Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/santiagonieto09/portafolio/llms.txt

Use this file to discover all available pages before exploring further.

The domain layer in src/domain/github/types.ts defines all data contracts used across the application. These interfaces are framework-agnostic — no React, no fetch, no GitHub SDK details appear here. Every other layer (GitHub API adapter, repository query engine, server-side loaders, and UI components) imports from this single source of truth, so changing a field name in one place surfaces all call-sites that need updating at compile time.
SocialLink represents a single social-media or contact link attached to a developer’s profile. The kind field is a narrow union type so the UI can render the correct icon without any string-matching heuristics.
interface SocialLink {
  kind: 'github' | 'linkedin' | 'x' | 'instagram' | 'facebook' | 'youtube' | 'website' | 'blog' | 'email';
  label: string;
  url: string;
}
kind
'github' | 'linkedin' | 'x' | 'instagram' | 'facebook' | 'youtube' | 'website' | 'blog' | 'email'
required
Discriminant that identifies the platform or link category. The UI maps each variant to a dedicated icon component, so the rendering layer never needs to inspect the URL itself.
label
string
required
Human-readable display text for the link, e.g. "@santiagonieto09" or "Portfolio". Shown as link text or a tooltip in the profile card.
url
string
required
Fully-qualified URL of the social profile or contact destination, e.g. "https://github.com/santiagonieto09". For kind: 'email' this will be a mailto: URI.

Profile

Profile holds the public information about the portfolio owner as returned by the GitHub Users API and enriched with parsed social links. It is the first field on every PortfolioSnapshot and is used directly by the hero section, the profile card, and page <meta> tags for SEO.
interface Profile {
  login: string;
  name: string;
  avatarUrl: string;
  bio: string | null;
  location: string | null;
  company: string | null;
  blog: string | null;
  email: string | null;
  publicRepos: number;
  followers: number;
  following: number;
  createdAt: string; // ISO 8601
  htmlUrl: string;
  socials: SocialLink[];
}
login
string
required
GitHub username (case-sensitive slug), e.g. "santiagonieto09". Used as the primary identifier when constructing GitHub API URLs.
name
string
required
Display name as set on the GitHub profile, e.g. "Santiago Nieto". Shown as the primary heading in the hero section.
avatarUrl
string
required
Absolute URL to the GitHub avatar image. Passed directly to an <img> element; no resizing proxy is needed because GitHub CDN supports ?s= query-string size hints.
bio
string | null
required
Short biography entered on the GitHub profile settings page. Rendered below the display name; the UI hides this element when the value is null.
location
string | null
required
Free-text location string, e.g. "Medellín, Colombia". Displayed with a pin icon in the profile card; omitted when null.
company
string | null
required
Organisation or employer name as entered on GitHub. May contain an @ prefix for GitHub organisation handles. Omitted when null.
blog
string | null
required
Raw blog or website URL from the GitHub profile’s “Website” field. Note: a cleaned-up version of this value also appears in socials when it is non-null.
email
string | null
required
Public email address. GitHub only exposes this when the user has chosen to make it public. Used to generate a mailto: entry in socials.
publicRepos
number
required
Total count of public repositories owned by this account. Shown in the statistics bar alongside followers and following counts.
followers
number
required
Number of GitHub accounts following this user. Shown in the statistics bar.
following
number
required
Number of GitHub accounts this user follows. Shown in the statistics bar.
createdAt
string
required
ISO 8601 timestamp of when the GitHub account was created, e.g. "2019-03-15T14:23:00Z". Used to display account age or a “member since” label.
htmlUrl
string
required
Full URL to the public GitHub profile page, e.g. "https://github.com/santiagonieto09". Used as the href for the GitHub social link.
socials
SocialLink[]
required
Array of parsed social links derived from the profile’s social-accounts endpoint and other public profile fields (blog, email, htmlUrl). The adapter layer normalises raw GitHub social entries into typed SocialLink objects before this field is populated.

ReleaseInfo

ReleaseInfo captures the most recent GitHub release attached to a repository. It is embedded directly inside Repository so consumers never have to make a second lookup to display release metadata.
interface ReleaseInfo {
  name: string;         // release title or tag_name if no title
  tag: string;          // git tag (e.g. 'v1.2.0')
  publishedAt: string | null; // ISO 8601 or null
  url: string;          // GitHub release page URL
}
name
string
required
Human-readable release title. When the release author left the title blank on GitHub, the adapter falls back to the raw tag_name string so this field is never empty.
tag
string
required
The Git tag associated with this release, e.g. "v1.2.0". Displayed as a badge on repository cards and used to link directly to the tagged diff on GitHub.
publishedAt
string | null
required
ISO 8601 timestamp of when the release was published. Draft releases that have never been published will have null here; the UI omits the date in that case.
url
string
required
Direct URL to the GitHub Releases page for this specific release, e.g. "https://github.com/santiagonieto09/my-project/releases/tag/v1.2.0".

