@codexa/cli 9.0.23 → 9.0.25

package/context/file-writer.ts

@@ -37,7 +37,7 @@ export function cleanupContextFiles(specId: string): void {
     const { readdirSync, unlinkSync } = require("fs");
     const files = readdirSync(dir) as string[];
     for (const file of files) {
-      if (file.startsWith("task-") && file.endsWith(".md")) {
+      if ((file.startsWith("task-") || file.startsWith("simplify-")) && file.endsWith(".md")) {
         unlinkSync(join(dir, file));
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.23",
+  "version": "9.0.25",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {
@@ -15,6 +15,7 @@
     "gates/",
     "protocol/",
     "detectors/",
+    "simplify/",
     "templates/"
   ],
   "scripts": {

package/simplify/prompt-builder.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { getDb } from "../db/connection";
+import { initSchema, runMigrations } from "../db/schema";
+import {
+  buildSimplifyPrompt,
+  getStandardsForSimplify,
+  formatStandardsBlock,
+  type SimplifyFile,
+} from "./prompt-builder";
+import { writeFileSync, mkdirSync, existsSync, rmSync } from "fs";
+import { join } from "path";
+
+// ═══════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════
+
+const TMP_DIR = join(process.cwd(), ".codexa", "test-tmp-simplify");
+
+function ensureTmpDir() {
+  if (!existsSync(TMP_DIR)) {
+    mkdirSync(TMP_DIR, { recursive: true });
+  }
+}
+
+function createTmpFile(name: string, content: string): string {
+  ensureTmpDir();
+  const path = join(TMP_DIR, name);
+  writeFileSync(path, content);
+  return path;
+}
+
+function insertStandard(opts: {
+  category: string;
+  scope: string;
+  rule: string;
+  enforcement?: string;
+  examples?: string;
+  anti_examples?: string;
+  semantic_query?: string | null;
+}) {
+  const db = getDb();
+  db.run(
+    `INSERT INTO standards (category, scope, rule, examples, anti_examples, enforcement, semantic_query, expect, source, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, 'no_match', 'test', datetime('now'))`,
+    [
+      opts.category,
+      opts.scope,
+      opts.rule,
+      opts.examples || null,
+      opts.anti_examples || null,
+      opts.enforcement || "required",
+      opts.semantic_query || null,
+    ]
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════
+// TESTS
+// ═══════════════════════════════════════════════════════════════
+
+describe("simplify prompt-builder", () => {
+  beforeEach(() => {
+    initSchema();
+    runMigrations();
+    const db = getDb();
+    db.run("DELETE FROM standards");
+    // Cleanup tmp
+    if (existsSync(TMP_DIR)) {
+      rmSync(TMP_DIR, { recursive: true, force: true });
+    }
+  });
+
+  // ── getStandardsForSimplify ─────────────────────────────────
+
+  describe("getStandardsForSimplify", () => {
+    it("returns standards filtered by scope", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Global rule" });
+      insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
+      insertStandard({ category: "code", scope: "frontend", rule: "Frontend rule" });
+
+      const backendStds = getStandardsForSimplify("backend");
+      expect(backendStds.length).toBe(2);
+      expect(backendStds.map(s => s.rule)).toContain("Global rule");
+      expect(backendStds.map(s => s.rule)).toContain("Backend rule");
+      expect(backendStds.map(s => s.rule)).not.toContain("Frontend rule");
+    });
+
+    it("returns all standards when scope is 'all'", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Global rule" });
+      insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
+
+      const allStds = getStandardsForSimplify("all");
+      expect(allStds.length).toBe(1);
+      expect(allStds[0].rule).toBe("Global rule");
+    });
+
+    it("returns empty array when no standards exist", () => {
+      const stds = getStandardsForSimplify("backend");
+      expect(stds.length).toBe(0);
+    });
+
+    it("orders required before recommended", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Recommended", enforcement: "recommended" });
+      insertStandard({ category: "code", scope: "all", rule: "Required", enforcement: "required" });
+
+      const stds = getStandardsForSimplify("all");
+      expect(stds[0].rule).toBe("Required");
+      expect(stds[1].rule).toBe("Recommended");
+    });
+  });
+
+  // ── formatStandardsBlock ────────────────────────────────────
+
+  describe("formatStandardsBlock", () => {
+    it("formats standards with examples and anti_examples", () => {
+      const standards = [
+        {
+          id: 1,
+          category: "code",
+          scope: "all",
+          rule: "Use function declaration",
+          examples: JSON.stringify(["function foo() {}"]),
+          anti_examples: JSON.stringify(["const foo = () => {}"]),
+          enforcement: "required",
+          semantic_query: null,
+        },
+      ];
+
+      const block = formatStandardsBlock(standards);
+      expect(block).toContain("## Standards do Projeto");
+      expect(block).toContain("### Obrigatorios (required)");
+      expect(block).toContain("[code] Use function declaration");
+      expect(block).toContain("Bom: function foo() {}");
+      expect(block).toContain("Ruim: const foo = () => {}");
+    });
+
+    it("formats standards with semantic_query", () => {
+      const standards = [
+        {
+          id: 1,
+          category: "practice",
+          scope: "all",
+          rule: "No console.log in production",
+          examples: null,
+          anti_examples: null,
+          enforcement: "required",
+          semantic_query: "console.log statements in non-test files",
+        },
+      ];
+
+      const block = formatStandardsBlock(standards);
+      expect(block).toContain('Detectar: "console.log statements in non-test files"');
+    });
+
+    it("separates required and recommended sections", () => {
+      const standards = [
+        {
+          id: 1, category: "code", scope: "all", rule: "Required rule",
+          examples: null, anti_examples: null, enforcement: "required", semantic_query: null,
+        },
+        {
+          id: 2, category: "code", scope: "all", rule: "Recommended rule",
+          examples: null, anti_examples: null, enforcement: "recommended", semantic_query: null,
+        },
+      ];
+
+      const block = formatStandardsBlock(standards);
+      expect(block).toContain("### Obrigatorios (required)");
+      expect(block).toContain("### Recomendados (recommended)");
+      expect(block).toContain("Required rule");
+      expect(block).toContain("Recommended rule");
+    });
+
+    it("returns empty string when no standards", () => {
+      expect(formatStandardsBlock([])).toBe("");
+    });
+  });
+
+  // ── buildSimplifyPrompt ─────────────────────────────────────
+
+  describe("buildSimplifyPrompt", () => {
+    it("builds refactor prompt with standards and files", () => {
+      insertStandard({
+        category: "code",
+        scope: "all",
+        rule: "Use function declarations",
+        examples: JSON.stringify(["function foo() {}"]),
+        anti_examples: JSON.stringify(["const foo = () => {}"]),
+      });
+
+      const filePath = createTmpFile("test.ts", "export function hello() {}");
+      const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
+
+      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+
+      expect(prompt).toContain("## Standards do Projeto");
+      expect(prompt).toContain("Use function declarations");
+      expect(prompt).toContain("## Arquivos para Simplificar");
+      expect(prompt).toContain("(criado)");
+      expect(prompt).toContain("## Instrucoes");
+      expect(prompt).toContain("Preservem funcionalidade");
+    });
+
+    it("builds audit prompt with analysis-only instructions", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Some rule" });
+
+      const filePath = createTmpFile("test2.ts", "export const x = 1;");
+      const files: SimplifyFile[] = [{ path: filePath, action: "modified" }];
+
+      const prompt = buildSimplifyPrompt(files, "all", "audit");
+
+      expect(prompt).toContain("NAO aplique mudancas");
+      expect(prompt).toContain("reporte oportunidades");
+      expect(prompt).toContain("(modificado)");
+    });
+
+    it("handles no standards gracefully", () => {
+      const filePath = createTmpFile("test3.ts", "export const y = 2;");
+      const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
+
+      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+
+      // Should still have files and instructions sections
+      expect(prompt).toContain("## Arquivos para Simplificar");
+      expect(prompt).toContain("## Instrucoes");
+      // Should NOT have standards section
+      expect(prompt).not.toContain("## Standards do Projeto");
+    });
+
+    it("filters out non-existing files", () => {
+      const filePath = createTmpFile("exists.ts", "export const z = 3;");
+      const files: SimplifyFile[] = [
+        { path: filePath, action: "created" },
+        { path: "/nonexistent/file.ts", action: "modified" },
+      ];
+
+      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+
+      expect(prompt).toContain("exists.ts");
+      expect(prompt).not.toContain("nonexistent");
+    });
+
+    it("filters standards by scope", () => {
+      insertStandard({ category: "code", scope: "backend", rule: "Backend only rule" });
+      insertStandard({ category: "code", scope: "frontend", rule: "Frontend only rule" });
+
+      const filePath = createTmpFile("test4.ts", "export const a = 1;");
+      const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
+
+      const prompt = buildSimplifyPrompt(files, "backend", "refactor");
+
+      expect(prompt).toContain("Backend only rule");
+      expect(prompt).not.toContain("Frontend only rule");
+    });
+  });
+});

package/simplify/prompt-builder.ts

@@ -0,0 +1,198 @@
+// ═══════════════════════════════════════════════════════════════
+// SIMPLIFY PROMPT BUILDER (v10.1)
+// Builds rich simplification prompts using Codexa standards
+// from SQLite. Generates context files for the simplifier agent.
+// ═══════════════════════════════════════════════════════════════
+
+import { getDb } from "../db/connection";
+import { existsSync } from "fs";
+import { resolve, join } from "path";
+import { ensureContextDir } from "../context/file-writer";
+
+// ═══════════════════════════════════════════════════════════════
+// INTERFACES
+// ═══════════════════════════════════════════════════════════════
+
+interface StandardRow {
+  id: number;
+  category: string;
+  scope: string;
+  rule: string;
+  examples: string | null;
+  anti_examples: string | null;
+  enforcement: string;
+  semantic_query: string | null;
+}
+
+export interface SimplifyFile {
+  path: string;
+  action: "created" | "modified";
+}
+
+export type SimplifyMode = "refactor" | "audit";
+
+// ═══════════════════════════════════════════════════════════════
+// STANDARDS RETRIEVAL
+// ═══════════════════════════════════════════════════════════════
+
+export function getStandardsForSimplify(agentDomain: string): StandardRow[] {
+  const db = getDb();
+  return db
+    .query(
+      `SELECT id, category, scope, rule, examples, anti_examples, enforcement, semantic_query
+       FROM standards
+       WHERE (scope = 'all' OR scope = ?)
+       ORDER BY enforcement DESC, category`
+    )
+    .all(agentDomain) as StandardRow[];
+}
+
+// ═══════════════════════════════════════════════════════════════
+// STANDARDS FORMATTING
+// ═══════════════════════════════════════════════════════════════
+
+export function formatStandardsBlock(standards: StandardRow[]): string {
+  if (standards.length === 0) return "";
+
+  const required = standards.filter(s => s.enforcement === "required");
+  const recommended = standards.filter(s => s.enforcement === "recommended");
+
+  let block = "## Standards do Projeto\n";
+
+  if (required.length > 0) {
+    block += "\n### Obrigatorios (required)\n";
+    block += formatStandardsList(required);
+  }
+
+  if (recommended.length > 0) {
+    block += "\n### Recomendados (recommended)\n";
+    block += formatStandardsList(recommended);
+  }
+
+  return block;
+}
+
+function formatStandardsList(standards: StandardRow[]): string {
+  let result = "";
+
+  for (const std of standards) {
+    result += `\n- [${std.category}] ${std.rule}`;
+
+    // Add good examples
+    const examples = parseJsonArray(std.examples);
+    if (examples.length > 0) {
+      for (const ex of examples.slice(0, 2)) {
+        result += `\n  Bom: ${ex}`;
+      }
+    }
+
+    // Add bad examples (anti-patterns)
+    const antiExamples = parseJsonArray(std.anti_examples);
+    if (antiExamples.length > 0) {
+      for (const anti of antiExamples.slice(0, 2)) {
+        result += `\n  Ruim: ${anti}`;
+      }
+    }
+
+    // Add semantic detection hint
+    if (std.semantic_query) {
+      result += `\n  Detectar: "${std.semantic_query}"`;
+    }
+  }
+
+  return result + "\n";
+}
+
+function parseJsonArray(json: string | null): string[] {
+  if (!json) return [];
+  try {
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// PROMPT BUILDER
+// ═══════════════════════════════════════════════════════════════
+
+export function buildSimplifyPrompt(
+  files: SimplifyFile[],
+  agentDomain: string,
+  mode: SimplifyMode
+): string {
+  const standards = getStandardsForSimplify(agentDomain);
+  const existingFiles = files.filter(f => existsSync(f.path));
+
+  let prompt = "";
+
+  // Standards section
+  const standardsBlock = formatStandardsBlock(standards);
+  if (standardsBlock) {
+    prompt += standardsBlock + "\n";
+  }
+
+  // Files section
+  prompt += "## Arquivos para Simplificar\n\n";
+  if (existingFiles.length === 0) {
+    prompt += "Nenhum arquivo encontrado.\n";
+  } else {
+    for (const file of existingFiles) {
+      prompt += `- \`${file.path}\` (${file.action === "created" ? "criado" : "modificado"})\n`;
+    }
+  }
+
+  // Instructions section
+  prompt += "\n## Instrucoes\n\n";
+
+  if (mode === "refactor") {
+    prompt += `Voce e um especialista em simplificacao de codigo. Analise os arquivos listados e aplique refinamentos que:
+
+1. **Preservem funcionalidade**: Nunca altere o que o codigo faz — apenas como faz.
+2. **Sigam os standards acima**: Aplique todas as regras obrigatorias. Considere as recomendadas.
+3. **Melhorem clareza**: Reduza complexidade, nesting, redundancias, abstracoes desnecessarias.
+4. **Mantenham equilibrio**: Evite over-simplificacao. Codigo explicito > codigo compacto.
+5. **Foquem no escopo**: Apenas refine os arquivos listados.
+
+Apos simplificar, liste as mudancas significativas realizadas.`;
+  } else {
+    prompt += `Voce e um especialista em simplificacao de codigo. Analise os arquivos listados e reporte oportunidades de simplificacao.
+
+**NAO aplique mudancas.** Apenas gere um relatorio com:
+
+1. **Oportunidades por arquivo**: Liste cada oportunidade com severidade (alta/media/baixa).
+2. **Violacoes de standards**: Identifique codigo que viola os standards obrigatorios acima.
+3. **Over-engineering**: Identifique abstracoes desnecessarias, complexidade excessiva.
+4. **Resumo**: Contagem de oportunidades por severidade.
+
+Formato do relatorio:
+\`\`\`
+### <arquivo>
+- [alta] <descricao da oportunidade>
+- [media] <descricao>
+- [baixa] <descricao>
+
+### Resumo
+- Alta: N oportunidades
+- Media: N oportunidades
+- Baixa: N oportunidades
+\`\`\``;
+  }
+
+  return prompt;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// CONTEXT FILE WRITER
+// ═══════════════════════════════════════════════════════════════
+
+export function writeSimplifyContext(
+  identifier: string,
+  content: string
+): string {
+  const dir = ensureContextDir();
+  const filePath = join(dir, `simplify-${identifier}.md`);
+  Bun.write(filePath, content);
+  return resolve(filePath);
+}