@saulwade/swl-ses 1.0.0

package/hooks/lib/detectar-package-manager.js

@@ -0,0 +1,423 @@
+'use strict';
+const fs   = require('fs');
+const path = require('path');
+
+/**
+ * Detecta el package manager del proyecto basandose en archivos lock y config.
+ *
+ * El orden de las entradas en `checks` importa: los archivos de lock más
+ * específicos se comprueban antes que los genéricos (ej: bun.lockb antes que
+ * package-lock.json) para evitar falsos positivos en proyectos con múltiples
+ * manifiestos.
+ *
+ * @param {string} dir - Directorio raíz del proyecto.
+ * @returns {{ manager: string, lockfile: string|null, configfile: string }}
+ *   - manager:    nombre del gestor de dependencias detectado, o 'unknown'.
+ *   - lockfile:   nombre del archivo de lock encontrado, o null si no aplica.
+ *   - configfile: nombre del archivo de configuración principal del manager.
+ */
+function detectarPackageManager(dir) {
+  const checks = [
+    // --- JavaScript / TypeScript ---
+    { file: 'bun.lockb',          manager: 'bun',      config: 'package.json' },
+    { file: 'pnpm-lock.yaml',     manager: 'pnpm',     config: 'package.json' },
+    { file: 'yarn.lock',          manager: 'yarn',     config: 'package.json' },
+    { file: 'package-lock.json',  manager: 'npm',      config: 'package.json' },
+    // --- Python ---
+    { file: 'poetry.lock',        manager: 'poetry',   config: 'pyproject.toml' },
+    { file: 'Pipfile.lock',       manager: 'pipenv',   config: 'Pipfile' },
+    { file: 'requirements.txt',   manager: 'pip',      config: 'requirements.txt' },
+    { file: 'pyproject.toml',     manager: 'pip',      config: 'pyproject.toml' },
+    // --- Go ---
+    { file: 'go.sum',             manager: 'go',       config: 'go.mod' },
+    // --- Rust ---
+    { file: 'Cargo.lock',         manager: 'cargo',    config: 'Cargo.toml' },
+    // --- PHP ---
+    { file: 'composer.lock',      manager: 'composer', config: 'composer.json' },
+    // --- Ruby ---
+    { file: 'Gemfile.lock',       manager: 'bundler',  config: 'Gemfile' },
+    // --- JVM (Gradle / Maven) ---
+    // gradle.lockfile = dependency locking habilitado en Gradle
+    { file: 'gradle.lockfile',    manager: 'gradle',   config: 'build.gradle' },
+    // Detectar Gradle por el DSL Kotlin o Groovy antes de Maven para evitar
+    // proyectos que usan ambos (Android suele incluir pom.xml generados).
+    { file: 'build.gradle.kts',   manager: 'gradle',   config: 'build.gradle.kts' },
+    { file: 'build.gradle',       manager: 'gradle',   config: 'build.gradle' },
+    { file: 'pom.xml',            manager: 'maven',    config: 'pom.xml' },
+    // --- .NET ---
+    // packages.lock.json requiere <RestorePackagesWithLockFile>true</...> en el csproj.
+    { file: 'packages.lock.json', manager: 'nuget',    config: '*.csproj' },
+  ];
+
+  for (const check of checks) {
+    if (fs.existsSync(path.join(dir, check.file))) {
+      return {
+        manager:    check.manager,
+        lockfile:   check.file,
+        configfile: check.config,
+      };
+    }
+  }
+
+  // Fallback 1: detectar proyectos .NET por extensión de archivo de proyecto.
+  // No tienen un lockfile universal — la restauración NuGet puede omitirlo.
+  try {
+    const files = fs.readdirSync(dir);
+    if (files.some(f => f.endsWith('.csproj') || f.endsWith('.sln') || f.endsWith('.fsproj'))) {
+      return { manager: 'dotnet', lockfile: null, configfile: '*.csproj' };
+    }
+
+    // Fallback 2: Swift Package Manager — Package.resolved puede estar en
+    // .build/checkouts/ en versiones antiguas; buscamos solo Package.swift.
+    if (files.some(f => f === 'Package.swift')) {
+      return {
+        manager:    'spm',
+        lockfile:   'Package.resolved',
+        configfile: 'Package.swift',
+      };
+    }
+  } catch (_) {
+    // Si no se puede leer el directorio (permisos, etc.) caemos al unknown.
+  }
+
+  return { manager: 'unknown', lockfile: null, configfile: 'unknown' };
+}
+
+/**
+ * Detecta todos los lenguajes de programación presentes en un proyecto
+ * escaneando las extensiones de archivo de forma recursiva hasta 3 niveles.
+ *
+ * Directorios excluidos del escaneo:
+ *   .git, node_modules, vendor, target, bin, .venv, __pycache__, dist, build
+ *
+ * @param {string} dir - Directorio raíz del proyecto.
+ * @returns {string[]} Lista de lenguajes detectados, ordenada alfabéticamente.
+ */
+function detectarLenguajes(dir) {
+  const lenguajes = new Set();
+
+  /** @type {Record<string, string>} Mapa extensión → nombre de lenguaje */
+  const extensiones = {
+    '.py':   'python',
+    '.pyw':  'python',
+    '.js':   'javascript',
+    '.mjs':  'javascript',
+    '.cjs':  'javascript',
+    '.ts':   'typescript',
+    '.tsx':  'typescript',
+    '.java': 'java',
+    '.go':   'go',
+    '.rs':   'rust',
+    '.cs':   'csharp',
+    '.kt':   'kotlin',
+    '.kts':  'kotlin',
+    '.swift':'swift',
+    '.php':  'php',
+    '.rb':   'ruby',
+    '.cpp':  'cpp',
+    '.cc':   'cpp',
+    '.cxx':  'cpp',
+    '.h':    'cpp',
+    '.hpp':  'cpp',
+    '.dart': 'dart',
+  };
+
+  const DIRS_IGNORADOS = new Set([
+    '.git', 'node_modules', 'vendor', 'target', 'bin',
+    '.venv', '__pycache__', 'dist', 'build', '.next',
+    '.nuxt', 'out', '.output',
+  ]);
+
+  /**
+   * Escanea un directorio de forma recursiva hasta la profundidad indicada.
+   *
+   * @param {string} d
+   * @param {number} depth
+   */
+  function scanDir(d, depth) {
+    if (depth > 3) return;
+    try {
+      for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+        if (entry.name.startsWith('.') || DIRS_IGNORADOS.has(entry.name)) continue;
+        if (entry.isDirectory()) {
+          scanDir(path.join(d, entry.name), depth + 1);
+        } else {
+          const ext = path.extname(entry.name).toLowerCase();
+          if (extensiones[ext]) lenguajes.add(extensiones[ext]);
+        }
+      }
+    } catch (_) {
+      // Permisos denegados u otros errores de I/O — continuar con lo detectado.
+    }
+  }
+
+  scanDir(dir, 0);
+  return Array.from(lenguajes).sort();
+}
+
+// ---------------------------------------------------------------------------
+// Detección de tecnologías específicas (inspirado en autoskills)
+// ---------------------------------------------------------------------------
+
+/**
+ * Mapa de tecnologías detectables con sus patrones y skills SWL asociados.
+ * Cada entrada define cómo detectar la tecnología y qué skills SWL cargar.
+ *
+ * Estrategias de detección:
+ *   - packages: buscar en dependencies/devDependencies de package.json
+ *   - configFiles: existencia de archivos de configuración
+ *   - configContent: buscar patrones dentro de archivos
+ *   - languages: lenguajes detectados por detectarLenguajes()
+ */
+const TECH_MAP = [
+  // --- Frameworks Python ---
+  { id: 'fastapi',       name: 'FastAPI',        detect: { packages: ['fastapi', 'uvicorn'] },
+    skills: ['fastapi-experto', 'async-python', 'api-rest-diseno'], agente: 'backend-python-swl' },
+  { id: 'django',        name: 'Django',         detect: { packages: ['django', 'djangorestframework'], configFiles: ['manage.py'] },
+    skills: ['django-experto', 'patrones-python'], agente: 'backend-python-swl' },
+  { id: 'flask',         name: 'Flask',          detect: { packages: ['flask'] },
+    skills: ['patrones-python', 'api-rest-diseno'], agente: 'backend-python-swl' },
+  { id: 'sqlalchemy',    name: 'SQLAlchemy',     detect: { packages: ['sqlalchemy', 'alembic'] },
+    skills: ['postgresql-experto', 'async-python'], agente: 'backend-python-swl' },
+  { id: 'celery',        name: 'Celery',         detect: { packages: ['celery'] },
+    skills: ['async-python'], agente: 'backend-workers-swl' },
+
+  // --- Frameworks Node/TS ---
+  { id: 'nextjs',        name: 'Next.js',        detect: { packages: ['next'], configFiles: ['next.config.js', 'next.config.mjs', 'next.config.ts'] },
+    skills: ['nextjs-experto', 'nextjs-patrones', 'nextjs-testing', 'react-experto'], agente: 'frontend-react-swl' },
+  { id: 'react',         name: 'React',          detect: { packages: ['react', 'react-dom'] },
+    skills: ['react-experto', 'react-optimizacion'], agente: 'frontend-react-swl' },
+  { id: 'angular',       name: 'Angular',        detect: { packages: ['@angular/core'], configFiles: ['angular.json'] },
+    skills: ['angular-moderno', 'angular-avanzado'], agente: 'frontend-angular-swl' },
+  { id: 'vue',           name: 'Vue',            detect: { packages: ['vue', 'nuxt'] },
+    skills: [], agente: 'frontend-swl' },
+  { id: 'svelte',        name: 'Svelte',         detect: { packages: ['svelte', '@sveltejs/kit'] },
+    skills: [], agente: 'frontend-swl' },
+  { id: 'express',       name: 'Express',        detect: { packages: ['express'] },
+    skills: ['node-experto', 'typescript-avanzado'], agente: 'backend-node-swl' },
+  { id: 'nestjs',        name: 'NestJS',         detect: { packages: ['@nestjs/core'] },
+    skills: ['node-experto', 'typescript-avanzado'], agente: 'backend-node-swl' },
+  { id: 'fastify',       name: 'Fastify',        detect: { packages: ['fastify'] },
+    skills: ['node-experto', 'typescript-avanzado'], agente: 'backend-node-swl' },
+
+  // --- CSS/UI ---
+  { id: 'tailwind',      name: 'Tailwind CSS',   detect: { packages: ['tailwindcss', '@tailwindcss/vite'], configFiles: ['tailwind.config.js', 'tailwind.config.ts'] },
+    skills: ['tailwind-experto', 'css-moderno'], agente: 'frontend-tailwind-swl' },
+  { id: 'shadcn',        name: 'shadcn/ui',      detect: { configFiles: ['components.json'] },
+    skills: ['tailwind-experto', 'react-experto'], agente: 'frontend-react-swl' },
+
+  // --- Bases de datos ---
+  { id: 'prisma',        name: 'Prisma',         detect: { packages: ['prisma', '@prisma/client'] },
+    skills: ['node-experto'], agente: 'backend-node-swl' },
+  { id: 'drizzle',       name: 'Drizzle ORM',    detect: { packages: ['drizzle-orm', 'drizzle-kit'] },
+    skills: ['node-experto', 'sql-optimizacion'], agente: 'backend-node-swl' },
+  { id: 'postgresql',    name: 'PostgreSQL',      detect: { packages: ['pg', 'postgres', 'asyncpg', 'psycopg2', 'psycopg2-binary', '@prisma/client'] },
+    skills: ['postgresql-experto', 'sql-optimizacion'], agente: null },
+  { id: 'mongodb',       name: 'MongoDB',        detect: { packages: ['mongoose', 'mongodb', 'motor'] },
+    skills: ['mongodb-experto'], agente: null },
+  { id: 'redis',         name: 'Redis',          detect: { packages: ['redis', 'ioredis', 'aioredis'] },
+    skills: ['redis-experto'], agente: null },
+
+  // --- Testing ---
+  { id: 'pytest',        name: 'pytest',         detect: { packages: ['pytest'], configFiles: ['pytest.ini', 'conftest.py'] },
+    skills: ['testing-python', 'tdd-workflow'], agente: 'tdd-qa-swl' },
+  { id: 'vitest',        name: 'Vitest',         detect: { packages: ['vitest'], configFiles: ['vitest.config.ts', 'vitest.config.js'] },
+    skills: ['nextjs-testing', 'tdd-workflow'], agente: 'tdd-qa-swl' },
+  { id: 'playwright',    name: 'Playwright',     detect: { packages: ['@playwright/test', 'playwright'] },
+    skills: ['tdd-workflow'], agente: 'tdd-qa-swl' },
+
+  // --- Java/JVM ---
+  { id: 'springboot',    name: 'Spring Boot',    detect: { configContent: { files: ['pom.xml', 'build.gradle', 'build.gradle.kts'], patterns: ['spring-boot-starter', 'org.springframework.boot'] } },
+    skills: ['java-experto', 'java-testing', 'java-patrones'], agente: 'backend-java-swl' },
+  { id: 'kotlin-android', name: 'Kotlin Android', detect: { configContent: { files: ['build.gradle.kts', 'build.gradle'], patterns: ['com.android.application', 'com.android.library'] } },
+    skills: ['kotlin-experto', 'kotlin-testing', 'kotlin-compose'], agente: 'mobile-android-swl' },
+
+  // --- Go ---
+  { id: 'go-chi',        name: 'Go Chi',         detect: { configContent: { files: ['go.mod'], patterns: ['github.com/go-chi/chi'] } },
+    skills: ['go-experto', 'go-testing', 'go-patrones'], agente: 'backend-go-swl' },
+  { id: 'go-gin',        name: 'Go Gin',         detect: { configContent: { files: ['go.mod'], patterns: ['github.com/gin-gonic/gin'] } },
+    skills: ['go-experto', 'go-testing', 'go-patrones'], agente: 'backend-go-swl' },
+
+  // --- Rust ---
+  { id: 'axum',          name: 'Axum',           detect: { configContent: { files: ['Cargo.toml'], patterns: ['axum'] } },
+    skills: ['rust-experto', 'rust-testing', 'rust-patrones'], agente: 'backend-rust-swl' },
+  { id: 'actix',         name: 'Actix',          detect: { configContent: { files: ['Cargo.toml'], patterns: ['actix-web'] } },
+    skills: ['rust-experto', 'rust-testing', 'rust-patrones'], agente: 'backend-rust-swl' },
+
+  // --- C#/.NET ---
+  { id: 'aspnet',        name: 'ASP.NET Core',   detect: { configContent: { files: ['*.csproj'], patterns: ['Microsoft.AspNetCore', 'Asp.Versioning'] } },
+    skills: ['csharp-experto', 'csharp-testing', 'csharp-patrones'], agente: 'backend-csharp-swl' },
+
+  // --- PHP ---
+  { id: 'laravel',       name: 'Laravel',        detect: { packages: ['laravel/framework'], configFiles: ['artisan'] },
+    skills: ['php-experto', 'php-testing', 'php-patrones'], agente: 'implementador-swl' },
+
+  // --- Swift/iOS ---
+  { id: 'swiftui',       name: 'SwiftUI',        detect: { configFiles: ['Package.swift'] },
+    skills: ['swift-experto', 'swift-testing', 'swift-patrones'], agente: 'mobile-ios-swl' },
+
+  // --- Mobile cross ---
+  { id: 'react-native',  name: 'React Native',   detect: { packages: ['react-native'] },
+    skills: ['mobile-react-native', 'react-experto'], agente: 'mobile-cross-swl' },
+  { id: 'flutter',       name: 'Flutter',        detect: { configFiles: ['pubspec.yaml'] },
+    skills: ['mobile-flutter'], agente: 'mobile-cross-swl' },
+  { id: 'expo',          name: 'Expo',           detect: { packages: ['expo'] },
+    skills: ['mobile-react-native', 'react-experto'], agente: 'mobile-cross-swl' },
+
+  // --- Infra ---
+  { id: 'docker',        name: 'Docker',         detect: { configFiles: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml'] },
+    skills: ['contenedores-docker', 'ci-cd-pipelines'], agente: 'devops-ci-swl' },
+  { id: 'terraform',     name: 'Terraform',      detect: { configFiles: ['main.tf', 'terraform.tf'] },
+    skills: ['terraform-experto', 'cloud-aws'], agente: 'cloud-infra-swl' },
+  { id: 'kubernetes',    name: 'Kubernetes',     detect: { configFiles: ['k8s', 'kustomization.yaml', 'Chart.yaml'] },
+    skills: ['kubernetes-orquestacion'], agente: 'cloud-infra-swl' },
+
+  // --- Auth ---
+  { id: 'auth-jwt',      name: 'JWT Auth',       detect: { packages: ['jsonwebtoken', 'jose', 'python-jose', 'PyJWT'] },
+    skills: ['auth-patrones', 'checklist-seguridad'], agente: null },
+  { id: 'oauth',         name: 'OAuth/OIDC',     detect: { packages: ['passport', 'authlib', 'next-auth', '@auth/core'] },
+    skills: ['auth-patrones', 'iam-secretos'], agente: null },
+];
+
+/**
+ * Combos: skills adicionales cuando se detectan 2+ tecnologías juntas.
+ */
+const COMBO_MAP = [
+  { id: 'fastapi-postgres',    requires: ['fastapi', 'postgresql'],     skills: ['async-python', 'sql-optimizacion'], pipeline: 'backend' },
+  { id: 'fastapi-celery',      requires: ['fastapi', 'celery'],         skills: ['async-python'], pipeline: 'backend-workers' },
+  { id: 'nextjs-prisma',       requires: ['nextjs', 'prisma'],          skills: ['nextjs-patrones', 'node-experto'], pipeline: 'fullstack' },
+  { id: 'nextjs-tailwind',     requires: ['nextjs', 'tailwind'],        skills: ['tailwind-experto', 'nextjs-experto'], pipeline: 'frontend' },
+  { id: 'react-tailwind',      requires: ['react', 'tailwind'],         skills: ['tailwind-experto', 'react-experto', 'css-moderno'], pipeline: 'frontend' },
+  { id: 'angular-tailwind',    requires: ['angular', 'tailwind'],       skills: ['tailwind-experto', 'angular-moderno'], pipeline: 'frontend' },
+  { id: 'django-postgres',     requires: ['django', 'postgresql'],      skills: ['django-experto', 'sql-optimizacion'], pipeline: 'backend' },
+  { id: 'springboot-postgres',  requires: ['springboot', 'postgresql'], skills: ['java-experto', 'sql-optimizacion'], pipeline: 'backend' },
+  { id: 'nextjs-react-native', requires: ['nextjs', 'react-native'],    skills: ['react-experto', 'mobile-react-native'], pipeline: 'fullstack-mobile' },
+  { id: 'docker-kubernetes',   requires: ['docker', 'kubernetes'],       skills: ['contenedores-docker', 'kubernetes-orquestacion'], pipeline: 'devops' },
+  { id: 'expo-tailwind',       requires: ['expo', 'tailwind'],          skills: ['mobile-react-native', 'tailwind-experto'], pipeline: 'mobile' },
+];
+
+/**
+ * Lee y parsea package.json del directorio dado.
+ * @param {string} dir
+ * @returns {object|null}
+ */
+function _readPkg(dir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+  } catch { return null; }
+}
+
+/**
+ * Extrae todos los nombres de paquetes de dependencies + devDependencies.
+ * @param {object|null} pkg
+ * @returns {Set<string>}
+ */
+function _allDeps(pkg) {
+  if (!pkg) return new Set();
+  return new Set([
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}),
+  ]);
+}
+
+/**
+ * Lee requirements.txt y extrae nombres de paquetes Python.
+ * @param {string} dir
+ * @returns {Set<string>}
+ */
+function _readPythonDeps(dir) {
+  const deps = new Set();
+  for (const f of ['requirements.txt', 'pyproject.toml', 'Pipfile']) {
+    try {
+      const content = fs.readFileSync(path.join(dir, f), 'utf8');
+      // Extraer nombres de paquetes antes del ==, >=, etc.
+      const matches = content.match(/^([a-zA-Z0-9_-]+)/gm);
+      if (matches) matches.forEach(m => deps.add(m.toLowerCase()));
+    } catch { /* skip */ }
+  }
+  return deps;
+}
+
+/**
+ * Verifica si un archivo contiene alguno de los patrones dados.
+ * @param {string} dir
+ * @param {string[]} files
+ * @param {string[]} patterns
+ * @returns {boolean}
+ */
+function _fileContainsAny(dir, files, patterns) {
+  for (const f of files) {
+    try {
+      // Soporte para wildcards simples (*.csproj)
+      if (f.includes('*')) {
+        const ext = f.replace('*', '');
+        const dirFiles = fs.readdirSync(dir).filter(n => n.endsWith(ext));
+        for (const df of dirFiles) {
+          const content = fs.readFileSync(path.join(dir, df), 'utf8');
+          if (patterns.some(p => content.includes(p))) return true;
+        }
+      } else {
+        const content = fs.readFileSync(path.join(dir, f), 'utf8');
+        if (patterns.some(p => content.includes(p))) return true;
+      }
+    } catch { /* file not found, skip */ }
+  }
+  return false;
+}
+
+/**
+ * Detecta tecnologías específicas del proyecto.
+ *
+ * Escanea package.json, requirements.txt, archivos de configuración y
+ * contenido de archivos para identificar frameworks, librerías y herramientas.
+ *
+ * @param {string} dir - Directorio raíz del proyecto.
+ * @returns {{ tecnologias: Array<{id: string, name: string, skills: string[], agente: string|null}>, combos: Array<{id: string, skills: string[], pipeline: string}> }}
+ */
+function detectarTecnologias(dir) {
+  const pkg = _readPkg(dir);
+  const jsDeps = _allDeps(pkg);
+  const pyDeps = _readPythonDeps(dir);
+  const allDeps = new Set([...jsDeps, ...pyDeps]);
+
+  const detected = [];
+
+  for (const tech of TECH_MAP) {
+    let found = false;
+
+    // Estrategia 1: packages
+    if (tech.detect.packages) {
+      found = tech.detect.packages.some(p => allDeps.has(p));
+    }
+
+    // Estrategia 2: configFiles
+    if (!found && tech.detect.configFiles) {
+      found = tech.detect.configFiles.some(f => fs.existsSync(path.join(dir, f)));
+    }
+
+    // Estrategia 3: configContent
+    if (!found && tech.detect.configContent) {
+      const { files, patterns } = tech.detect.configContent;
+      found = _fileContainsAny(dir, files, patterns);
+    }
+
+    if (found) {
+      detected.push({
+        id: tech.id,
+        name: tech.name,
+        skills: tech.skills,
+        agente: tech.agente,
+      });
+    }
+  }
+
+  // Detectar combos
+  const detectedIds = new Set(detected.map(t => t.id));
+  const combos = COMBO_MAP
+    .filter(c => c.requires.every(r => detectedIds.has(r)))
+    .map(c => ({ id: c.id, skills: c.skills, pipeline: c.pipeline }));
+
+  return { tecnologias: detected, combos };
+}
+
+module.exports = { detectarPackageManager, detectarLenguajes, detectarTecnologias };

