@codexa/cli 9.0.2 → 9.0.4

package/commands/knowledge.ts

@@ -1,5 +1,7 @@
 import { getDb } from "../db/connection";
-import { initSchema, getRelatedDecisions, getRelatedFiles, findContradictions } from "../db/schema";
+import { initSchema, getRelatedDecisions, getRelatedFiles } from "../db/schema";
+import { resolveSpec } from "./spec-resolver";
+import { CodexaError, ValidationError } from "../errors";
 
 type KnowledgeCategory = "discovery" | "decision" | "blocker" | "pattern" | "constraint";
 type KnowledgeSeverity = "info" | "warning" | "critical";
@@ -9,13 +11,7 @@ interface AddKnowledgeOptions {
   category: KnowledgeCategory;
   severity?: KnowledgeSeverity;
   broadcastTo?: string;
-}
-
-function getActiveSpec(): any {
-  const db = getDb();
-  return db
-    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-    .get();
+  specId?: string;
 }
 
 function getCurrentTask(specId: string): any {
@@ -31,24 +27,16 @@ export function addKnowledge(options: AddKnowledgeOptions): void {
   const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = getActiveSpec();
-  if (!spec) {
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
+  const spec = resolveSpec(options.specId);
 
   const currentTask = getCurrentTask(spec.id);
   if (!currentTask) {
-    console.error("\nNenhuma task em execucao.");
-    console.error("Knowledge so pode ser adicionado durante execucao de uma task.\n");
-    process.exit(1);
+    throw new CodexaError("Nenhuma task em execucao.\nKnowledge so pode ser adicionado durante execucao de uma task.");
   }
 
   const validCategories: KnowledgeCategory[] = ["discovery", "decision", "blocker", "pattern", "constraint"];
   if (!validCategories.includes(options.category)) {
-    console.error(`\nCategoria invalida: ${options.category}`);
-    console.error(`Validas: ${validCategories.join(", ")}\n`);
-    process.exit(1);
+    throw new ValidationError(`Categoria invalida: ${options.category}\nValidas: ${validCategories.join(", ")}`);
   }
 
   const severity = options.severity || "info";
@@ -79,20 +67,13 @@ export function listKnowledge(options: {
   category?: string;
   severity?: string;  // v8.0: Filtro por severidade
   json?: boolean;
+  specId?: string;
 }): void {
   initSchema();
 
   const db = getDb();
 
-  const spec = getActiveSpec();
-  if (!spec) {
-    if (options.json) {
-      console.log(JSON.stringify({ knowledge: [], message: "Nenhuma feature ativa" }));
-      return;
-    }
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
+  const spec = resolveSpec(options.specId);
 
   let query = "SELECT * FROM knowledge WHERE spec_id = ?";
   const params: any[] = [spec.id];
@@ -122,9 +103,10 @@ export function listKnowledge(options: {
     const currentTask = getCurrentTask(spec.id);
     if (currentTask) {
       filtered = knowledge.filter((k) => {
-        if (!k.acknowledged_by) return true;
-        const acked = JSON.parse(k.acknowledged_by) as number[];
-        return !acked.includes(currentTask.id);
+        const isAcked = db.query(
+          "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
+        ).get(k.id, currentTask.id);
+        return !isAcked;
       });
     }
   }
@@ -158,42 +140,29 @@ export function listKnowledge(options: {
   }
 }
 
-export function acknowledgeKnowledge(knowledgeId: string): void {
+export function acknowledgeKnowledge(knowledgeId: string, specId?: string): void {
   initSchema();
 
   const db = getDb();
 
-  const spec = getActiveSpec();
-  if (!spec) {
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
+  const spec = resolveSpec(specId);
 
   const currentTask = getCurrentTask(spec.id);
   if (!currentTask) {
-    console.error("\nNenhuma task em execucao.\n");
-    process.exit(1);
+    throw new CodexaError("Nenhuma task em execucao.");
   }
 
   const kid = parseInt(knowledgeId);
   const knowledge = db.query("SELECT * FROM knowledge WHERE id = ?").get(kid) as any;
 
   if (!knowledge) {
-    console.error(`\nKnowledge #${kid} nao encontrado.\n`);
-    process.exit(1);
+    throw new CodexaError(`Knowledge #${kid} nao encontrado.`);
   }
 
-  const acknowledged = knowledge.acknowledged_by
-    ? (JSON.parse(knowledge.acknowledged_by) as number[])
-    : [];
-
-  if (!acknowledged.includes(currentTask.id)) {
-    acknowledged.push(currentTask.id);
-    db.run("UPDATE knowledge SET acknowledged_by = ? WHERE id = ?", [
-      JSON.stringify(acknowledged),
-      kid,
-    ]);
-  }
+  db.run(
+    "INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)",
+    [kid, currentTask.id]
+  );
 
   console.log(`\nKnowledge #${kid} marcado como lido pela Task #${currentTask.number}.\n`);
 }
@@ -221,11 +190,13 @@ export function getKnowledgeForTask(specId: string, taskId: number): any[] {
 
 export function getUnreadKnowledgeForTask(specId: string, taskId: number): any[] {
   const all = getKnowledgeForTask(specId, taskId);
+  const db = getDb();
 
   return all.filter((k) => {
-    if (!k.acknowledged_by) return true;
-    const acked = JSON.parse(k.acknowledged_by) as number[];
-    return !acked.includes(taskId);
+    const isAcked = db.query(
+      "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
+    ).get(k.id, taskId);
+    return !isAcked;
   });
 }
 
@@ -233,40 +204,13 @@ export function getUnreadKnowledgeForTask(specId: string, taskId: number): any[]
 export function queryGraph(options: {
   file?: string;
   decision?: string;
-  contradictions?: boolean;
   json?: boolean;
+  specId?: string;
 }): void {
   initSchema();
   const db = getDb();
 
-  const spec = getActiveSpec();
-  if (!spec) {
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
-
-  // Buscar contradicoes
-  if (options.contradictions) {
-    const contradictions = findContradictions(spec.id);
-
-    if (options.json) {
-      console.log(JSON.stringify({ contradictions }));
-      return;
-    }
-
-    if (contradictions.length === 0) {
-      console.log("\nNenhuma contradicao detectada.\n");
-      return;
-    }
-
-    console.log(`\nContradicoes detectadas (${contradictions.length}):`);
-    console.log(`${"─".repeat(50)}`);
-    for (const c of contradictions) {
-      console.log(`  [!] "${c.decision1}" <-> "${c.decision2}"`);
-      console.log(`      Detectada em: ${c.createdAt}\n`);
-    }
-    return;
-  }
+  const spec = resolveSpec(options.specId);
 
   // Buscar relacoes para um arquivo
   if (options.file) {
@@ -357,21 +301,175 @@ export function queryGraph(options: {
   }
   console.log(`\nComandos:`);
   console.log(`  knowledge graph --file <path>           Relacoes de um arquivo`);
-  console.log(`  knowledge graph --decision <id>         Arquivos afetados por decisao`);
-  console.log(`  knowledge graph --contradictions        Detectar contradicoes\n`);
+  console.log(`  knowledge graph --decision <id>         Arquivos afetados por decisao\n`);
+}
+
+// v9.2: Jaccard similarity for knowledge compaction
+export function jaccardSimilarity(a: string, b: string): number {
+  const tokenize = (s: string): Set<string> => {
+    const words = s
+      .toLowerCase()
+      .replace(/[^\w\s-]/g, " ")
+      .split(/\s+/)
+      .filter((w) => w.length > 2);
+    return new Set(words);
+  };
+
+  const setA = tokenize(a);
+  const setB = tokenize(b);
+
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const word of setA) {
+    if (setB.has(word)) intersection++;
+  }
+
+  const union = setA.size + setB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+// v9.2: Knowledge compaction — merge similar, archive old, archive completed
+export function compactKnowledge(options: {
+  specId?: string;
+  dryRun?: boolean;
+  json?: boolean;
+}): void {
+  initSchema();
+  const db = getDb();
+
+  let merged = 0;
+  let archivedOld = 0;
+  let archivedCompleted = 0;
+
+  // Phase 1: Merge similar entries (same category + spec_id, Jaccard >= 0.8)
+  const specFilter = options.specId
+    ? "AND spec_id = ?"
+    : "";
+  const specParams = options.specId ? [options.specId] : [];
+
+  const entries = db
+    .query(
+      `SELECT * FROM knowledge WHERE severity != 'archived' ${specFilter} ORDER BY category, spec_id, created_at DESC`
+    )
+    .all(...specParams) as any[];
+
+  // Group by category + spec_id
+  const groups = new Map<string, any[]>();
+  for (const entry of entries) {
+    const key = `${entry.category}:${entry.spec_id}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key)!.push(entry);
+  }
+
+  const toArchive = new Set<number>();
+
+  for (const [, group] of groups) {
+    for (let i = 0; i < group.length; i++) {
+      if (toArchive.has(group[i].id)) continue;
+      for (let j = i + 1; j < group.length; j++) {
+        if (toArchive.has(group[j].id)) continue;
+
+        const sim = jaccardSimilarity(group[i].content, group[j].content);
+        if (sim >= 0.8) {
+          // Keep higher severity or newer; archive the other
+          const severityOrder: Record<string, number> = { critical: 3, warning: 2, info: 1, archived: 0 };
+          const keepI = (severityOrder[group[i].severity] || 0) >= (severityOrder[group[j].severity] || 0);
+          const archiveId = keepI ? group[j].id : group[i].id;
+          toArchive.add(archiveId);
+          merged++;
+        }
+      }
+    }
+  }
+
+  // Phase 2: Archive old info entries (>7 days, no graph references)
+  const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+  const oldInfoEntries = db
+    .query(
+      `SELECT k.id FROM knowledge k
+       WHERE k.severity = 'info' AND k.created_at < ? ${specFilter}
+       AND NOT EXISTS (
+         SELECT 1 FROM knowledge_graph kg
+         WHERE kg.source_id = CAST(k.id AS TEXT) AND kg.source_type = 'knowledge'
+       )
+       AND NOT EXISTS (
+         SELECT 1 FROM knowledge_graph kg
+         WHERE kg.target_id = CAST(k.id AS TEXT) AND kg.target_type = 'knowledge'
+       )`
+    )
+    .all(sevenDaysAgo, ...specParams) as any[];
+
+  for (const entry of oldInfoEntries) {
+    if (!toArchive.has(entry.id)) {
+      toArchive.add(entry.id);
+      archivedOld++;
+    }
+  }
+
+  // Phase 3: Archive all entries from completed/cancelled specs
+  const completedEntries = db
+    .query(
+      `SELECT k.id FROM knowledge k
+       JOIN specs s ON k.spec_id = s.id
+       WHERE s.phase IN ('completed', 'cancelled')
+       AND k.severity != 'archived'
+       ${options.specId ? "AND k.spec_id = ?" : ""}`
+    )
+    .all(...specParams) as any[];
+
+  for (const entry of completedEntries) {
+    if (!toArchive.has(entry.id)) {
+      toArchive.add(entry.id);
+      archivedCompleted++;
+    }
+  }
+
+  // Apply changes
+  if (!options.dryRun && toArchive.size > 0) {
+    const ids = Array.from(toArchive);
+    const placeholders = ids.map(() => "?").join(",");
+    db.run(
+      `UPDATE knowledge SET severity = 'archived' WHERE id IN (${placeholders})`,
+      ids
+    );
+  }
+
+  // Output
+  const result = {
+    merged,
+    archivedOld,
+    archivedCompleted,
+    totalArchived: toArchive.size,
+    dryRun: !!options.dryRun,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+
+  const mode = options.dryRun ? "[DRY RUN] " : "";
+  console.log(`\n${mode}Knowledge Compaction:`);
+  console.log(`${"─".repeat(50)}`);
+  console.log(`  Similares mesclados: ${merged}`);
+  console.log(`  Info antigos (>7d): ${archivedOld}`);
+  console.log(`  Specs finalizados: ${archivedCompleted}`);
+  console.log(`  Total arquivado: ${toArchive.size}`);
+  if (options.dryRun) {
+    console.log(`\nPara aplicar: knowledge compact${options.specId ? ` --spec ${options.specId}` : ""}`);
+  }
+  console.log();
 }
 
 // v9.0: Resolver/reconhecer knowledge critico (para desbloquear task start)
-export function resolveKnowledge(ids: string, resolution?: string): void {
+export function resolveKnowledge(ids: string, resolution?: string, specId?: string): void {
   initSchema();
   const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = getActiveSpec();
-  if (!spec) {
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
+  const spec = resolveSpec(specId);
 
   const knowledgeIds = ids.split(",").map(s => parseInt(s.trim()));
 
@@ -383,18 +481,10 @@ export function resolveKnowledge(ids: string, resolution?: string): void {
       continue;
     }
 
-    const acknowledged = knowledge.acknowledged_by
-      ? (JSON.parse(knowledge.acknowledged_by) as number[])
-      : [];
-
     // Usar -1 como marker de "resolvido pelo orquestrador"
-    if (!acknowledged.includes(-1)) {
-      acknowledged.push(-1);
-    }
-
     db.run(
-      "UPDATE knowledge SET acknowledged_by = ? WHERE id = ?",
-      [JSON.stringify(acknowledged), kid]
+      "INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)",
+      [kid, -1]
     );
 
     console.log(`Knowledge #${kid} resolvido.`);

package/commands/patterns.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, afterAll } from "bun:test";
+import { extractUtilitiesFromFile, inferScopeFromPath } from "./patterns";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+
+const TMP_DIR = join(import.meta.dir, "__test_tmp__");
+
+function setupTmpDir() {
+  mkdirSync(TMP_DIR, { recursive: true });
+}
+
+function cleanTmpDir() {
+  try { rmSync(TMP_DIR, { recursive: true }); } catch {}
+}
+
+function writeTmpFile(name: string, content: string): string {
+  setupTmpDir();
+  const path = join(TMP_DIR, name);
+  writeFileSync(path, content);
+  return path;
+}
+
+describe("extractUtilitiesFromFile", () => {
+  afterAll(() => cleanTmpDir());
+
+  it("extracts exported function", () => {
+    const path = writeTmpFile("func.ts", 'export function createUser(name: string): User {\n  return { name };\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("createUser");
+    expect(utils[0].type).toBe("function");
+    expect(utils[0].signature).toContain("(name: string)");
+  });
+
+  it("extracts exported async function", () => {
+    const path = writeTmpFile("async.ts", 'export async function fetchData(url: string): Promise<Data> {\n  return await fetch(url);\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("fetchData");
+    expect(utils[0].type).toBe("function");
+  });
+
+  it("extracts exported const", () => {
+    const path = writeTmpFile("const.ts", 'export const MAX_RETRIES: number = 3;');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("MAX_RETRIES");
+    expect(utils[0].type).toBe("const");
+    expect(utils[0].signature).toBe("number");
+  });
+
+  it("extracts exported const without type annotation", () => {
+    const path = writeTmpFile("const2.ts", 'export const config = { port: 3000 };');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("config");
+    expect(utils[0].type).toBe("const");
+  });
+
+  it("extracts exported class", () => {
+    const path = writeTmpFile("class.ts", 'export class UserService {\n  constructor() {}\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("UserService");
+    expect(utils[0].type).toBe("class");
+  });
+
+  it("extracts exported interface", () => {
+    const path = writeTmpFile("iface.ts", 'export interface UserProps {\n  name: string;\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("UserProps");
+    expect(utils[0].type).toBe("interface");
+  });
+
+  it("extracts exported type", () => {
+    const path = writeTmpFile("type.ts", 'export type Status = "active" | "inactive";');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("Status");
+    expect(utils[0].type).toBe("type");
+  });
+
+  it("extracts multiple exports from one file", () => {
+    const path = writeTmpFile("multi.ts", [
+      'export function foo() {}',
+      'export const BAR = 1;',
+      'export class Baz {}',
+      'export interface Qux {}',
+      'export type Quux = string;',
+    ].join("\n"));
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(5);
+    expect(utils.map(u => u.name)).toEqual(["foo", "BAR", "Baz", "Qux", "Quux"]);
+  });
+
+  it("returns empty array for non-existent file", () => {
+    const utils = extractUtilitiesFromFile("/nonexistent/path.ts");
+    expect(utils).toEqual([]);
+  });
+
+  it("returns empty array for file without exports", () => {
+    const path = writeTmpFile("noexport.ts", 'const internal = 1;\nfunction helper() {}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toEqual([]);
+  });
+
+  it("ignores non-export declarations", () => {
+    const path = writeTmpFile("mixed.ts", [
+      'const private1 = 1;',
+      'function private2() {}',
+      'export function public1() {}',
+    ].join("\n"));
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("public1");
+  });
+});
+
+describe("inferScopeFromPath", () => {
+  it("identifies backend paths", () => {
+    expect(inferScopeFromPath("src/app/api/users/route.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/server/index.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/backend/auth.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/services/user.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/actions/submit.ts")).toBe("backend");
+  });
+
+  it("identifies frontend paths", () => {
+    expect(inferScopeFromPath("src/components/Button.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/hooks/useAuth.ts")).toBe("frontend");
+    expect(inferScopeFromPath("src/pages/index.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/frontend/App.tsx")).toBe("frontend");
+  });
+
+  it("identifies frontend for /app/ paths without /api/", () => {
+    expect(inferScopeFromPath("src/app/dashboard/page.tsx")).toBe("frontend");
+  });
+
+  it("identifies database paths", () => {
+    expect(inferScopeFromPath("src/db/schema.ts")).toBe("database");
+    expect(inferScopeFromPath("src/schema/users.ts")).toBe("database");
+    expect(inferScopeFromPath("src/migrations/001.sql")).toBe("database");
+    expect(inferScopeFromPath("src/database/connection.ts")).toBe("database");
+  });
+
+  it("identifies testing paths", () => {
+    expect(inferScopeFromPath("src/tests/user.test.ts")).toBe("testing");
+    // Note: /components/ matches frontend before .test. matches testing
+    expect(inferScopeFromPath("src/components/Button.test.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/lib/auth.spec.ts")).toBe("testing");
+  });
+
+  it("returns shared for unrecognized paths", () => {
+    expect(inferScopeFromPath("src/lib/utils.ts")).toBe("shared");
+    expect(inferScopeFromPath("src/config/env.ts")).toBe("shared");
+    expect(inferScopeFromPath("package.json")).toBe("shared");
+  });
+
+  it("handles Windows-style paths (backslashes)", () => {
+    expect(inferScopeFromPath("src\\components\\Button.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src\\db\\schema.ts")).toBe("database");
+  });
+
+  it("is case-insensitive", () => {
+    expect(inferScopeFromPath("src/Components/Button.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/DB/Schema.ts")).toBe("database");
+  });
+});

package/commands/patterns.ts

@@ -8,6 +8,7 @@
 import { execSync, spawnSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
 import { extname, basename, dirname } from "path";
+import { CodexaError, ValidationError } from "../errors";
 import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 
@@ -601,10 +602,7 @@ export function patternsExtract(options: ExtractOptions): void {
 
   // Verificar grepai
   if (!isGrepaiAvailable()) {
-    console.error("\n[ERRO] grepai nao encontrado.");
-    console.error("Instale com: go install github.com/your-org/grepai@latest");
-    console.error("Ou configure no PATH.\n");
-    process.exit(1);
+    throw new CodexaError("grepai nao encontrado.\nInstale com: go install github.com/your-org/grepai@latest\nOu configure no PATH.");
   }
 
   const db = getDb();
@@ -617,9 +615,7 @@ export function patternsExtract(options: ExtractOptions): void {
   }
 
   if (queries.length === 0) {
-    console.error(`\n[ERRO] Escopo '${options.scope}' nao reconhecido.`);
-    console.error("Escopos validos: frontend, backend, database, testing\n");
-    process.exit(1);
+    throw new ValidationError("Escopo '" + options.scope + "' nao reconhecido.\nEscopos validos: frontend, backend, database, testing");
   }
 
   console.log(`\n🔍 Extraindo patterns via grepai...`);
@@ -737,15 +733,13 @@ export function patternsExtract(options: ExtractOptions): void {
 
 export function patternsAnalyze(filePath: string, json: boolean = false): void {
   if (!existsSync(filePath)) {
-    console.error(`\n[ERRO] Arquivo nao encontrado: ${filePath}\n`);
-    process.exit(1);
+    throw new CodexaError("Arquivo nao encontrado: " + filePath);
   }
 
   const analysis = analyzeFile(filePath);
 
   if (!analysis) {
-    console.error(`\n[ERRO] Nao foi possivel analisar o arquivo.\n`);
-    process.exit(1);
+    throw new CodexaError("Nao foi possivel analisar o arquivo.");
   }
 
   if (json) {
@@ -855,8 +849,7 @@ export function patternsAnalyzeDeep(files: string[], json: boolean = false): voi
   }
 
   if (analyses.length === 0) {
-    console.error("\nNenhum arquivo analisado.\n");
-    process.exit(1);
+    throw new CodexaError("Nenhum arquivo analisado.");
   }
 
   const summary = {