@umbral/cli 0.0.2 → 0.0.4

package/dist/index.js

@@ -3,6 +3,10 @@
 // src/index.ts
 import { Command } from "commander";
 
+// src/analyze.ts
+import { readdirSync } from "fs";
+import { join as join11 } from "path";
+
 // src/detect/node.ts
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
@@ -258,17 +262,250 @@ var StylingDetector = class {
   }
 };
 
+// src/detect/python.ts
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { join as join7 } from "path";
+function readTextFile(path) {
+  try {
+    return readFileSync7(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function extractPythonDeps(projectPath) {
+  const deps = [];
+  const reqPath = join7(projectPath, "requirements.txt");
+  if (existsSync6(reqPath)) {
+    const content = readTextFile(reqPath);
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("-")) {
+        const name = trimmed.split(/[>=<!\[;]/)[0].trim().toLowerCase();
+        if (name) deps.push(name);
+      }
+    }
+  }
+  const pyprojectPath = join7(projectPath, "pyproject.toml");
+  if (existsSync6(pyprojectPath)) {
+    const content = readTextFile(pyprojectPath);
+    const depMatches = content.match(/["']([a-zA-Z0-9_-]+)(?:\[.*?\])?(?:[>=<~!].*?)?["']/g);
+    if (depMatches) {
+      for (const m of depMatches) {
+        const name = m.replace(/["']/g, "").split(/[>=<~!\[]/)[0].trim().toLowerCase();
+        if (name && name.length > 1) deps.push(name);
+      }
+    }
+  }
+  return [...new Set(deps)];
+}
+var PythonDetector = class {
+  detect(projectPath) {
+    const hasPyproject = existsSync6(join7(projectPath, "pyproject.toml"));
+    const hasRequirements = existsSync6(join7(projectPath, "requirements.txt"));
+    const hasSetupPy = existsSync6(join7(projectPath, "setup.py"));
+    const hasPipfile = existsSync6(join7(projectPath, "Pipfile"));
+    const hasPoetryLock = existsSync6(join7(projectPath, "poetry.lock"));
+    const hasManagePy = existsSync6(join7(projectPath, "manage.py"));
+    if (!hasPyproject && !hasRequirements && !hasSetupPy && !hasPipfile && !hasManagePy) return [];
+    const results = [];
+    const evidence = [];
+    if (hasPyproject) evidence.push("pyproject.toml");
+    if (hasRequirements) evidence.push("requirements.txt");
+    if (hasSetupPy) evidence.push("setup.py");
+    if (hasPipfile) evidence.push("Pipfile");
+    let pythonVersion = "";
+    if (existsSync6(join7(projectPath, ".python-version"))) {
+      pythonVersion = readTextFile(join7(projectPath, ".python-version")).trim();
+    }
+    results.push({
+      category: "runtime",
+      name: `Python${pythonVersion ? ` ${pythonVersion}` : ""}`,
+      slug: "python",
+      confidence: 1,
+      evidence,
+      metadata: { pythonVersion }
+    });
+    if (hasPoetryLock) {
+      results.push({ category: "package-manager", name: "Poetry", slug: "poetry", confidence: 1, evidence: ["poetry.lock"], metadata: {} });
+    } else if (hasPipfile) {
+      results.push({ category: "package-manager", name: "Pipenv", slug: "pipenv", confidence: 1, evidence: ["Pipfile"], metadata: {} });
+    } else if (hasPyproject) {
+      const content = readTextFile(join7(projectPath, "pyproject.toml"));
+      if (content.includes("uv")) {
+        results.push({ category: "package-manager", name: "uv", slug: "uv", confidence: 0.7, evidence: ["pyproject.toml referencia uv"], metadata: {} });
+      }
+    }
+    const deps = extractPythonDeps(projectPath);
+    if (deps.includes("fastapi") || deps.includes("fastapi[standard]")) {
+      results.push({ category: "framework", name: "FastAPI", slug: "fastapi", confidence: 1, evidence: ["fastapi en dependencies"], metadata: {} });
+    } else if (hasManagePy || deps.includes("django")) {
+      results.push({ category: "framework", name: "Django", slug: "django", confidence: 1, evidence: [hasManagePy ? "manage.py" : "django en dependencies"], metadata: {} });
+    } else if (deps.includes("flask")) {
+      results.push({ category: "framework", name: "Flask", slug: "flask", confidence: 1, evidence: ["flask en dependencies"], metadata: {} });
+    } else if (deps.includes("streamlit")) {
+      results.push({ category: "framework", name: "Streamlit", slug: "streamlit", confidence: 1, evidence: ["streamlit en dependencies"], metadata: {} });
+    }
+    if (deps.includes("sqlalchemy")) {
+      results.push({ category: "database", name: "SQLAlchemy", slug: "sqlalchemy", confidence: 1, evidence: ["sqlalchemy en dependencies"], metadata: {} });
+    } else if (deps.includes("supabase")) {
+      results.push({ category: "database", name: "Supabase (PostgreSQL)", slug: "supabase", confidence: 1, evidence: ["supabase en dependencies"], metadata: {} });
+    } else if (deps.includes("psycopg2") || deps.includes("psycopg2-binary") || deps.includes("asyncpg")) {
+      results.push({ category: "database", name: "PostgreSQL", slug: "postgresql-python", confidence: 0.9, evidence: ["driver PostgreSQL en dependencies"], metadata: {} });
+    }
+    if (deps.includes("pytest")) {
+      results.push({ category: "testing", name: "pytest", slug: "pytest", confidence: 1, evidence: ["pytest en dependencies"], metadata: {} });
+    } else if (deps.includes("unittest")) {
+      results.push({ category: "testing", name: "unittest", slug: "unittest", confidence: 0.8, evidence: ["unittest en dependencies"], metadata: {} });
+    }
+    if (deps.includes("langchain") || deps.includes("langchain-core") || deps.includes("langgraph")) {
+      const parts = [];
+      if (deps.includes("langchain") || deps.includes("langchain-core")) parts.push("LangChain");
+      if (deps.includes("langgraph")) parts.push("LangGraph");
+      results.push({ category: "framework", name: parts.join(" + "), slug: "langchain", confidence: 1, evidence: parts.map((p) => `${p.toLowerCase()} en dependencies`), metadata: {} });
+    }
+    return results;
+  }
+};
+
+// src/detect/go.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { join as join8 } from "path";
+var GoDetector = class {
+  detect(projectPath) {
+    const goModPath = join8(projectPath, "go.mod");
+    if (!existsSync7(goModPath)) return [];
+    const results = [];
+    let moduleName = "";
+    let goVersion = "";
+    try {
+      const content = readFileSync8(goModPath, "utf-8");
+      const moduleMatch = content.match(/^module\s+(\S+)/m);
+      const versionMatch = content.match(/^go\s+(\S+)/m);
+      if (moduleMatch) moduleName = moduleMatch[1];
+      if (versionMatch) goVersion = versionMatch[1];
+    } catch {
+    }
+    results.push({
+      category: "runtime",
+      name: `Go${goVersion ? ` ${goVersion}` : ""}`,
+      slug: "golang",
+      confidence: 1,
+      evidence: ["go.mod"],
+      metadata: { moduleName, goVersion }
+    });
+    return results;
+  }
+};
+
+// src/detect/rust.ts
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { join as join9 } from "path";
+var RustDetector = class {
+  detect(projectPath) {
+    const cargoPath = join9(projectPath, "Cargo.toml");
+    if (!existsSync8(cargoPath)) return [];
+    const results = [];
+    let edition = "";
+    try {
+      const content = readFileSync9(cargoPath, "utf-8");
+      const editionMatch = content.match(/edition\s*=\s*"(\d+)"/);
+      if (editionMatch) edition = editionMatch[1];
+    } catch {
+    }
+    results.push({
+      category: "runtime",
+      name: `Rust${edition ? ` (edition ${edition})` : ""}`,
+      slug: "rust",
+      confidence: 1,
+      evidence: ["Cargo.toml"],
+      metadata: { edition }
+    });
+    return results;
+  }
+};
+
+// src/detect/docker.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
+var DockerDetector = class {
+  detect(projectPath) {
+    const results = [];
+    if (existsSync9(join10(projectPath, "Dockerfile"))) {
+      results.push({
+        category: "infra",
+        name: "Docker",
+        slug: "docker",
+        confidence: 1,
+        evidence: ["Dockerfile"],
+        metadata: {}
+      });
+    }
+    const composeNames = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+    const found = composeNames.find((n) => existsSync9(join10(projectPath, n)));
+    if (found) {
+      results.push({
+        category: "infra",
+        name: "Docker Compose",
+        slug: "docker-compose",
+        confidence: 1,
+        evidence: [found],
+        metadata: {}
+      });
+    }
+    return results;
+  }
+};
+
 // src/analyze.ts
 var DETECTORS = [
   new NodeDetector(),
+  new PythonDetector(),
+  new GoDetector(),
+  new RustDetector(),
   new FrameworkDetector(),
   new DatabaseDetector(),
   new TestingDetector(),
   new BuildDetector(),
-  new StylingDetector()
+  new StylingDetector(),
+  new DockerDetector()
 ];
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "env",
+  ".env",
+  ".tox",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "target",
+  "vendor"
+]);
+function runDetectors(dirPath) {
+  return DETECTORS.flatMap((d) => d.detect(dirPath));
+}
 function analyzeProject(projectPath) {
-  const detections = DETECTORS.flatMap((d) => d.detect(projectPath));
+  const detections = runDetectors(projectPath);
+  try {
+    const entries = readdirSync(projectPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      const subPath = join11(projectPath, entry.name);
+      const subDetections = runDetectors(subPath);
+      for (const d of subDetections) {
+        d.subdir = entry.name;
+        d.name = `${d.name} (${entry.name}/)`;
+        detections.push(d);
+      }
+    }
+  } catch {
+  }
   detections.sort((a, b) => b.confidence - a.confidence);
   return { projectPath, detections };
 }
@@ -425,14 +662,347 @@ var TEMPLATES = [
       "No saltarse el pipeline de Turbo ejecutando scripts directamente en paquetes interdependientes.",
       "No ignorar los outputs de cache en turbo.json."
     ]
+  },
+  {
+    slugs: ["fastapi"],
+    cognitiveLevel: "navigator",
+    complexityTier: 2,
+    title: () => "FastAPI como framework backend",
+    decision: () => "El backend utiliza FastAPI para servir la API HTTP con validacion automatica y documentacion OpenAPI.",
+    mechanism: () => "Endpoints async definidos con decoradores. Pydantic para validacion de request/response. Uvicorn como servidor ASGI.",
+    rationale: () => "FastAPI combina rendimiento async con type-safety via Pydantic y genera documentacion OpenAPI automaticamente.",
+    alternatives: () => [
+      { option: "Django REST Framework", rejectedBecause: "Mayor overhead para APIs puras sin necesidad de ORM integrado." },
+      { option: "Flask", rejectedBecause: "Sin validacion nativa ni soporte async." }
+    ],
+    antiPatterns: () => [
+      "No usar funciones sincronas bloqueantes en endpoints async.",
+      "No omitir modelos Pydantic para validacion de entrada.",
+      "No exponer excepciones internas sin un exception handler."
+    ]
+  },
+  {
+    slugs: ["django"],
+    cognitiveLevel: "navigator",
+    complexityTier: 2,
+    title: () => "Django como framework backend",
+    decision: () => "El backend utiliza Django como framework web full-stack.",
+    mechanism: () => "Models definen el esquema de datos. Views procesan requests. URLs mapean rutas. Migraciones via manage.py migrate.",
+    rationale: () => "Django provee ORM, auth, admin y migraciones out-of-the-box. Ideal para aplicaciones con modelo de datos relacional complejo.",
+    alternatives: () => [
+      { option: "FastAPI", rejectedBecause: "No incluye ORM ni admin panel integrados." }
+    ],
+    antiPatterns: () => [
+      "No ejecutar queries N+1 en views sin select_related/prefetch_related.",
+      "No modificar modelos sin crear migraciones."
+    ]
+  },
+  {
+    slugs: ["flask"],
+    cognitiveLevel: "explorer",
+    complexityTier: 1,
+    title: () => "Flask como framework backend",
+    decision: () => "El backend utiliza Flask como micro-framework HTTP.",
+    mechanism: () => "Rutas definidas con decoradores. Blueprints para modularizar. Extensions para funcionalidad adicional.",
+    rationale: () => "Flask es minimalista y flexible. Permite elegir cada componente (ORM, auth, etc.) independientemente.",
+    alternatives: () => [
+      { option: "FastAPI", rejectedBecause: "Mayor complejidad inicial para APIs simples." }
+    ],
+    antiPatterns: () => [
+      "No almacenar estado mutable en variables globales del modulo.",
+      "No omitir manejo de errores en endpoints."
+    ]
+  },
+  {
+    slugs: ["langchain"],
+    cognitiveLevel: "anchor",
+    complexityTier: 3,
+    title: () => "LangChain/LangGraph como framework de agentes AI",
+    decision: () => "La orquestacion de agentes AI utiliza LangChain y/o LangGraph para flujos multi-paso con LLMs.",
+    mechanism: () => "LangGraph define grafos de estado con nodos y edges. Cada nodo ejecuta una accion (tool call, LLM call). El estado se propaga entre nodos.",
+    rationale: () => "LangGraph permite flujos de agentes complejos con ciclos, branching y estado persistente. LangChain provee abstracciones para tools, memory y prompts.",
+    alternatives: () => [
+      { option: "Llamadas directas a la API del LLM", rejectedBecause: "Sin soporte para grafos de estado, reintentos ni tool calling estandarizado." },
+      { option: "CrewAI", rejectedBecause: "Menor control sobre el flujo de ejecucion." }
+    ],
+    antiPatterns: () => [
+      "No hardcodear prompts sin versionarlos o parametrizarlos.",
+      "No omitir manejo de errores en tool calls (timeouts, rate limits).",
+      "No ignorar el costo de tokens en flujos con multiples LLM calls."
+    ]
+  },
+  {
+    slugs: ["sqlalchemy"],
+    cognitiveLevel: "anchor",
+    complexityTier: 2,
+    title: () => "SQLAlchemy como ORM Python",
+    decision: () => "La persistencia utiliza SQLAlchemy para modelado relacional con type-safety.",
+    mechanism: () => "Modelos declarativos con Column definitions. Sessions para transacciones. Alembic para migraciones.",
+    rationale: () => "SQLAlchemy es el ORM mas maduro de Python. Soporta multiples backends SQL y ofrece tanto ORM como Core para queries.",
+    alternatives: () => [
+      { option: "Django ORM", rejectedBecause: "Acoplado al framework Django." }
+    ],
+    antiPatterns: () => [
+      "No crear sesiones sin cerrarlas (usar context manager).",
+      "No ejecutar queries en loops sin batch/bulk operations."
+    ]
+  },
+  {
+    slugs: ["supabase"],
+    cognitiveLevel: "anchor",
+    complexityTier: 2,
+    title: () => "Supabase como backend-as-a-service",
+    decision: () => "La persistencia y autenticacion utilizan Supabase (PostgreSQL + Auth + Storage + Realtime).",
+    mechanism: () => "Cliente Supabase conecta a PostgreSQL via REST/Realtime. Auth con JWT. Storage para archivos. Row Level Security para autorizacion.",
+    rationale: () => "Supabase provee PostgreSQL managed con auth, storage y realtime integrados. Reduce la necesidad de infraestructura propia.",
+    alternatives: () => [
+      { option: "Firebase", rejectedBecause: "NoSQL (Firestore) vs SQL (PostgreSQL); vendor lock-in mas fuerte." },
+      { option: "PostgreSQL autohosteado", rejectedBecause: "Requiere mantener infraestructura de auth, storage y realtime por separado." }
+    ],
+    antiPatterns: () => [
+      "No omitir Row Level Security en tablas con datos de usuario.",
+      "No exponer la service_role key en el frontend.",
+      "No hacer queries complejas sin indices en las columnas filtradas."
+    ]
+  },
+  {
+    slugs: ["pytest"],
+    cognitiveLevel: "explorer",
+    complexityTier: 1,
+    title: () => "pytest como framework de testing",
+    decision: () => "Los tests del proyecto Python utilizan pytest.",
+    mechanism: () => "Tests como funciones con prefijo test_. Fixtures para setup/teardown. Markers para categorizar. conftest.py para configuracion compartida.",
+    rationale: () => "pytest es el standard de facto en Python. Fixtures, parametrize y plugins lo hacen extensible sin boilerplate.",
+    alternatives: () => [
+      { option: "unittest", rejectedBecause: "Requiere clases y mas boilerplate." }
+    ],
+    antiPatterns: () => [
+      "No compartir estado mutable entre tests sin fixtures con scope adecuado.",
+      "No omitir fixtures de limpieza para recursos externos (DB, files)."
+    ]
+  },
+  {
+    slugs: ["python"],
+    cognitiveLevel: "explorer",
+    complexityTier: 1,
+    title: () => "Python como runtime del backend",
+    decision: () => "El proyecto utiliza Python como lenguaje principal del backend.",
+    mechanism: () => "Entorno virtual para aislamiento de dependencias. pip/poetry/uv para gestion de paquetes.",
+    rationale: () => "Python tiene el ecosistema mas amplio para AI/ML, data processing y APIs web.",
+    alternatives: () => [
+      { option: "Node.js", rejectedBecause: "Menor ecosistema de librerias AI/ML nativas." },
+      { option: "Go", rejectedBecause: "Menor productividad para prototipado rapido." }
+    ],
+    antiPatterns: () => [
+      "No instalar paquetes fuera del entorno virtual.",
+      "No commitear el entorno virtual (venv/) al repositorio."
+    ]
+  },
+  {
+    slugs: ["golang"],
+    cognitiveLevel: "explorer",
+    complexityTier: 1,
+    title: () => "Go como runtime principal",
+    decision: () => "El proyecto utiliza Go como lenguaje de desarrollo.",
+    mechanism: () => "Go modules para gestion de dependencias. go build para compilacion. go test para testing.",
+    rationale: () => "Go ofrece compilacion rapida, binarios estaticos y concurrencia nativa con goroutines.",
+    alternatives: () => [
+      { option: "Rust", rejectedBecause: "Curva de aprendizaje mas pronunciada." },
+      { option: "Node.js", rejectedBecause: "Menor rendimiento en workloads CPU-bound." }
+    ],
+    antiPatterns: () => [
+      "No ignorar errores retornados (no usar _ sin justificacion).",
+      "No compartir estado mutable entre goroutines sin sincronizacion."
+    ]
+  },
+  {
+    slugs: ["rust"],
+    cognitiveLevel: "navigator",
+    complexityTier: 2,
+    title: () => "Rust como runtime principal",
+    decision: () => "El proyecto utiliza Rust para rendimiento y seguridad de memoria.",
+    mechanism: () => "Cargo para build y dependencias. Ownership system para seguridad de memoria sin GC. Crates.io como registry.",
+    rationale: () => "Rust garantiza seguridad de memoria en compile-time sin garbage collector. Ideal para sistemas de alto rendimiento.",
+    alternatives: () => [
+      { option: "C++", rejectedBecause: "Sin garantias de seguridad de memoria en compile-time." },
+      { option: "Go", rejectedBecause: "GC introduce latencia impredecible." }
+    ],
+    antiPatterns: () => [
+      "No usar unsafe sin documentar la invariante de seguridad.",
+      "No ignorar warnings del compilador."
+    ]
+  },
+  {
+    slugs: ["docker"],
+    cognitiveLevel: "explorer",
+    complexityTier: 1,
+    title: () => "Docker como entorno de containerizacion",
+    decision: () => "El proyecto utiliza Docker para empaquetar y desplegar la aplicacion.",
+    mechanism: () => "Dockerfile define la imagen. Multi-stage builds para optimizar tamano. .dockerignore para excluir archivos innecesarios.",
+    rationale: () => "Docker garantiza reproducibilidad del entorno entre desarrollo y produccion.",
+    alternatives: () => [
+      { option: "Despliegue directo", rejectedBecause: "Sin aislamiento ni reproducibilidad del entorno." }
+    ],
+    antiPatterns: () => [
+      "No instalar dependencias de desarrollo en la imagen de produccion.",
+      "No correr el proceso como root en el contenedor."
+    ]
   }
 ];
 function getTemplate(detection) {
   return TEMPLATES.find((t) => t.slugs.includes(detection.slug)) ?? null;
 }
 
+// src/claude-generate.ts
+import { spawnSync } from "child_process";
+function isClaudeAvailable() {
+  try {
+    const r = spawnSync("claude", ["--version"], {
+      timeout: 5e3,
+      shell: true,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+function buildPrompt(detections) {
+  const detectionsJson = JSON.stringify(
+    detections.map((d) => ({
+      name: d.name,
+      slug: d.slug,
+      category: d.category,
+      confidence: d.confidence,
+      evidence: d.evidence,
+      metadata: d.metadata,
+      subdir: d.subdir
+    })),
+    null,
+    2
+  );
+  return `Eres Umbral, un framework de gobernanza para proyectos de software. Bas\xE1ndote en las tecnolog\xEDas detectadas abajo, genera Estructuras de Decisi\xF3n Expl\xEDcitas (EDEs) \u2014 decisiones arquitect\xF3nicas formalizadas y espec\xEDficas para ESTE proyecto.
+
+## Tecnolog\xEDas Detectadas
+${detectionsJson}
+
+## Esquema JSON de una EDE
+Cada EDE debe seguir EXACTAMENTE esta estructura:
+{
+  "id": "EDE-001-slug",
+  "title": "string",
+  "version": 1,
+  "status": "proposed",
+  "cognitiveLevel": "explorer" | "navigator" | "anchor",
+  "complexityTier": 1 | 2 | 3,
+  "whatAndHow": { "decision": "string", "mechanism": "string" },
+  "why": {
+    "rationale": "string",
+    "alternativesConsidered": [{ "option": "string", "rejectedBecause": "string" }],
+    "references": []
+  },
+  "whatNotToDo": { "antiPatterns": ["string"] },
+  "whatsNext": { "continuations": [], "openQuestions": [] },
+  "contracts": { "layerContracts": [], "verifiedBy": [] },
+  "tests": { "unitTests": [], "sadPaths": [], "coverageTarget": 0.8 },
+  "provenance": { "phase": "onboarding", "slice": null, "createdBy": "claude", "createdAt": null, "lastUpdated": null }
+}
+
+## Instrucciones
+- Genera una EDE por cada decisi\xF3n arquitect\xF3nica significativa
+- S\xE9 ESPEC\xCDFICO para este proyecto: usa la evidencia detectada para personalizar cada decisi\xF3n
+- Incluye anti-patrones relevantes a la COMBINACI\xD3N de tecnolog\xEDas (no gen\xE9ricos)
+- IDs: EDE-001-slug, EDE-002-slug, etc.
+- cognitiveLevel: "explorer" para simples, "navigator" para intermedias, "anchor" para invariantes
+- complexityTier: 1 simple, 2 medio, 3 complejo
+- Todo el contenido en espa\xF1ol
+- Genera entre 3 y 10 EDEs seg\xFAn la complejidad del proyecto
+
+Retorna \xDANICAMENTE un array JSON v\xE1lido. Sin markdown, sin backticks, sin texto adicional.`;
+}
+function extractJson(text) {
+  const codeBlock = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlock) return codeBlock[1].trim();
+  const arrayMatch = text.match(/\[[\s\S]*\]/);
+  if (arrayMatch) return arrayMatch[0];
+  return text.trim();
+}
+function normalizeEde(raw, index) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: raw.id ?? `EDE-${String(index + 1).padStart(3, "0")}-generated`,
+    title: raw.title ?? "EDE generada por Claude",
+    version: 1,
+    status: "proposed",
+    cognitiveLevel: raw.cognitiveLevel ?? "explorer",
+    complexityTier: raw.complexityTier ?? 1,
+    whatAndHow: {
+      decision: raw.whatAndHow?.decision ?? "",
+      mechanism: raw.whatAndHow?.mechanism ?? ""
+    },
+    why: {
+      rationale: raw.why?.rationale ?? "",
+      alternativesConsidered: Array.isArray(raw.why?.alternativesConsidered) ? raw.why.alternativesConsidered : [],
+      references: []
+    },
+    whatNotToDo: {
+      antiPatterns: Array.isArray(raw.whatNotToDo?.antiPatterns) ? raw.whatNotToDo.antiPatterns : []
+    },
+    whatsNext: {
+      continuations: [],
+      openQuestions: Array.isArray(raw.whatsNext?.openQuestions) ? raw.whatsNext.openQuestions : []
+    },
+    contracts: {
+      layerContracts: Array.isArray(raw.contracts?.layerContracts) ? raw.contracts.layerContracts : [],
+      verifiedBy: []
+    },
+    tests: {
+      unitTests: [],
+      sadPaths: [],
+      coverageTarget: raw.tests?.coverageTarget ?? 0.8
+    },
+    provenance: {
+      phase: "onboarding",
+      slice: null,
+      createdBy: "claude",
+      createdAt: now,
+      lastUpdated: now
+    }
+  };
+}
+function generateWithClaude(detections) {
+  if (detections.length === 0) return null;
+  const prompt = buildPrompt(detections);
+  try {
+    const result = spawnSync("claude", ["--print"], {
+      input: prompt,
+      encoding: "utf-8",
+      timeout: 12e4,
+      shell: true,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    if (result.status !== 0 || !result.stdout) return null;
+    const jsonStr = extractJson(result.stdout);
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed) || parsed.length === 0) return null;
+    const edes = [];
+    for (let i = 0; i < parsed.length; i++) {
+      try {
+        const ede = normalizeEde(parsed[i], i);
+        if (ede.whatAndHow.decision && ede.why.rationale) {
+          edes.push(ede);
+        }
+      } catch {
+      }
+    }
+    return edes.length > 0 ? edes : null;
+  } catch {
+    return null;
+  }
+}
+
 // src/generate.ts
-function generateProposals(detections) {
+function generateFromTemplates(detections) {
   const proposals = [];
   let counter = 1;
   for (const detection of detections) {
@@ -484,6 +1054,17 @@ function generateProposals(detections) {
   }
   return proposals;
 }
+function generateProposals(detections, onStatus) {
+  if (isClaudeAvailable()) {
+    onStatus?.("Generando EDEs con Claude Code...");
+    const claudeEdes = generateWithClaude(detections);
+    if (claudeEdes && claudeEdes.length > 0) {
+      return { proposals: claudeEdes, source: "claude" };
+    }
+    onStatus?.("Claude no pudo generar EDEs, usando templates...");
+  }
+  return { proposals: generateFromTemplates(detections), source: "templates" };
+}
 
 // src/ui.ts
 import { createInterface } from "readline/promises";
@@ -738,16 +1319,16 @@ function setupDatabase(edes) {
 }
 
 // src/setup/hooks.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join12 } from "path";
 function setupHooks(projectPath) {
-  const claudeDir = join7(projectPath, ".claude");
+  const claudeDir = join12(projectPath, ".claude");
   mkdirSync2(claudeDir, { recursive: true });
-  const settingsPath = join7(claudeDir, "settings.json");
+  const settingsPath = join12(claudeDir, "settings.json");
   let existing = {};
-  if (existsSync6(settingsPath)) {
+  if (existsSync10(settingsPath)) {
     try {
-      existing = JSON.parse(readFileSync7(settingsPath, "utf-8"));
+      existing = JSON.parse(readFileSync10(settingsPath, "utf-8"));
     } catch {
     }
   }
@@ -794,7 +1375,7 @@ function setupHooks(projectPath) {
 
 // src/setup/context.ts
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join8 } from "path";
+import { join as join13 } from "path";
 
 // ../orchestrator/src/claude-context.ts
 function assembleClaudeContext(edes) {
@@ -897,9 +1478,9 @@ function setupContext(projectPath) {
   const edes = createEdeStore(db).getAll();
   db.close();
   const content = assembleClaudeContext(edes);
-  const claudeDir = join8(projectPath, ".claude");
+  const claudeDir = join13(projectPath, ".claude");
   mkdirSync3(claudeDir, { recursive: true });
-  writeFileSync2(join8(claudeDir, "CLAUDE.md"), content, "utf-8");
+  writeFileSync2(join13(claudeDir, "CLAUDE.md"), content, "utf-8");
 }
 
 // src/commands/init.ts
@@ -918,7 +1499,19 @@ async function initCommand(options) {
 `);
     }
   }
-  const proposals = generateProposals(analysis.detections);
+  w("\n");
+  const { proposals, source } = generateProposals(
+    analysis.detections,
+    (msg) => w(`  ${msg}
+`)
+  );
+  if (source === "claude") {
+    w(`  \u2713 ${proposals.length} EDEs generadas con Claude Code (IA)
+`);
+  } else {
+    w(`  \u21B3 EDEs generadas desde templates locales
+`);
+  }
   if (proposals.length === 0) {
     w("\n  No hay propuestas de EDEs para generar.\n");
     w("  Configurando infraestructura base...\n\n");
@@ -1040,11 +1633,11 @@ async function hookCommand(_event) {
 
 // src/commands/mcp.ts
 import { execFileSync } from "child_process";
-import { join as join9, dirname as dirname2 } from "path";
+import { join as join14, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 async function mcpCommand() {
   const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const mcpEntry = join9(__dirname, "mcp-entry.js");
+  const mcpEntry = join14(__dirname, "mcp-entry.js");
   execFileSync(process.execPath, [mcpEntry], {
     stdio: "inherit"
   });
@@ -1053,11 +1646,11 @@ async function mcpCommand() {
 // src/commands/start.ts
 import { execSync, spawn } from "child_process";
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join10 } from "path";
+import { join as join15 } from "path";
 import { homedir as homedir3 } from "os";
 import { createServer } from "net";
-var UMBRAL_DIR = join10(homedir3(), ".umbral");
-var COMPOSE_PATH = join10(UMBRAL_DIR, "docker-compose.yml");
+var UMBRAL_DIR = join15(homedir3(), ".umbral");
+var COMPOSE_PATH = join15(UMBRAL_DIR, "docker-compose.yml");
 var DOCKER_IMAGE = process.env.UMBRAL_IMAGE ?? "ghcr.io/josephrobles23/umbral-web:latest";
 function dockerInstalled() {
   try {
@@ -1090,7 +1683,7 @@ function findFreePort(start) {
   });
 }
 function generateCompose(webPort, wsPort) {
-  const dbPath = join10(UMBRAL_DIR, "umbral.db").replace(/\\/g, "/");
+  const dbPath = join15(UMBRAL_DIR, "umbral.db").replace(/\\/g, "/");
   const dbDir = UMBRAL_DIR.replace(/\\/g, "/");
   return `# Auto-generated by Umbral CLI \u2014 do not edit manually
 name: umbral
@@ -1189,14 +1782,14 @@ async function startCommand(options) {
 
 // src/commands/stop.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join16 } from "path";
 import { homedir as homedir4 } from "os";
-var COMPOSE_PATH2 = join11(homedir4(), ".umbral", "docker-compose.yml");
+var COMPOSE_PATH2 = join16(homedir4(), ".umbral", "docker-compose.yml");
 function stopCommand() {
   const w = (s) => process.stdout.write(s);
   w("\n  Umbral  \u2014  Deteniendo plataforma\n\n");
-  if (!existsSync8(COMPOSE_PATH2)) {
+  if (!existsSync12(COMPOSE_PATH2)) {
     w("  \u2717 No se encontro docker-compose.yml en ~/.umbral/\n");
     w("    Ejecuta 'umbral start' primero.\n\n");
     process.exit(1);
@@ -1214,7 +1807,7 @@ function stopCommand() {
 
 // src/index.ts
 var program = new Command();
-program.name("umbral").description("Umbral \u2014 Framework de gobernanza para proyectos con Claude Code").version("0.0.2");
+program.name("umbral").description("Umbral \u2014 Framework de gobernanza para proyectos con Claude Code").version("0.0.4");
 program.command("init").description("Inicializar Umbral en el proyecto actual").option("--yes", "Aceptar todas las propuestas sin preguntar").option("--path <path>", "Ruta al proyecto (default: directorio actual)").action(initCommand);
 program.command("start").description("Levantar la plataforma Umbral (Neo4j + Dashboard web)").option("--port <port>", "Puerto para el dashboard (default: auto)").option("--no-detach", "Correr en primer plano (sin -d)").action(startCommand);
 program.command("stop").description("Detener la plataforma Umbral").action(stopCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umbral/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "private": false,
   "type": "module",
   "bin": {