Repository

Repository is the central data type of the portfolio. Each object represents one public GitHub repository enriched with language byte-counts, detected technologies, and the latest release. The repository explorer renders one card per Repository and the filtering/sorting engine in repository-query.ts operates exclusively on arrays of this type.
interface Repository {
  id: number;
  name: string;
  description: string | null;
  htmlUrl: string;
  homepage: string | null;
  language: string | null;       // primary language
  languages: Record<string, number>; // language -> bytes
  technologies: string[];         // detected frameworks/tools
  stars: number;
  forks: number;
  watchers: number;
  openIssues: number;
  archived: boolean;
  visibility: string;             // 'public' | 'private' | 'internal'
  createdAt: string;
  updatedAt: string;
  pushedAt: string;
  topics: string[];
  hasPages: boolean;
  license: string | null;        // SPDX identifier
  release: ReleaseInfo | null;
}
id
number
required
GitHub’s internal numeric repository ID. Stable across renames, used as a React list key.
name
string
required
Repository slug, e.g. "portafolio". Combined with the owner’s login to build API and web URLs.
description
string | null
required
Short description entered in the repository settings. Rendered in the card body; the card omits the description element when this is null.
htmlUrl
string
required
Canonical GitHub web URL for the repository, e.g. "https://github.com/santiagonieto09/portafolio". Used for the “View on GitHub” link and as input to docsUrlFor.
homepage
string | null
required
Optional URL for a live demo or project website as entered in the repository settings. When non-null, a “Live site” button is rendered on the card.
language
string | null
required
Primary programming language as determined by GitHub’s Linguist library (the language with the largest byte share). Used as a quick label; for full breakdown see languages.
languages
Record<string, number>
required
Map of language name to byte count across all tracked files, e.g. { "TypeScript": 42300, "CSS": 8100 }. The adapter fetches this from the separate /languages endpoint and merges it in. Powers the LanguageSlice chart and the language filter dropdown.
technologies
string[]
required
Ordered list of frameworks, libraries, and tools inferred by detectTechnologies in src/domain/github/technology-detection.ts. Includes both raw language names and framework labels such as "React" or "Docker". Used by the technology filter dropdown and rendered as tag chips on each repository card.
stars
number
required
GitHub stargazer count. Used in the stats bar and as one of the available sort keys.
forks
number
required
Number of times this repository has been forked. Shown in the card metadata row.
watchers
number
required
Number of users watching the repository for notifications. Shown in the card metadata row.
openIssues
number
required
Count of open issues (and open pull requests, as GitHub’s API combines them). Shown in the card metadata row.
archived
boolean
required
true when the repository has been archived on GitHub (read-only). An “Archived” badge is rendered on the card and the onlyArchived / onlyActive query filters rely on this field.
visibility
string
required
Repository visibility level. One of 'public', 'private', or 'internal' (the latter only for GitHub organisation repositories). In practice only public repos appear in the portfolio, but the field is preserved for completeness.
createdAt
string
required
ISO 8601 timestamp of repository creation. Used by the 'created' sort key in applyQuery.
updatedAt
string
required
ISO 8601 timestamp of the last metadata update (e.g. description change). Distinct from pushedAt, which tracks actual code pushes.
pushedAt
string
required
ISO 8601 timestamp of the last Git push to any branch. This is the timestamp used by the default 'updated' sort key because it most accurately reflects recent coding activity.
topics
string[]
required
GitHub repository topics (tags) chosen by the owner, e.g. ["react", "typescript", "portfolio"]. Included in free-text search and used as signals by detectTechnologies.
hasPages
boolean
required
true when GitHub Pages is enabled for this repository. The UI may surface a Pages URL derived from the owner’s GitHub Pages domain.
license
string | null
required
SPDX license identifier string, e.g. "MIT" or "Apache-2.0". Rendered as a small label in the card footer; null means no license file was detected.
release
ReleaseInfo | null
required
The most recent published GitHub release, or null if none exists. When non-null, a release badge is shown on the card and the onlyWithRelease filter will include this repository.

LanguageSlice

