@codexa/cli 9.0.2 → 9.0.4

package/commands/discover.ts

@@ -11,6 +11,7 @@ import {
   getDetailedTechnologies,
   type UnifiedDetectionResult,
 } from "../detectors/loader";
+import { CodexaError } from "../errors";
 
 interface StackDetection {
   frontend?: string;
@@ -172,9 +173,7 @@ export function discoverConfirm(): void {
 
   const pending = db.query("SELECT * FROM project WHERE id = 'pending'").get() as any;
   if (!pending) {
-    console.error("\nNenhuma descoberta pendente.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Nenhuma descoberta pendente.\nExecute: discover start primeiro");
   }
 
   const data = JSON.parse(pending.stack);
@@ -183,9 +182,9 @@ export function discoverConfirm(): void {
   // Mover de pending para default
   db.run("DELETE FROM project WHERE id = 'pending'");
   db.run(
-    `INSERT INTO project (id, name, stack, discovered_at, updated_at, cli_version)
-     VALUES ('default', ?, ?, ?, ?, ?)`,
-    ["Projeto", JSON.stringify(data.stack), now, now, pkg.version]
+    `INSERT INTO project (id, name, stack, discovered_at, updated_at, cli_version, last_discover_at)
+     VALUES ('default', ?, ?, ?, ?, ?, ?)`,
+    ["Projeto", JSON.stringify(data.stack), now, now, pkg.version, now]
   );
 
   // Criar standards baseados na estrutura detectada
@@ -283,9 +282,7 @@ export function discoverShow(json: boolean = false): void {
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
 
   if (!project) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start");
   }
 
   const standards = db.query("SELECT * FROM standards ORDER BY category, scope").all() as any[];
@@ -381,9 +378,7 @@ export async function discoverRefresh(options: { force?: boolean } = {}): Promis
 
   const currentProject = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
   if (!currentProject) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start primeiro");
   }
 
   const currentStack = JSON.parse(currentProject.stack);
@@ -460,6 +455,129 @@ export async function discoverRefresh(options: { force?: boolean } = {}): Promis
   }
 }
 
