@codexa/cli 9.0.2 → 9.0.3

package/commands/architect.test.ts

@@ -0,0 +1,531 @@
+import { describe, it, expect } from "bun:test";
+import {
+  extractSection,
+  parseBabySteps,
+  parseRisks,
+  parseDiagrams,
+  parseDecisionsTable,
+  type BabyStep,
+  type Risk,
+  type ArchitecturalDecision,
+} from "./architect";
+
+describe("extractSection", () => {
+  it("should extract section with exact match (Tier 1)", () => {
+    const content = `## Solucao Proposta
+
+This is the proposed solution.
+
+## Other Section
+Other content.`;
+
+    const result = extractSection(content, "Solucao Proposta");
+    expect(result).toBe("This is the proposed solution.");
+  });
+
+  it("should extract section with case-insensitive match (Tier 2)", () => {
+    const content = `## solucao proposta
+
+This is the content.
+
+## Next Section`;
+
+    const result = extractSection(content, "Solucao Proposta");
+    expect(result).toBe("This is the content.");
+  });
+
+  it("should extract section using alias (Tier 3)", () => {
+    const content = `## Proposed Solution
+
+This is the solution content.
+
+## Risks`;
+
+    const result = extractSection(content, "Solucao Proposta");
+    expect(result).toBe("This is the solution content.");
+  });
+
+  it("should return empty string when header not found", () => {
+    const content = `## Some Header
+
+Content here.`;
+
+    const result = extractSection(content, "Nonexistent Section");
+    expect(result).toBe("");
+  });
+
+  it("should extract correct section when multiple sections exist", () => {
+    const content = `## Contexto e Entendimento
+
+Context content.
+
+## Solucao Proposta
+
+Solution content.
+
+## Baby Steps
+
+Steps content.`;
+
+    const result = extractSection(content, "Solucao Proposta");
+    expect(result).toBe("Solution content.");
+  });
+
+  it("should extract section with multiple lines", () => {
+    const content = `## Riscos e Mitigacoes
+
+Line 1
+Line 2
+Line 3
+
+## Next Section`;
+
+    const result = extractSection(content, "Riscos e Mitigacoes");
+    expect(result).toBe("Line 1\nLine 2\nLine 3");
+  });
+
+  it("should handle alias 'risks' for Riscos e Mitigacoes", () => {
+    const content = `## Risks
+
+Risk content here.
+
+## Other`;
+
+    const result = extractSection(content, "Riscos e Mitigacoes");
+    expect(result).toBe("Risk content here.");
+  });
+
+  it("should handle alias 'steps' for Baby Steps", () => {
+    const content = `## Steps
+
+Step content.
+
+## End`;
+
+    const result = extractSection(content, "Baby Steps");
+    expect(result).toBe("Step content.");
+  });
+});
+
+describe("parseBabySteps", () => {
+  it("should parse single basic step", () => {
+    const section = `### 1. Create schema
+
+**O que**: Build database schema
+**Por que**: Foundation for data layer`;
+
+    const result = parseBabySteps(section);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      number: 1,
+      name: "Create schema",
+      what: "Build database schema",
+      why: "Foundation for data layer",
+    });
+  });
+
+  it("should parse step with 'Step N:' format", () => {
+    const section = `### Step 2: Setup API routes
+
+**O que**: Create REST endpoints
+**Por que**: Enable frontend communication`;
+
+    const result = parseBabySteps(section);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      number: 2,
+      name: "Setup API routes",
+      what: "Create REST endpoints",
+      why: "Enable frontend communication",
+    });
+  });
+
+  it("should parse step with files", () => {
+    const section = `### 3. Implement handlers
+
+**O que**: Write business logic
+**Arquivos**: \`src/handlers/user.ts\`, \`src/handlers/auth.ts\``;
+
+    const result = parseBabySteps(section);
+    expect(result).toHaveLength(1);
+    expect(result[0].files).toEqual(["src/handlers/user.ts", "src/handlers/auth.ts"]);
+  });
+
+  it("should parse step with files using semicolon separator", () => {
+    const section = `### 1. Create files
+
+**Arquivos**: \`app.ts\`; \`config.ts\`; \`index.ts\``;
+
+    const result = parseBabySteps(section);
+    expect(result[0].files).toEqual(["app.ts", "config.ts", "index.ts"]);
+  });
+
+  it("should parse step with dependencies", () => {
+    const section = `### 4. Build UI
+
+**O que**: Create components
+**Depende de**: 1, 2, 3`;
+
+    const result = parseBabySteps(section);
+    expect(result[0].dependsOn).toEqual([1, 2, 3]);
+  });
+
+  it("should parse step with agent", () => {
+    const section = `### 5. Deploy
+
+**O que**: Setup infrastructure
+**Agente**: database-postgres`;
+
+    const result = parseBabySteps(section);
+    expect(result[0].agent).toBe("database-postgres");
+  });
+
+  it("should return empty array for empty section", () => {
+    const result = parseBabySteps("");
+    expect(result).toEqual([]);
+  });
+
+  it("should parse multiple steps", () => {
+    const section = `### 1. First step
+
+**O que**: Do first thing
+**Por que**: Needed first
+
+### 2. Second step
+
+**O que**: Do second thing
+**Por que**: Needed second
+**Depende de**: 1`;
+
+    const result = parseBabySteps(section);
+    expect(result).toHaveLength(2);
+    expect(result[0].number).toBe(1);
+    expect(result[0].name).toBe("First step");
+    expect(result[1].number).toBe(2);
+    expect(result[1].name).toBe("Second step");
+    expect(result[1].dependsOn).toEqual([1]);
+  });
+
+  it("should parse step with all fields", () => {
+    const section = `### Step 6: Complete integration
+
+**O que**: Integrate all systems
+**Por que**: Final assembly needed
+**Resultado**: Fully integrated system
+**Arquivos**: \`src/main.ts\`, \`src/index.ts\`
+**Agente**: frontend-next
+**Depende de**: 4, 5`;
+
+    const result = parseBabySteps(section);
+    expect(result[0]).toMatchObject({
+      number: 6,
+      name: "Complete integration",
+      what: "Integrate all systems",
+      why: "Final assembly needed",
+      result: "Fully integrated system",
+      files: ["src/main.ts", "src/index.ts"],
+      agent: "frontend-next",
+      dependsOn: [4, 5],
+    });
+  });
+
+  it("should handle files without backticks", () => {
+    const section = `### 1. Create files
+
+**Arquivos**: file1.ts, file2.ts`;
+
+    const result = parseBabySteps(section);
+    expect(result[0].files).toEqual(["file1.ts", "file2.ts"]);
+  });
+});
+
+describe("parseRisks", () => {
+  it("should parse standard risk with R prefix", () => {
+    const section = `### R1. Data loss
+
+**Probabilidade**: high
+**Impacto**: high
+**Mitigacao**: Implement automated backups`;
+
+    const result = parseRisks(section);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      id: "R1",
+      description: "Data loss",
+      probability: "high",
+      impact: "high",
+      mitigation: "Implement automated backups",
+    });
+  });
+
+  it("should parse risk without R prefix", () => {
+    const section = `### 1. Performance degradation
+
+**Probabilidade**: medium
+**Impacto**: high
+**Mitigacao**: Add caching layer`;
+
+    const result = parseRisks(section);
+    expect(result[0]).toMatchObject({
+      id: "R1",
+      description: "Performance degradation",
+      probability: "medium",
+      impact: "high",
+      mitigation: "Add caching layer",
+    });
+  });
+
+  it("should return empty array for empty section", () => {
+    const result = parseRisks("");
+    expect(result).toEqual([]);
+  });
+
+  it("should default to medium for missing probability", () => {
+    const section = `### R2. Security breach
+
+**Impacto**: high
+**Mitigacao**: Use encryption`;
+
+    const result = parseRisks(section);
+    expect(result[0].probability).toBe("medium");
+  });
+
+  it("should default to medium for missing impact", () => {
+    const section = `### R3. API rate limiting
+
+**Probabilidade**: low
+**Mitigacao**: Implement retry logic`;
+
+    const result = parseRisks(section);
+    expect(result[0].impact).toBe("medium");
+  });
+
+  it("should handle Mitigação with cedilla", () => {
+    const section = `### R1. Test risk
+
+**Probabilidade**: low
+**Impacto**: low
+**Mitigação**: Do something`;
+
+    const result = parseRisks(section);
+    expect(result[0].mitigation).toBe("Do something");
+  });
+
+  it("should parse multiple risks", () => {
+    const section = `### R1. First risk
+
+**Probabilidade**: high
+**Impacto**: medium
+**Mitigacao**: Mitigation 1
+
+### R2. Second risk
+
+**Probabilidade**: low
+**Impacto**: high
+**Mitigacao**: Mitigation 2`;
+
+    const result = parseRisks(section);
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe("R1");
+    expect(result[0].description).toBe("First risk");
+    expect(result[1].id).toBe("R2");
+    expect(result[1].description).toBe("Second risk");
+  });
+
+  it("should handle probability and impact variations", () => {
+    const section = `### R1. Test
+
+**Probabilidade**: high
+**Impacto**: low
+**Mitigacao**: Fix`;
+
+    const result = parseRisks(section);
+    expect(result[0].probability).toBe("high");
+    expect(result[0].impact).toBe("low");
+  });
+});
+
+describe("parseDiagrams", () => {
+  it("should parse mermaid flowchart diagram", () => {
+    const section = `### System Architecture
+
+Some description here.
+
+\`\`\`mermaid
+flowchart TD
+  A[Client] --> B[Server]
+  B --> C[Database]
+\`\`\``;
+
+    const result = parseDiagrams(section);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      name: "System Architecture",
+      type: "flowchart",
+      content: "flowchart TD\n  A[Client] --> B[Server]\n  B --> C[Database]",
+    });
+  });
+
+  it("should parse mermaid sequence diagram", () => {
+    const section = `### User Flow
+
+\`\`\`mermaid
+sequenceDiagram
+  User->>API: Request
+  API->>DB: Query
+  DB-->>API: Result
+  API-->>User: Response
+\`\`\``;
+
+    const result = parseDiagrams(section);
+    expect(result[0]).toMatchObject({
+      name: "User Flow",
+      type: "sequenceDiagram",
+    });
+  });
+
+  it("should return empty array when no diagrams present", () => {
+    const section = `### Some Section
+
+No diagrams here.`;
+
+    const result = parseDiagrams(section);
+    expect(result).toEqual([]);
+  });
+
+  it("should parse multiple diagrams", () => {
+    const section = `### First Diagram
+
+\`\`\`mermaid
+flowchart LR
+  A --> B
+\`\`\`
+
+### Second Diagram
+
+\`\`\`mermaid
+graph TD
+  C --> D
+\`\`\``;
+
+    const result = parseDiagrams(section);
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe("First Diagram");
+    expect(result[0].type).toBe("flowchart");
+    expect(result[1].name).toBe("Second Diagram");
+    expect(result[1].type).toBe("graph");
+  });
+
+  it("should handle diagram with complex content", () => {
+    const section = `### Component Diagram
+
+\`\`\`mermaid
+classDiagram
+  class User {
+    +String name
+    +String email
+    +login()
+  }
+  class Admin {
+    +deleteUser()
+  }
+  User <|-- Admin
+\`\`\``;
+
+    const result = parseDiagrams(section);
+    expect(result[0].type).toBe("classDiagram");
+    expect(result[0].content).toContain("class User");
+    expect(result[0].content).toContain("User <|-- Admin");
+  });
+});
+
+describe("parseDecisionsTable", () => {
+  it("should parse standard decisions table", () => {
+    const section = `| Decisao | Justificativa |
+| --- | --- |
+| Use Drizzle ORM | Better TypeScript support and DX |
+| Deploy on Vercel | Seamless Next.js integration |`;
+
+    const result = parseDecisionsTable(section);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({
+      decision: "Use Drizzle ORM",
+      rationale: "Better TypeScript support and DX",
+    });
+    expect(result[1]).toMatchObject({
+      decision: "Deploy on Vercel",
+      rationale: "Seamless Next.js integration",
+    });
+  });
+
+  it("should skip header row with 'Decisao'", () => {
+    const section = `| Decisao | Justificativa |
+| --- | --- |
+| Use PostgreSQL | Reliable and scalable |`;
+
+    const result = parseDecisionsTable(section);
+    expect(result).toHaveLength(1);
+    expect(result[0].decision).not.toBe("Decisao");
+  });
+
+  it("should return empty array for empty section", () => {
+    const result = parseDecisionsTable("");
+    expect(result).toEqual([]);
+  });
+
+  it("should handle table with only header", () => {
+    const section = `| Decisao | Justificativa |
+| --- | --- |`;
+
+    const result = parseDecisionsTable(section);
+    expect(result).toEqual([]);
+  });
+
+  it("should parse single decision", () => {
+    const section = `| Decisao | Justificativa |
+| --- | --- |
+| Use TypeScript | Type safety and better IDE support |`;
+
+    const result = parseDecisionsTable(section);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      decision: "Use TypeScript",
+      rationale: "Type safety and better IDE support",
+    });
+  });
+
+  it("should handle decisions with pipes in content", () => {
+    const section = `| Decisao | Justificativa |
+| --- | --- |
+| Use A or B | Choose A if X, otherwise B |`;
+
+    const result = parseDecisionsTable(section);
+    expect(result).toHaveLength(1);
+    // Note: This will capture "Use A or B " due to split behavior
+    expect(result[0].decision).toContain("Use A or B");
+  });
+
+  it("should trim whitespace from cells", () => {
+    const section = `| Decisao | Justificativa |
+| --- | --- |
+|  Use React  |  Component-based architecture  |`;
+
+    const result = parseDecisionsTable(section);
+    expect(result[0].decision).toBe("Use React");
+    expect(result[0].rationale).toBe("Component-based architecture");
+  });
+
+  it("should handle alternative header names (not auto-skipped)", () => {
+    // Note: The code only skips rows where decision === "Decisao", not "Decision"
+    // So "Decision" header row is treated as a data row
+    const section = `| Decision | Rationale |
+| --- | --- |
+| Use REST API | Well-understood and widely supported |`;
+
+    const result = parseDecisionsTable(section);
+    // "Decision" row is included (not filtered), separator is skipped
+    expect(result).toHaveLength(2);
+    expect(result[0].decision).toBe("Decision");
+    expect(result[1].decision).toBe("Use REST API");
+  });
+});

