Andres glastor-dev

GLASTOR® — Ingeniería de Sistemas, Backend & Arquitectura Crítica

Arquitecto Jefe en Rust & Python · Sistemas Distribuidos de Ultra-Baja Latencia · DevSecOps & Edge Tooling

Note

⚡ Autonomous Living Profile: Este perfil es un artefacto de ingeniería vivo, autogenerado y validado en tiempo real con análisis AST de TypeScript, auditoría 4R (Risk, Readability, Reliability, Resilience) y despliegue continuo de su documentación técnica a GitHub Pages (mdBook).

🟢 Disponible para proyectos — Próximas aperturas: Diciembre 2026

🏢 GLASTOR® Core • 📖 Documentación Técnica (mdBook) • 📦 JSR Package • 💙 Sponsors • 📧 Contacto • 🌐 Website • 🎥 Demo

👋 Sobre mí

Arquitecto sistemas distribuidos de misión crítica, backends de ultra-baja latencia y herramientas de automatización en Rust, Python y runtimes modernos (Deno 2 / Bun) para empresas B2B en producción. Desde 2010 (+15 años de trayectoria y 150+ proyectos desplegados), transformo retos técnicos complejos en infraestructuras escalables de alto rendimiento, alto uptime y costos operativos optimizados.

Fundador, CEO & Arquitecto Jefe en GLASTOR® y GLASTOR® Core — Lidero la ingeniería directa —sin intermediarios— de motores de ejecución determinística, gateways Edge, análisis estático AST y pipelines DevSecOps que reducen latencias hasta un 90% y costos de infraestructura hasta un 40%.

"Andres entregó una solución de API que maneja 5,000 req/s con latencia p99 < 50ms. Su trabajo redujo nuestros costos de infraestructura significativamente."
— Dan Khasis
Chief Executive Officer and Founder, Route4Me

💼 Especialidades técnicas

✅ Sistemas Críticos en Rust & Python — Microservicios seguros en memoria y APIs (FastAPI/Django) optimizadas para alto tráfico (5K+ req/s, p99 < 50ms)
✅ Edge Runtimes & Developer Tooling — Motores de alto rendimiento y baja latencia sobre Deno 2, Bun y TypeScript AST
✅ DevSecOps & CI Predictivo — Pipelines y orquestación inteligente que reducen tiempos de despliegue un 75% (30min → 7min)
✅ Infraestructura Cloud & Contenedores — Arquitecturas Docker, Kubernetes y AWS diseñadas para escalado horizontal y alta disponibilidad (HPC)

🔭 Actualmente trabajando en

🚀 Ecosistema Deno 2 & JSR — Generador de READMEs de alto rendimiento con análisis AST y plugins modulares (@glastor-dev/readmegen)
🏛️ Plataforma GLASTOR® Core — Sistemas distribuidos y motores Edge/CI: glastor-core, nemesis (DevSecOps), vortex (Predictive AST CI), zerho (Edge Docs), medusa (Edge API Gateway) y hyper-flow (Edge AI API)
🤖 Herramientas AI-Ready — Integración nativa del estándar llms.txt y pipelines de automatización
🧪 Smart injection engine — Template engine inteligente que reduce boilerplate 60%
📝 Contenido técnico — Serie sobre arquitectura de APIs, optimización p99 y patrones backend
🤝 Open Source — Aceptando contribuciones en herramientas de developer experience (ver CONTRIBUTING)

✨ Disponible para

Arquitectura e Ingeniería B2B en sistemas críticos, migraciones a Rust/Python y optimización de latencia/costos cloud
Code review & Auditoría DevSecOps en infraestructuras Rust, Python/FastAPI y TypeScript (Deno/Bun)
Desarrollo de motores core, tooling interno, CLI tools y automatizaciones determinísticas
Technical writing y arquitectura de portales de documentación (mdBook, OpenAPI 3.1, llms.txt)
Proyectos Open Source — Issues, RFCs y PRs bienvenidos en GLASTOR® Core

🛠️ Stack Tecnológico

Backend, Sistemas & Runtimes:

Frameworks, APIs & WebGL:

DevSecOps, Cloud & Edge Infra:

Databases, Caching & Developer Tooling:

