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.

Instead of requiring manual tags on each repository, the portfolio infers technologies automatically using a rule set that maps GitHub-exposed signals (languages, topics, name, description) to framework and tool names. The result is stored in repo.technologies and used both by the filter dropdowns and the technology badges displayed on each repository card.

​
How it works

Source: src/domain/github/technology-detection.ts 
function detectTechnologies(input: {
  name: string;
  description: string | null;
  topics: string[];
  languages: string[];
  homepage: string | null;
}): string[]
The function works in four steps:
  1. Build a haystack — Concatenates name (with hyphens and underscores replaced by spaces), description, the topics array joined by spaces, and homepage into a single lowercase string. This is the text that keyword rules search through.
  2. Seed with raw languages — The found set is initialised with all entries from input.languages. This ensures the detected technologies array always includes the primary languages GitHub detected.
  3. Evaluate rules — Iterates over all 25 TechRule entries. A rule matches when either condition is true (short-circuit OR):
    • byLanguage — at least one of the rule’s languages[] entries is present in input.languages
    • byKeyword — at least one of the rule’s keywords[] entries appears as a substring in the lowercase haystack
    Matched tech names are added to the found set (deduplication is automatic via Set).
  4. Return — The Set is spread into a plain array and returned.

​
Rule table

All 25 rules defined in the RULES array:
TechnologyTrigger languagesTrigger keywords
Spring Boot—spring boot, springboot, spring-boot, spring
Spring Security—spring security, spring-security, jwt
Spring Cloud—eureka, spring cloud, gateway, microservi
JPA / Hibernate—jpa, hibernate
MavenJava—
Angular—angular
React—react, next.js, nextjs
FlutterDartflutter
Django—django
JinjaJinja—
Symfony—symfony
Laravel—laravel, blade
FastAPI—fastapi
Node.js—node, express, nest
DockerDockerfiledocker, contenedor
PostgreSQL—postgres, postgresql
MySQL—mysql, mariadb
MongoDB—mongo
REST API—api rest, rest api, api-rest, restful
GraphQL—graphql
IA / RAG—rag, llm, ia (with spaces), asistente de ia, openai, embedding
Tailwind CSS—tailwind
Vercel—vercel
RPC / RMI—rpc, rmi, distribuid
Android—android
Rules that have both a languages list and a keywords list (e.g. Flutter, Docker) match on either condition independently — a Dart repository without the word “flutter” anywhere will still be tagged as Flutter.

​
frameworksOnly helper

function frameworksOnly(technologies: string[], languages: string[]): string[]
detectTechnologies() seeds the result with raw language names (e.g. "TypeScript", "Java"). frameworksOnly() filters those out so that RepositoryCard only shows framework and tool badges — language information is already shown separately via the colored language dot. The collectTechnologies() function in repository-query.ts applies the same logic when building the framework dropdown for RepositoryFilters: 
export function collectTechnologies(repos: Repository[]): string[] {
  const languages = new Set(collectLanguages(repos));
  return [...new Set(repos.flatMap((r) => r.technologies))]
    .filter((t) => !languages.has(t))
    .sort((a, b) => a.localeCompare(b));
}

​
Adding new rules

The module follows the open/closed principle: to add detection for a new technology, append a TechRule object to the RULES array in src/domain/github/technology-detection.ts. No other code changes are required. 
{ tech: 'Prisma', keywords: ['prisma'] },
{ tech: 'Redis', keywords: ['redis'] },
A rule may specify languages, keywords, or both. At least one must be provided — a rule with neither condition would match every repository.
The haystack normalises hyphens and underscores in the repo name to spaces before matching (input.name.replace(/[-_]/g, " ")), so a repository named spring-boot-demo correctly triggers the Spring Boot rule even though the keyword is "spring boot" (with a space). This also means partial suffixes work: "microservi" matches "microservicio", "microservices", "microservidor", etc.

Build docs developers (and LLMs) love

Get started for freeTalk to us