@codexa/cli 9.0.2 → 9.0.4

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");
+  });
+});