package/hooks/lib/edit-accumulator.js

@@ -0,0 +1,171 @@
+'use strict';
+
+/**
+ * Edit Accumulator — Acumula paths de archivos editados durante una respuesta.
+ *
+ * En vez de correr lint/typecheck despues de cada Edit individual, acumula
+ * los paths y permite un batch check al final (en Stop hook o pre-commit).
+ *
+ * Inspirado en ECC post-edit-accumulator.js + stop-format-typecheck.js.
+ * Zero-dependencies: usa archivos temporales para estado entre hook calls.
+ *
+ * @module hooks/lib/edit-accumulator
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ---------------------------------------------------------------------------
+// Estado persistido en archivo temporal (por sesion)
+// ---------------------------------------------------------------------------
+
+/**
+ * Obtiene la ruta del archivo acumulador para la sesion actual.
+ * @param {string} [sessionId='default']
+ * @returns {string}
+ */
+function getAccumulatorPath(sessionId) {
+  const id = sessionId || 'default';
+  return path.join(os.tmpdir(), `swl-edit-acc-${id}.json`);
+}
+
+/**
+ * Lee el estado actual del acumulador.
+ * @param {string} [sessionId]
+ * @returns {{ files: string[], startTime: string }}
+ */
+function readState(sessionId) {
+  const accPath = getAccumulatorPath(sessionId);
+  try {
+    return JSON.parse(fs.readFileSync(accPath, 'utf8'));
+  } catch {
+    return { files: [], startTime: new Date().toISOString() };
+  }
+}
+
+/**
+ * Guarda el estado del acumulador.
+ * @param {{ files: string[], startTime: string }} state
+ * @param {string} [sessionId]
+ */
+function writeState(state, sessionId) {
+  const accPath = getAccumulatorPath(sessionId);
+  try {
+    fs.writeFileSync(accPath, JSON.stringify(state), 'utf8');
+  } catch { /* best effort */ }
+}
+
+// ---------------------------------------------------------------------------
+// API publica
+// ---------------------------------------------------------------------------
+
+/**
+ * Registra un archivo editado en el acumulador.
+ * @param {string} filePath - Ruta del archivo editado.
+ * @param {string} [sessionId]
+ */
+function recordEdit(filePath, sessionId) {
+  if (!filePath) return;
+  const state = readState(sessionId);
+  const normalized = path.resolve(filePath);
+  if (!state.files.includes(normalized)) {
+    state.files.push(normalized);
+    writeState(state, sessionId);
+  }
+}
+
+/**
+ * Obtiene todos los archivos acumulados y limpia el acumulador.
+ * @param {string} [sessionId]
+ * @returns {string[]} Paths de archivos editados (deduplicados).
+ */
+function flushEdits(sessionId) {
+  const state = readState(sessionId);
+  const files = [...state.files];
+  // Reset
+  writeState({ files: [], startTime: new Date().toISOString() }, sessionId);
+  return files;
+}
+
+/**
+ * Obtiene archivos acumulados sin limpiar.
+ * @param {string} [sessionId]
+ * @returns {string[]}
+ */
+function peekEdits(sessionId) {
+  return readState(sessionId).files;
+}
+
+/**
+ * Filtra archivos por extensiones que soportan lint/typecheck.
+ * @param {string[]} files
+ * @returns {{ js: string[], ts: string[], py: string[], css: string[] }}
+ */
+function categorizeFiles(files) {
+  const js = [];
+  const ts = [];
+  const py = [];
+  const css = [];
+
+  for (const f of files) {
+    const ext = path.extname(f).toLowerCase();
+    switch (ext) {
+      case '.js': case '.mjs': case '.cjs': case '.jsx':
+        js.push(f); break;
+      case '.ts': case '.tsx': case '.mts': case '.cts':
+        ts.push(f); break;
+      case '.py': case '.pyw':
+        py.push(f); break;
+      case '.css': case '.scss': case '.less':
+        css.push(f); break;
+    }
+  }
+
+  return { js, ts, py, css };
+}
+
+/**
+ * Genera los comandos de verificacion batch para los archivos acumulados.
+ * @param {string[]} files
+ * @param {string} cwd - Directorio de trabajo.
+ * @returns {string[]} Comandos a ejecutar.
+ */
+function generateBatchCommands(files, cwd) {
+  const { js, ts, py } = categorizeFiles(files);
+  const commands = [];
+
+  // TypeScript typecheck
+  if (ts.length > 0 && fs.existsSync(path.join(cwd, 'tsconfig.json'))) {
+    commands.push('npx tsc --noEmit 2>&1 | head -20');
+  }
+
+  // ESLint para JS/TS
+  if ((js.length + ts.length) > 0) {
+    const allJsTs = [...js, ...ts].map(f => path.relative(cwd, f)).join(' ');
+    if (fs.existsSync(path.join(cwd, 'node_modules', '.bin', 'eslint'))) {
+      commands.push(`npx eslint --no-error-on-unmatched-pattern ${allJsTs} 2>&1 | head -20`);
+    }
+  }
+
+  // Ruff para Python
+  if (py.length > 0) {
+    const allPy = py.map(f => path.relative(cwd, f)).join(' ');
+    commands.push(`ruff check --select=E,W,F ${allPy} 2>&1 | head -20`);
+  }
+
+  return commands;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  recordEdit,
+  flushEdits,
+  peekEdits,
+  categorizeFiles,
+  generateBatchCommands,
+  getAccumulatorPath,
+};