🎓 Certificaciones & Aprendizaje

🏆 AWS Solutions Architect & DevOps Specialist (Arquitecturas cloud y microservicios)
📚 Especialización continua: Kubernetes (CKA), Advanced PostgreSQL Performance Tuning
🎯 Enfoque técnico: Rust (Tokio/Axum), FastAPI patterns, AsyncIO, Deno 2 / Bun Edge Runtimes, Distributed Systems & AI Agents

📊 GitHub Stats & Activity

📈 Ver métricas completas e historial de actividad

💙 Sponsors, Casos de Éxito & Ecosistema

Empresas con las que hemos desplegado sistemas críticos en producción y proyectos Open Source del ecosistema:

Nexperia _{Automatización de pipeline de testing para semiconductores}	Aspid Cars _{Sistema de gestión de inventario y logística}	Route4Me _{API de geolocalización y routing en tiempo real}
Rizin _{Contribuciones al framework de ingeniería inversa}	Neovim _{Plugins y contribuciones al ecosistema}	¿Tu empresa? _{Apoya el ecosistema con Factura E / Factura A}

Impacto comprobado: +15 años en producción (desde 2010) • 150+ proyectos desplegados • Arquitecturas de 5K+ req/s (p99 < 50ms) • Hasta 40% ahorro en infraestructura

👉 📄 Ver Programa Completo de Sponsorship, Tiers Corporativos y Facturación Fiscal (SPONSORS.md) →
_{Emitimos Factura E de Exportación de Servicios (USD/EUR para empresas internacionales) y Factura A / B (IVA Responsable Inscripto en Argentina).}

🏆 Contributors Hall of Fame:

Agradecemos a todos nuestros contributors:

Ver todos los contributors →

📫 Contacto & Enlaces

💼 Disponible para proyectos freelance, consultoría técnica y colaboraciones
📧 Tiempo de respuesta promedio: < 24 horas (normalmente < 6h)
🗓️ Agendar llamada de 30min (gratis, sin compromiso)

🔗 Más recursos:

🌐 Website

📖 Documentación Técnica & Arquitectura (Motor Autónomo)

💡 Portal Completo de Arquitectura: Accede al manual técnico completo, diagramas de módulos y guías en el portal oficial: glastor-dev.github.io/glastor-dev

📐 Architecture & Module Graph

graph TD
    src_generators_api_ts["src/generators/api.ts"]
    src_parsers_source_code_ts["src/parsers/source_code.ts"]
    src_generators_badges_ts["src/generators/badges.ts"]
    src_generators_doc_coverage_ts["src/generators/doc_coverage.ts"]
    src_generators_examples_ts["src/generators/examples.ts"]
    src_generators_llms_ts["src/generators/llms.ts"]
    src_parsers_deno_json_ts["src/parsers/deno_json.ts"]
    src_utils_user_config_ts["src/utils/user_config.ts"]
    src_generators_mermaid_ts["src/generators/mermaid.ts"]
    src_generators_toc_ts["src/generators/toc.ts"]
    src_main_ts["src/main.ts"]
    src_mod_ts["src/mod.ts"]
    src_utils_init_wizard_ts["src/utils/init_wizard.ts"]
    src_utils_logger_ts["src/utils/logger.ts"]
    src_project_analyze_ts["src/project/analyze.ts"]
    src_templates_load_ts["src/templates/load.ts"]
    src_templates_render_ts["src/templates/render.ts"]
    src_utils_file_system_ts["src/utils/file_system.ts"]
    src_parsers_imports_ts["src/parsers/imports.ts"]
    src_parsers_import_map_ts["src/parsers/import_map.ts"]
    src_parsers_project_files_ts["src/parsers/project_files.ts"]
    src_parsers_source_code_ast_ts["src/parsers/source_code_ast.ts"]
    src_parsers_workflows_ts["src/parsers/workflows.ts"]
    src_parsers_tests_ts["src/parsers/tests.ts"]
    src_utils_readme_infer_ts["src/utils/readme_infer.ts"]
    src_generators_api_ts --> src_parsers_source_code_ts
    src_generators_doc_coverage_ts --> src_parsers_source_code_ts
    src_generators_examples_ts --> src_parsers_source_code_ts
    src_generators_llms_ts --> src_parsers_deno_json_ts
    src_generators_llms_ts --> src_parsers_source_code_ts
    src_generators_llms_ts --> src_utils_user_config_ts
    src_main_ts --> src_mod_ts
    src_main_ts --> src_utils_init_wizard_ts
    src_main_ts --> src_utils_logger_ts
    src_mod_ts --> src_project_analyze_ts
    src_mod_ts --> src_templates_load_ts
    src_mod_ts --> src_templates_render_ts
    src_mod_ts --> src_utils_file_system_ts
    src_parsers_source_code_ast_ts --> src_parsers_source_code_ts
    src_parsers_source_code_ts --> src_parsers_source_code_ast_ts
    src_project_analyze_ts --> src_generators_api_ts
    src_project_analyze_ts --> src_generators_badges_ts
    src_project_analyze_ts --> src_generators_doc_coverage_ts
    src_project_analyze_ts --> src_generators_examples_ts
    src_project_analyze_ts --> src_generators_llms_ts
    src_project_analyze_ts --> src_generators_mermaid_ts
    src_project_analyze_ts --> src_generators_toc_ts
    src_project_analyze_ts --> src_parsers_deno_json_ts
    src_project_analyze_ts --> src_parsers_import_map_ts
    src_project_analyze_ts --> src_parsers_imports_ts
    src_project_analyze_ts --> src_parsers_project_files_ts
    src_project_analyze_ts --> src_parsers_source_code_ts
    src_project_analyze_ts --> src_parsers_tests_ts
    src_project_analyze_ts --> src_parsers_workflows_ts
    src_project_analyze_ts --> src_utils_readme_infer_ts
    src_project_analyze_ts --> src_utils_user_config_ts
    src_utils_init_wizard_ts --> src_utils_logger_ts