LanguageSlice is a pre-computed aggregate used by the language breakdown chart in the portfolio stats section. Rather than forcing the UI to recalculate percentages from raw byte counts on every render, the adapter layer (or a selector) produces one LanguageSlice per language from the full collection of repositories.
interface LanguageSlice {
  name: string;
  bytes: number;
  percentage: number;   // 0-100, 1 decimal
  repoCount: number;
  color: string;        // hex color
}
name
string
required
Programming language name, matching the keys used in Repository.languages, e.g. "TypeScript" or "Java".
bytes
number
required
Total byte count for this language summed across all repositories in the snapshot.
percentage
number
required
Share of total bytes expressed as a percentage between 0 and 100, rounded to one decimal place, e.g. 34.7. The sum of all slices’ percentages equals 100.
repoCount
number
required
Number of repositories that contain at least one byte of this language. Shown as a sub-label in the language chart tooltip.
color
string
required
Hex colour string for this language, e.g. "#3178c6" for TypeScript. Sourced from the languageColor function in src/domain/github/language-colors.ts, which uses GitHub Linguist colours with a deterministic hash fallback for unknown languages.

PortfolioStats

PortfolioStats is the rolled-up numerical summary for the entire portfolio. It is computed once per PortfolioSnapshot and fed directly to the stats bar and language chart components. Keeping it separate from PortfolioSnapshot makes it easy to memoize or cache independently.
interface PortfolioStats {
  totalRepos: number;
  totalStars: number;
  totalForks: number;
  totalReleases: number;
  activeRepos: number;
  archivedRepos: number;
  languages: LanguageSlice[];
  lastSyncedAt: string; // ISO 8601
}
totalRepos
number
required
Count of all repositories included in the snapshot (public, non-forked by default depending on adapter configuration).
totalStars
number
required
Sum of stars across all repositories. Displayed as a headline metric in the stats bar.
totalForks
number
required
Sum of forks across all repositories. Displayed alongside totalStars in the stats bar.
totalReleases
number
required
Count of repositories that have at least one published release (i.e. release !== null). Shown as a “Releases published” metric.
activeRepos
number
required
Count of repositories where archived === false. Together with archivedRepos this should equal totalRepos.
archivedRepos
number
required
Count of repositories where archived === true.
languages
LanguageSlice[]
required
Ordered array of language slices (highest percentage first) used to render the language breakdown chart. See the LanguageSlice interface for field details.
lastSyncedAt
string
required
ISO 8601 timestamp of when this snapshot was generated. Displayed as a “Last updated” label so visitors know how fresh the data is.

ActivityItem

ActivityItem represents a single entry in the GitHub public events feed for the portfolio owner. The adapter maps raw GitHub event payloads (which vary wildly by type) into a uniform summary string, making the UI completely event-type-agnostic.
interface ActivityItem {
  id: string;
  type: string;         // GitHub event type (e.g. 'PushEvent')
  repoName: string;     // 'owner/repo' format
  repoUrl: string;
  branch: string | null;
  createdAt: string;
  summary: string;      // human-readable description
}
id
string
required
GitHub’s unique event ID string. Used as a React list key in the activity feed.
type
string
required
Raw GitHub event type string, e.g. "PushEvent", "CreateEvent", "IssuesEvent". The UI can use this to render a contextual icon alongside the summary text.
repoName
string
required
Repository identifier in owner/repo format, e.g. "santiagonieto09/portafolio". Displayed as a link label in the activity feed.
repoUrl
string
required
Full GitHub URL for the repository, used as the href on the repoName link.
branch
string | null
required
Branch name associated with the event (e.g. "main" for a PushEvent). Not all event types have a meaningful branch; the field is null for events like WatchEvent or ForkEvent.
createdAt
string
required
ISO 8601 timestamp of when the event occurred. Used to render a relative time label such as “3 days ago”.
summary
string
required
Human-readable sentence describing the event, e.g. "Pushed 3 commits to main" or "Opened issue #12". Generated by the adapter so the UI never has to parse raw GitHub payloads.

PortfolioSnapshot

PortfolioSnapshot is the root data structure returned by the server loader. It bundles everything the portfolio UI needs into a single object so that React components can be hydrated in one pass with no client-side waterfall fetches.
interface PortfolioSnapshot {
  profile: Profile;
  repositories: Repository[];
  stats: PortfolioStats;
  activity: ActivityItem[];
  degraded: boolean;    // true when GitHub API was unreachable
}
profile
Profile
required
Portfolio owner’s public GitHub profile. See the Profile interface above.
repositories
Repository[]
required
Full list of public repositories included in the portfolio, each enriched with language counts, detected technologies, and the latest release. This array is the primary input to applyQuery in the repository explorer.
stats
PortfolioStats
required
Pre-computed aggregate statistics derived from repositories. See PortfolioStats above.
activity
ActivityItem[]
required
Recent public activity events for the profile owner, normalised into uniform ActivityItem objects. The adapter fetches up to 30 events from the GitHub Events API and maps each one to this shape.
degraded
boolean
required
Set to true when the GitHub API was unreachable at snapshot build time and the application fell back to a cached or empty dataset. The UI renders a visible banner warning when this flag is true so visitors know the displayed data may be stale.

Build docs developers (and LLMs) love