+export async function discoverIncremental(): Promise<void> {
+  initSchema();
+  const db = getDb();
+
+  const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
+  if (!project) {
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start primeiro");
+  }
+
+  // Data de referencia: last_discover_at > discovered_at > fallback 30 dias
+  const sinceDate = project.last_discover_at || project.discovered_at ||
+    new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+
+  console.log(`\nDiscover incremental desde: ${sinceDate}\n`);
+
+  // Listar arquivos modificados via git
+  const gitResult = spawnSync("git", [
+    "diff", "--name-only", "--diff-filter=ACMR",
+    `--since=${sinceDate}`, "HEAD"
+  ], { encoding: "utf-8", timeout: 10000 });
+
+  // Fallback: se --since nao funciona com diff, usar log
+  let modifiedFiles: string[] = [];
+  if (gitResult.status !== 0 || !gitResult.stdout.trim()) {
+    const logResult = spawnSync("git", [
+      "log", "--since", sinceDate, "--name-only", "--pretty=format:", "--diff-filter=ACMR"
+    ], { encoding: "utf-8", timeout: 10000 });
+
+    if (logResult.status === 0 && logResult.stdout.trim()) {
+      modifiedFiles = [...new Set(logResult.stdout.trim().split("\n").filter(f => f.trim()))];
+    }
+  } else {
+    modifiedFiles = [...new Set(gitResult.stdout.trim().split("\n").filter(f => f.trim()))];
+  }
+
+  // Filtrar apenas arquivos que ainda existem e sao codigo
+  const codeExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".cs", ".dart"];
+  const existingFiles = modifiedFiles.filter(f => {
+    const fullPath = join(process.cwd(), f);
+    return existsSync(fullPath) && codeExtensions.some(ext => f.endsWith(ext));
+  });
+
+  if (existingFiles.length === 0) {
+    console.log("Nenhum arquivo de codigo modificado desde ultimo discover.");
+    console.log("Stack e utilities estao atualizados.\n");
+
+    // Atualizar timestamp mesmo sem mudancas
+    const now = new Date().toISOString();
+    db.run("UPDATE project SET last_discover_at = ? WHERE id = 'default'", [now]);
+    return;
+  }
+
+  console.log(`[1/3] Analisando ${existingFiles.length} arquivo(s) modificado(s)...`);
+
+  // Importar funcoes de patterns
+  const { extractUtilitiesFromFile, inferScopeFromPath } = await import("./patterns");
+  const { upsertUtility } = await import("../db/schema");
+
+  // Extrair utilities dos arquivos modificados
+  let utilitiesUpdated = 0;
+  for (const file of existingFiles) {
+    const fullPath = join(process.cwd(), file);
+    const utilities = extractUtilitiesFromFile(fullPath);
+    const scope = inferScopeFromPath(file);
+
+    for (const util of utilities) {
+      upsertUtility({
+        filePath: file,
+        utilityName: util.name,
+        utilityType: util.type,
+        scope,
+        signature: util.signature,
+      });
+      utilitiesUpdated++;
+    }
+  }
+
+  console.log(`    ✓ ${utilitiesUpdated} utilities registradas/atualizadas`);
+
+  // Re-detectar stack e comparar
+  console.log("\n[2/3] Verificando mudancas no stack...");
+  const currentStack = JSON.parse(project.stack);
+  const newStack = await detectStack();
+
+  const stackChanges: { key: string; from: string | undefined; to: string | undefined }[] = [];
+  const allKeys = new Set([...Object.keys(currentStack), ...Object.keys(newStack)]);
+
+  for (const key of allKeys) {
+    const current = currentStack[key as keyof StackDetection];
+    const detected = newStack[key as keyof StackDetection];
+    if (current !== detected) {
+      stackChanges.push({ key, from: current, to: detected });
+    }
+  }
+
+  if (stackChanges.length > 0) {
+    console.log("    ⚠ Mudancas detectadas no stack:");
+    for (const change of stackChanges) {
+      const from = change.from || "(nao definido)";
+      const to = change.to || "(removido)";
+      console.log(`      ${change.key}: ${from} → ${to}`);
+    }
+    console.log("    Use: discover refresh --force para aplicar");
+  } else {
+    console.log("    ✓ Stack inalterado");
+  }
+
+  // Atualizar timestamp
+  console.log("\n[3/3] Atualizando timestamp...");
+  const now = new Date().toISOString();
+  db.run("UPDATE project SET last_discover_at = ?, updated_at = ? WHERE id = 'default'", [now, now]);
+
+  // Resumo
+  console.log("\n" + "═".repeat(50));
+  console.log("DISCOVER INCREMENTAL CONCLUIDO");
+  console.log("═".repeat(50));
+  console.log(`  Arquivos analisados: ${existingFiles.length}`);
+  console.log(`  Utilities atualizadas: ${utilitiesUpdated}`);
+  console.log(`  Mudancas no stack: ${stackChanges.length}`);
+  console.log(`  Timestamp atualizado: ${now}`);
+  console.log("═".repeat(50) + "\n");
+}
+
 function generateStandardsMarkdown(): void {
   const db = getDb();
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
@@ -649,9 +767,7 @@ export function discoverPatternsShow(name: string, json: boolean = false): void
   const pattern = db.query("SELECT * FROM implementation_patterns WHERE name = ?").get(name) as any;
 
   if (!pattern) {
-    console.error(`\nPattern '${name}' nao encontrado.`);
-    console.error("Use: discover patterns para listar todos\n");
-    process.exit(1);
+    throw new CodexaError(`Pattern '${name}' nao encontrado.\nUse: discover patterns para listar todos`);
   }
 
   const structure = JSON.parse(pattern.structure || "{}");
@@ -751,9 +867,7 @@ export function discoverPatternAdd(options: {
   // Verificar se pattern ja existe
   const existing = db.query("SELECT id FROM implementation_patterns WHERE name = ?").get(options.name);
   if (existing) {
-    console.error(`\nPattern '${options.name}' ja existe.`);
-    console.error("Use: discover pattern-edit para modificar\n");
-    process.exit(1);
+    throw new CodexaError(`Pattern '${options.name}' ja existe.\nUse: discover pattern-edit para modificar`);
   }
 
   const now = new Date().toISOString();
@@ -800,9 +914,7 @@ export function discoverPatternEdit(name: string, options: {
 
   const existing = db.query("SELECT * FROM implementation_patterns WHERE name = ?").get(name) as any;
   if (!existing) {
-    console.error(`\nPattern '${name}' nao encontrado.`);
-    console.error("Use: discover patterns para listar todos\n");
-    process.exit(1);
+    throw new CodexaError(`Pattern '${name}' nao encontrado.\nUse: discover patterns para listar todos`);
   }
 
   const updates: string[] = [];
@@ -842,8 +954,7 @@ export function discoverPatternEdit(name: string, options: {
   }
 
   if (updates.length === 0) {
-    console.error("\nNenhuma opcao de atualizacao fornecida.\n");
-    process.exit(1);
+    throw new CodexaError("Nenhuma opcao de atualizacao fornecida.");
   }
 
   updates.push("updated_at = ?");
@@ -868,8 +979,7 @@ export function discoverPatternRemove(name: string): void {
 
   const existing = db.query("SELECT id FROM implementation_patterns WHERE name = ?").get(name);
   if (!existing) {
-    console.error(`\nPattern '${name}' nao encontrado.\n`);
-    process.exit(1);
+    throw new CodexaError(`Pattern '${name}' nao encontrado.`);
   }
 
   db.run("DELETE FROM implementation_patterns WHERE name = ?", [name]);
@@ -888,9 +998,7 @@ export function discoverRefreshPatterns(): void {
   // Verificar se projeto foi descoberto
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
   if (!project) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start primeiro");
   }
 
   console.log("\n⚠ Refresh de patterns requer analise manual do codigo.");

package/commands/knowledge.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { jaccardSimilarity, compactKnowledge } from "./knowledge";
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+
+describe("jaccardSimilarity", () => {
+  it("returns 1 for identical strings", () => {
+    expect(jaccardSimilarity("hello world test", "hello world test")).toBe(1);
+  });
+
+  it("returns 0 for completely different strings", () => {
+    expect(jaccardSimilarity("apple banana cherry", "delta echo foxtrot")).toBe(0);
+  });
+
+  it("returns high similarity for near-duplicates", () => {
+    const sim = jaccardSimilarity(
+      "Implemented user authentication with JWT tokens",
+      "Implemented user authentication using JWT tokens"
+    );
+    expect(sim).toBeGreaterThan(0.7);
+  });
+
+  it("returns 1 for two empty strings", () => {
+    expect(jaccardSimilarity("", "")).toBe(1);
+  });
+
+  it("returns 0 when one string is empty", () => {
+    expect(jaccardSimilarity("hello world test", "")).toBe(0);
+  });
+
+  it("is case insensitive", () => {
+    expect(jaccardSimilarity("Hello World Test", "hello world test")).toBe(1);
+  });
+
+  it("ignores short words (<=2 chars)", () => {
+    // "a" and "is" are filtered out, only "cat" and "dog" matter
+    const sim = jaccardSimilarity("a cat is here", "a dog is here");
+    // "cat" vs "dog" + "here" in common
+    expect(sim).toBeGreaterThan(0);
+    expect(sim).toBeLessThan(1);
+  });
+
+  it("strips punctuation", () => {
+    const sim = jaccardSimilarity("hello, world! test.", "hello world test");
+    expect(sim).toBe(1);
+  });
+});
+
+describe("compactKnowledge", () => {
+  beforeEach(() => {
+    initSchema();
+    const db = getDb();
+    db.run("DELETE FROM knowledge_graph");
+    db.run("DELETE FROM knowledge");
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM context");
+    db.run("DELETE FROM specs");
+  });
+
+  function createSpec(id: string, phase: string) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.run(
+      "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+      [id, `Feature ${id}`, phase, now, now]
+    );
+  }
+
+  function addKnowledgeEntry(specId: string, content: string, category: string, severity: string, createdAt?: string) {
+    const db = getDb();
+    const now = createdAt || new Date().toISOString();
+    db.run(
+      `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
+       VALUES (?, 0, ?, ?, ?, 'all', ?)`,
+      [specId, category, content, severity, now]
+    );
+  }
+
+  it("merges similar entries in same category and spec", () => {
+    createSpec("spec-a", "implementing");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for login flow", "discovery", "info");
+
+    // Dry run first
+    compactKnowledge({ dryRun: true, json: true });
+
+    // Actual compact
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(1);
+  });
+
+  it("keeps higher severity entry when merging", () => {
+    createSpec("spec-a", "implementing");
+    addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production", "blocker", "critical");
+    addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production system", "blocker", "info");
+
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const remaining = db.query("SELECT * FROM knowledge WHERE severity != 'archived'").all() as any[];
+    expect(remaining.length).toBe(1);
+    expect(remaining[0].severity).toBe("critical");
+  });
+
+  it("archives old info entries (>7 days)", () => {
+    createSpec("spec-a", "implementing");
+    const oldDate = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString();
+    addKnowledgeEntry("spec-a", "Some old discovery that is not referenced anywhere in the graph", "discovery", "info", oldDate);
+    addKnowledgeEntry("spec-a", "A recent discovery that should not be archived by this compaction", "discovery", "info");
+
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(1);
+  });
+
+  it("archives entries from completed specs", () => {
+    createSpec("spec-done", "completed");
+    addKnowledgeEntry("spec-done", "Something learned during completed feature implementation", "discovery", "info");
+    addKnowledgeEntry("spec-done", "A critical blocker that was found during the implementation phase", "blocker", "critical");
+
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(2);
+  });
+
+  it("dry-run mode does not modify DB", () => {
+    createSpec("spec-done", "completed");
+    addKnowledgeEntry("spec-done", "Something that would be archived in a real compaction run", "discovery", "info");
+
+    compactKnowledge({ dryRun: true, json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(0);
+  });
+
+  it("respects --spec filter", () => {
+    createSpec("spec-a", "implementing");
+    createSpec("spec-b", "implementing");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system", "discovery", "info");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system flow", "discovery", "info");
+    addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login", "discovery", "info");
+    addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
+
+    compactKnowledge({ specId: "spec-a", json: true });
+
+    const db = getDb();
+    const archivedA = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-a'").get() as any;
+    const archivedB = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-b'").get() as any;
+    expect(archivedA.c).toBe(1);
+    expect(archivedB.c).toBe(0);
+  });
+});