📚 API Reference (AST Autogenerated)

scripts/code_review.ts

calculateReviewResult

Type: function
Signature: calculateReviewResult(findings: Finding[], filesAnalyzed: string[]): ReviewResult

Finding

Type: interface

formatMarkdown

Type: function
Signature: formatMarkdown(result: ReviewResult): string

formatTerminal

Type: function
Signature: formatTerminal(result: ReviewResult): string

Pillar

Type: type

PillarScore

Type: interface

reviewFile

Type: function
Signature: reviewFile(filePath: string, content: string): Finding[]

ReviewResult

Type: interface

Severity

Type: type

src/generators/api.ts

generateApiDocs

Type: function
Signature: generateApiDocs(exports: ExportInfo[], projectRoot: string = Deno.cwd()): string

src/generators/badges.ts

BadgesConfig

Type: interface

generateBadges

Type: function
Signature: generateBadges(_config: BadgesConfig): string

generateRepoBadges

Type: function
Signature: generateRepoBadges(config: RepoBadgesConfig): string

generateVisitorBadge

Type: function
Signature: generateVisitorBadge(config: VisitorBadgeConfig): string

RepoBadgesConfig

Type: interface

VisitorBadgeConfig

Type: interface

src/generators/doc_coverage.ts

calculateDocCoverage

Type: function
Signature: calculateDocCoverage(exports: ExportInfo[]): DocCoverageResult

DocCoverageResult

Type: interface

src/generators/examples.ts

ExamplesOptions

Type: interface

ExamplesResult

Type: interface

generateExamples

Type: function (async)
Signature: async generateExamples(projectRoot: string, exports: ExportInfo[], options: ExamplesOptions = {}): Promise<ExamplesResult>

src/generators/llms.ts

generateLlmsTxt

Type: function (async)
Signature: async generateLlmsTxt(options: LlmsTxtOptions): Promise<string>

LlmsTxtOptions

Type: interface

src/generators/mermaid.ts

generateMermaidGraph

Type: function (async)
Signature: async generateMermaidGraph(projectRoot: string, options: MermaidGraphOptions = {}): Promise<string>

MermaidGraphOptions

Type: interface

src/generators/toc.ts

generateToc

Type: function
Signature: generateToc(options: TocOptions): string

TocOptions

Type: interface

src/mod.ts

generateReadme

Generates the README documentation for the project by analyzing AST and rendering templates.