package/commands/architect.ts

@@ -7,7 +7,7 @@ import { join } from "path";
 // TYPES
 // ═══════════════════════════════════════════════════════════════
 
-interface BabyStep {
+export interface BabyStep {
   number: number;
   name: string;
   what: string;
@@ -18,7 +18,7 @@ interface BabyStep {
   dependsOn?: number[];
 }
 
-interface Risk {
+export interface Risk {
   id: string;
   description: string;
   probability: "low" | "medium" | "high";
@@ -35,7 +35,7 @@ interface Alternative {
   whyDiscarded?: string;
 }
 
-interface ArchitecturalDecision {
+export interface ArchitecturalDecision {
   decision: string;
   rationale: string;
 }
@@ -103,23 +103,80 @@ function formatDate(date: Date): string {
 }
 
 // ═══════════════════════════════════════════════════════════════
-// MARKDOWN PARSER (v8.4)
+// MARKDOWN PARSER (v8.4 + v9.0 tolerant matching)
 // ═══════════════════════════════════════════════════════════════
 
-function extractSection(content: string, header: string): string {
-  // Split por headers ## e encontrar a secao correta
+const HEADER_ALIASES: Record<string, string[]> = {
+  "Contexto e Entendimento": [
+    "contexto e entendimento", "context and understanding", "contexto",
+    "entendimento do problema", "understanding", "background",
+  ],
+  "Stack e Arquitetura Atual": [
+    "stack e arquitetura atual", "stack e arquitetura", "current architecture",
+    "arquitetura atual", "stack atual", "tech stack",
+  ],
+  "Solucao Proposta": [
+    "solucao proposta", "proposed solution", "abordagem proposta",
+    "proposta", "solution", "approach",
+  ],
+  "Diagramas": [
+    "diagramas", "diagrams", "diagramas mermaid", "architecture diagrams",
+  ],
+  "Baby Steps": [
+    "baby steps", "passos", "steps", "plano de implementacao",
+    "implementation plan", "implementation steps", "etapas",
+  ],
+  "Riscos e Mitigacoes": [
+    "riscos e mitigacoes", "risks and mitigations", "riscos",
+    "risks", "analise de riscos", "risk analysis",
+  ],
+  "Alternativas Descartadas": [
+    "alternativas descartadas", "alternativas", "alternatives",
+    "discarded alternatives", "alternativas consideradas",
+  ],
+  "Decisoes Arquiteturais": [
+    "decisoes arquiteturais", "architectural decisions",
+    "decisoes", "decisions",
+  ],
+};
+
+export function extractSection(content: string, header: string): string {
   const sections = content.split(/^## /m);
+
+  // Tier 1: Exact startsWith (fast path)
   for (const section of sections) {
     if (section.startsWith(header)) {
-      // Remover o header e retornar o conteudo
       const lines = section.split("\n");
       return lines.slice(1).join("\n").trim();
     }
   }
+
+  // Tier 2: Case-insensitive startsWith
+  const headerLower = header.toLowerCase();
+  for (const section of sections) {
+    if (section.toLowerCase().startsWith(headerLower)) {
+      const lines = section.split("\n");
+      return lines.slice(1).join("\n").trim();
+    }
+  }
+
+  // Tier 3: Alias-based includes matching (case-insensitive)
+  const aliases = HEADER_ALIASES[header] || [];
+  for (const section of sections) {
+    const sectionHeader = section.split("\n")[0]?.toLowerCase().trim() || "";
+    for (const alias of aliases) {
+      if (sectionHeader.includes(alias)) {
+        const lines = section.split("\n");
+        return lines.slice(1).join("\n").trim();
+      }
+    }
+  }
+
+  console.warn(`[architect] Secao "${header}" nao encontrada no .md`);
   return "";
 }
 
-function parseBabySteps(section: string): BabyStep[] {
+export function parseBabySteps(section: string): BabyStep[] {
   if (!section) return [];
   const steps: BabyStep[] = [];
   // Match "### N. Name" or "### Step N: Name"
@@ -152,7 +209,7 @@ function parseBabySteps(section: string): BabyStep[] {
   return steps;
 }
 
-function parseRisks(section: string): Risk[] {
+export function parseRisks(section: string): Risk[] {
   if (!section) return [];
   const risks: Risk[] = [];
   const riskBlocks = section.split(/^###\s+/m).filter(Boolean);
@@ -173,7 +230,7 @@ function parseRisks(section: string): Risk[] {
   return risks;
 }
 
-function parseDiagrams(section: string): { name: string; type: string; content: string }[] {
+export function parseDiagrams(section: string): { name: string; type: string; content: string }[] {
   if (!section) return [];
   const diagrams: { name: string; type: string; content: string }[] = [];
   const diagramRegex = /###\s+(.+)\n[\s\S]*?```mermaid\n([\s\S]*?)```/g;
@@ -192,7 +249,7 @@ function parseDiagrams(section: string): { name: string; type: string; content:
   return diagrams;
 }
 
-function parseDecisionsTable(section: string): ArchitecturalDecision[] {
+export function parseDecisionsTable(section: string): ArchitecturalDecision[] {
   if (!section) return [];
   const decisions: ArchitecturalDecision[] = [];
   const lines = section.split("\n");

package/commands/clear.ts

@@ -71,7 +71,6 @@ export function clearTasks(options: ClearOptions = {}): void {
   // Ordem de deleção respeita foreign keys
   // v8.0: Incluindo novas tabelas
   const tablesToClear = [
-    "session_summaries",
     "reasoning_log",
     "knowledge_graph",
     "knowledge",