Type: function (async)
Signature: async generateReadme(args: GenerateReadmeArgs): Promise<void>
Params:
- args - Configuration options including template style, output file, and force flag.
Returns - A promise that resolves when the README and related artifacts are generated.

await generateReadme({ template: "modern", output: "README.md", force: true });

GenerateReadmeArgs

Arguments for generating the project README

Type: interface

sanitizeGeneratedMarkdown

Normalizes and cleans generated Markdown text by stripping BOM, removing accidental trash code, and ensuring banner images are positioned at the document header.

Type: function
Signature: sanitizeGeneratedMarkdown(markdown: string): string
Params:
- markdown - Raw generated markdown content.
Returns - Cleaned and sanitized markdown string.

TemplateName

Supported README template styles

Type: type

src/parsers/deno_json.ts

DenoConfig

Type: interface

readDenoConfig

Type: function (async)
Signature: async readDenoConfig(projectRoot: string): Promise<DenoConfig | null>

src/parsers/import_map.ts

ImportMap

Type: interface

readImportMap

Type: function (async)
Signature: async readImportMap(projectRoot: string): Promise<ImportMap | null>

src/parsers/imports.ts

analyzeImports

Type: function (async)
Signature: async analyzeImports(projectRoot: string, options: AnalyzeImportsOptions = {}): Promise<ImportAnalysis>

AnalyzeImportsOptions

Type: interface

ImportAnalysis

Type: interface

src/parsers/project_files.ts

detectProjectFiles

Type: function (async)
Signature: async detectProjectFiles(projectRoot: string): Promise<string[]>

src/parsers/source_code.ts

ExportInfo

Type: interface

ExportType

Type: type

extractExports

Type: function (async)
Signature: async extractExports(filePath: string): Promise<ExportInfo[]>

extractExportsFromProject

Type: function (async)
Signature: async extractExportsFromProject(projectRoot: string, options: ExtractOptions = {}): Promise<ExportInfo[]>

ExtractOptions

Type: interface

JSDocParam

Type: interface

src/parsers/source_code_ast.ts

extractExportsAst

Type: function (async)
Signature: async extractExportsAst(filePath: string): Promise<ExportInfo[]>

extractExportsAstFromCode

Type: function
Signature: extractExportsAstFromCode(code: string, filePath: string): ExportInfo[]

JSDocInfo

Type: interface

src/parsers/workflows.ts

detectWorkflows

Type: function (async)
Signature: async detectWorkflows(projectRoot: string): Promise<string[]>

src/project/analyze.ts

analyzeProject

Type: function (async)
Signature: async analyzeProject(options: AnalyzeProjectOptions): Promise<ProjectAnalysis>

AnalyzeProjectOptions

Type: interface

ProjectAnalysis

Type: interface

TemplateData

Type: interface

src/utils/file_system.ts

ensureWritableOutput

Type: function (async)
Signature: async ensureWritableOutput(outputPath: string, options: { force: boolean }): Promise<void>

src/utils/init_wizard.ts

runInitWizard

Type: function (async)
Signature: async runInitWizard(projectRoot: string)

src/utils/logger.ts

Logger

Type: const
Signature: const Logger

src/utils/readme_infer.ts

inferDescriptionFromReadme

Type: function (async)
Signature: async inferDescriptionFromReadme(readmePath: string): Promise<string | null>

src/utils/user_config.ts

loadUserConfig

Type: function (async)
Signature: async loadUserConfig(projectRoot: string): Promise<UserConfig>

UserConfig

Type: interface

Ver docs completas: API Documentation

📦 Dependencies & Tech Stack

Runtime & Installation

Deno >= 2.1.0 (recommended: latest stable)
TypeScript 5.x (bundled with Deno)

# Via Deno 2 (JSR)
deno install -g -A -n readmegen jsr:@glastor-dev/readmegen

# O ejecución directa sin instalación previa:
deno run -A jsr:@glastor-dev/readmegen

Detected Project Dependencies & Manifests

Config files

deno.json/deno.jsonc
import_map.json

Project files

Dockerfile
LICENSE

Standard Library

jsr:@std/fs@^1.0.0/exists
jsr:@std/fs@^1.0.0/walk
jsr:@std/jsonc@^1.0.0/parse
jsr:@std/path@^1.0.0/dirname
jsr:@std/path@^1.0.0/extname
jsr:@std/path@^1.0.0/glob-to-regexp
jsr:@std/path@^1.0.0/join
jsr:@std/path@^1.0.0/relative

Third-party

jsr:@cliffy/ansi@1.0.0-rc.7/colors
jsr:@cliffy/command@1.0.0-rc.7
jsr:@cliffy/prompt@1.0.0-rc.7
npm:typescript@^5.7.0

🔧 Development Setup & Toolbox

🖥️ Entorno de Desarrollo

Sistemas Operativos:

🐧 Arch Linux (principal) — Kernel 6.x custom
- Terminal: Xterm + Zsh + Oh-My-Zsh
- WM: i3-gaps con Polybar
- Terminal alternativo: eDEX-UI (cyberpunk style)
🪟 Windows 10 Pro (testing)
- Terminal: Windows Terminal + Git Bash
- WSL2: Ubuntu 22.04 LTS

Editores & IDEs:

💻 VS Code (principal) — Extensions:
- Python, Deno, ESLint, Prettier
- GitLens, Docker, Thunder Client
- Quimera Theme (propio)
⚡ Neovim — Para edición rápida y remota
- Config: LazyVim + custom plugins
- LSP: pyright, tsserver, rust-analyzer

Version Control:

🦑 GitKraken PRO — GUI para operaciones complejas
🔧 Git CLI — Para automation y scripts
📊 GitHub Desktop — Para quick commits

🎯 Áreas de Especialización

Backend, Sistemas Críticos & APIs:

Microservicios en Rust (Tokio, Axum, memoria segura y concurrencia sin data races)
FastAPI & Django REST Framework patterns de ultra-baja latencia
Edge Runtimes & Gateways con Deno 2, Bun y Hono
gRPC, GraphQL (Strawberry/Ariadne) y OpenAPI 3.1

DevOps & Infrastructure:

Docker multi-stage builds
Docker Compose orchestration
GitHub Actions workflows
AWS (EC2, Lambda, RDS, S3)
Terraform (IaC)

Security & Cryptography:

OWASP Top 10 mitigation
JWT/OAuth2 implementation
Encryption (AES, RSA)
Penetration testing basics
Secure coding practices

AI/ML & Automation:

Prompt Engineering (GPT-4, Claude)
LangChain for AI workflows
OpenAI API integration
Automation scripts (Python, Bash)
Web scraping (Beautiful Soup, Scrapy)

Documentation & Technical Writing:

API documentation (OpenAPI/Swagger)
Technical blog writing
Video tutorial creation
Code documentation standards

📚 Lecturas & Formación Continua

Libros técnicos recientes:

✅ The Pragmatic Programmer (20th Anniversary)
✅ Clean Architecture — Robert C. Martin
✅ Designing Data-Intensive Applications — Martin Kleppmann
📖 Building Microservices (2nd ed.) — En progreso
📖 Site Reliability Engineering — Google (En progreso)

Cursos & Certificaciones en proceso:

🎓 AWS Solutions Architect Associate (Completado)
🎓 Certified Kubernetes Administrator (CKA) (En preparación)
📚 FastAPI Advanced Patterns & AI Agent Architectures

Podcasts favoritos:

🎙️ Talk Python To Me
🎙️ Python Bytes
🎙️ The Changelog
🎙️ Software Engineering Daily

📋 Políticas del Proyecto

💙 Sponsors • 📞 Soporte • 🔒 Seguridad • ⚖️ Código de Conducta • 📜 Licencia

2025 GLASTOR® marca registrada en Argentina (INPI)
Reg. 4559568 (Clase 42) y 4559567 (Clase 35) — Fecha: 19/08/2025

Licencia Dual:

Código de la herramienta: Licenciado bajo GNU GPL v3.0
Textos generados y plantillas: Licenciados bajo Creative Commons Attribution 4.0 (CC BY 4.0)

_{🤖 README generado automáticamente • Versión 2.2.0 • Última actualización: 2026-11-05}
_{⭐ Si este proyecto te fue útil, considera darle una estrella en GitHub}