@codexa/cli 9.0.7 → 9.0.9

package/context/references.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { join } from "path";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { findReferenceFiles } from "./references";
+
+// ── Test fixtures ────────────────────────────────────────────
+
+const TMP_DIR = join(import.meta.dir, "__test_refs__");
+
+function ensureDir(dir: string) {
+  mkdirSync(dir, { recursive: true });
+}
+
+function writeTmpFile(relativePath: string, content: string): string {
+  const full = join(TMP_DIR, relativePath);
+  ensureDir(join(full, ".."));
+  writeFileSync(full, content);
+  return relativePath;
+}
+
+beforeAll(() => {
+  ensureDir(TMP_DIR);
+
+  // src/routes/ — 3 route files of different sizes
+  writeTmpFile("src/routes/users.ts", "export function getUsers() { return []; }\nexport function createUser() { return {}; }\n// more code here to make it larger\n".repeat(5));
+  writeTmpFile("src/routes/products.ts", "export function getProducts() { return []; }\n");
+  writeTmpFile("src/routes/orders.ts", "export function getOrders() { return []; }\nexport function createOrder() { return {}; }\n");
+
+  // src/services/ — 2 service files
+  writeTmpFile("src/services/auth.service.ts", "export class AuthService { login() {} logout() {} verify() {} }\n".repeat(3));
+  writeTmpFile("src/services/user.service.ts", "export class UserService { getById() {} }\n");
+
+  // src/components/ — React components
+  writeTmpFile("src/components/Button.tsx", "export function Button() { return <button/>; }\n");
+  writeTmpFile("src/components/Card.tsx", "export function Card() { return <div/>; }\nexport function CardHeader() { return <div/>; }\n".repeat(3));
+
+  // src/modules/users/ and src/modules/payments/ — parallel structure
+  writeTmpFile("src/modules/users/route.ts", "export function usersRoute() { return {}; }\n".repeat(4));
+  writeTmpFile("src/modules/users/service.ts", "export function usersService() {}\n");
+  writeTmpFile("src/modules/payments/service.ts", "export function paymentsService() {}\n");
+
+  // tests/ — test files
+  writeTmpFile("tests/routes/users.test.ts", "describe('users', () => { it('works', () => {}); });\n".repeat(2));
+
+  // node_modules/ — should be ignored
+  writeTmpFile("node_modules/pkg/index.ts", "export const x = 1;\n");
+
+  // Non-code file
+  writeTmpFile("docs/readme.md", "# Readme\n");
+});
+
+afterAll(() => {
+  rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("findReferenceFiles", () => {
+  it("finds siblings in the same directory", () => {
+    // Target: new file in src/routes/ — should find existing routes
+    const refs = findReferenceFiles(["src/routes/payments.ts"], TMP_DIR);
+
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    expect(refs[0].reason).toBe("mesmo diretorio");
+    // Should pick the largest sibling (users.ts has the most content)
+    expect(refs[0].path).toBe("src/routes/users.ts");
+  });
+
+  it("prioritizes largest file as reference", () => {
+    const refs = findReferenceFiles(["src/components/Modal.tsx"], TMP_DIR);
+
+    expect(refs.length).toBe(1);
+    // Card.tsx is larger than Button.tsx
+    expect(refs[0].path).toBe("src/components/Card.tsx");
+  });
+
+  it("finds namesakes when no siblings exist", () => {
+    // Target: src/modules/payments/route.ts — no siblings, but src/modules/users/route.ts exists
+    const refs = findReferenceFiles(["src/modules/payments/route.ts"], TMP_DIR);
+
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    const paths = refs.map(r => r.path);
+    // Should find the namesake route.ts or a sibling service.ts
+    expect(
+      paths.some(p => p.includes("route.ts") || p.includes("service.ts"))
+    ).toBe(true);
+  });
+
+  it("returns empty for non-code files", () => {
+    const refs = findReferenceFiles(["docs/notes.md"], TMP_DIR);
+    expect(refs).toEqual([]);
+  });
+
+  it("returns empty for empty task files", () => {
+    expect(findReferenceFiles([], TMP_DIR)).toEqual([]);
+  });
+
+  it("returns empty for null/undefined", () => {
+    expect(findReferenceFiles(null as any, TMP_DIR)).toEqual([]);
+    expect(findReferenceFiles(undefined as any, TMP_DIR)).toEqual([]);
+  });
+
+  it("ignores node_modules", () => {
+    const refs = findReferenceFiles(["node_modules/pkg/new.ts"], TMP_DIR);
+    // Even if node_modules has .ts files, targets in ignored dirs get no refs
+    // (the target itself is filtered by extension check, not by ignored dir)
+    // But results should never point INTO node_modules
+    for (const ref of refs) {
+      expect(ref.path).not.toContain("node_modules");
+    }
+  });
+
+  it("limits to 3 references max", () => {
+    const refs = findReferenceFiles([
+      "src/routes/payments.ts",
+      "src/services/payment.service.ts",
+      "src/components/Modal.tsx",
+      "tests/routes/products.test.ts",
+    ], TMP_DIR);
+
+    expect(refs.length).toBeLessThanOrEqual(3);
+  });
+
+  it("deduplicates references", () => {
+    const refs = findReferenceFiles([
+      "src/routes/payments.ts",
+      "src/routes/invoices.ts",
+    ], TMP_DIR);
+
+    const paths = refs.map(r => r.path);
+    const unique = new Set(paths);
+    expect(paths.length).toBe(unique.size);
+  });
+
+  it("handles Windows-style backslash paths", () => {
+    const refs = findReferenceFiles(["src\\routes\\payments.ts"], TMP_DIR);
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    // All returned paths should use forward slashes
+    for (const ref of refs) {
+      expect(ref.path).not.toContain("\\");
+    }
+  });
+
+  it("finds reference for test files", () => {
+    const refs = findReferenceFiles(["tests/routes/products.test.ts"], TMP_DIR);
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    expect(refs[0].path).toContain("users.test.ts");
+  });
+
+  it("uses parent directory as fallback", () => {
+    // Target in a new subdirectory with no siblings or namesakes
+    writeTmpFile("src/features/billing/handler.ts", "export function handle() {}\n");
+    const refs = findReferenceFiles(["src/features/billing/processor.ts"], TMP_DIR);
+    // Should find handler.ts as sibling
+    if (refs.length > 0) {
+      expect(refs[0].path).toContain("billing");
+    }
+  });
+});

package/context/references.ts

@@ -0,0 +1,159 @@
+import { join, dirname, basename, extname, resolve, relative } from "path";
+import { globSync } from "fs";
+
+// ═══════════════════════════════════════════════════════════════
+// REFERENCE FILES — Pattern by Example (v9.5)
+//
+// Finds existing files similar to task targets so subagents can
+// read them and replicate the coding style exactly.
+// ═══════════════════════════════════════════════════════════════
+
+export interface ReferenceFile {
+  path: string;
+  reason: string;
+}
+
+const IGNORED_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".next", ".codexa",
+  ".nuxt", ".output", "coverage", "__pycache__", ".venv", "vendor",
+  "target", "bin", "obj",
+]);
+
+const CODE_EXTENSIONS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte",
+  ".go", ".rs", ".py", ".cs", ".kt", ".java",
+  ".dart", ".php", ".rb", ".swift",
+]);
+
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+function isIgnored(filePath: string): boolean {
+  const parts = normalizePath(filePath).split("/");
+  return parts.some(part => IGNORED_DIRS.has(part));
+}
+
+function getFileSize(filePath: string): number {
+  try {
+    return Bun.file(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+
+function fileExists(filePath: string): boolean {
+  try {
+    return Bun.file(filePath).size > 0;
+  } catch {
+    return false;
+  }
+}
+
+function globFiles(pattern: string, cwd: string): string[] {
+  try {
+    const glob = new Bun.Glob(pattern);
+    const results: string[] = [];
+    for (const match of glob.scanSync({ cwd, dot: false })) {
+      const full = join(cwd, match);
+      if (!isIgnored(full)) {
+        results.push(normalizePath(full));
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+function pickLargest(files: string[]): string | null {
+  if (files.length === 0) return null;
+
+  let best = files[0];
+  let bestSize = getFileSize(files[0]);
+
+  for (let i = 1; i < files.length; i++) {
+    const size = getFileSize(files[i]);
+    if (size > bestSize) {
+      best = files[i];
+      bestSize = size;
+    }
+  }
+
+  return bestSize > 0 ? best : null;
+}
+
+/**
+ * Find reference files for a set of task target files.
+ *
+ * Strategy per target file:
+ * 1. Siblings — other files in the same directory with same extension
+ * 2. Namesakes — files with same basename in other directories
+ * 3. Parent — files with same extension in parent directory tree
+ *
+ * Returns max 3 deduplicated reference file paths.
+ */
+export function findReferenceFiles(
+  taskFiles: string[],
+  projectRoot: string,
+): ReferenceFile[] {
+  if (!taskFiles || taskFiles.length === 0) return [];
+
+  const seen = new Set<string>();
+  const results: ReferenceFile[] = [];
+  const normalizedRoot = normalizePath(resolve(projectRoot));
+
+  for (const rawTarget of taskFiles) {
+    if (results.length >= 3) break;
+
+    const target = normalizePath(resolve(projectRoot, rawTarget));
+    const ext = extname(target);
+    const base = basename(target);
+    const dir = dirname(target);
+
+    if (!ext || !CODE_EXTENSIONS.has(ext)) continue;
+
+    // Strategy 1: Siblings (same directory, same extension)
+    const siblings = globFiles(`*${ext}`, dir)
+      .filter(f => f !== target && !seen.has(f) && fileExists(f));
+
+    const bestSibling = pickLargest(siblings);
+    if (bestSibling) {
+      const rel = normalizePath(relative(normalizedRoot, bestSibling));
+      seen.add(bestSibling);
+      results.push({ path: rel, reason: "mesmo diretorio" });
+      continue;
+    }
+
+    // Strategy 2: Namesakes (same filename in other directories)
+    const namesakes = globFiles(`**/${base}`, normalizedRoot)
+      .filter(f => f !== target && !seen.has(f) && fileExists(f));
+
+    if (namesakes.length > 0) {
+      // Pick the one closest by path depth similarity
+      const bestNamesake = pickLargest(namesakes);
+      if (bestNamesake) {
+        const rel = normalizePath(relative(normalizedRoot, bestNamesake));
+        seen.add(bestNamesake);
+        results.push({ path: rel, reason: "mesmo tipo de arquivo" });
+        continue;
+      }
+    }
+
+    // Strategy 3: Parent directory search (same extension, one level up)
+    const parentDir = dirname(dir);
+    if (parentDir !== dir) {
+      const parentFiles = globFiles(`**/*${ext}`, parentDir)
+        .filter(f => f !== target && !seen.has(f) && fileExists(f));
+
+      const bestParent = pickLargest(parentFiles);
+      if (bestParent) {
+        const rel = normalizePath(relative(normalizedRoot, bestParent));
+        seen.add(bestParent);
+        results.push({ path: rel, reason: "arquivo similar proximo" });
+      }
+    }
+  }
+
+  return results;
+}

package/context/sections.ts

@@ -1,5 +1,7 @@
 import { getUtilitiesForContext, getAgentHints } from "../db/schema";
 import type { ContextSection, ContextData } from "./assembly";
+import { getAgentDomain, domainToScope } from "./domains";
+import { findReferenceFiles } from "./references";
 
 // ── Section Builders ──────────────────────────────────────────
 
@@ -162,7 +164,7 @@ export function buildUtilitiesSection(data: ContextData): ContextSection | null
             return parts.slice(0, -1).join("/");
         }).filter(Boolean))];
 
-        const agentScope = data.task.agent?.split("-")[0] || undefined;
+        const agentScope = domainToScope(getAgentDomain(data.task.agent)) || undefined;
         let relevantUtilities = getUtilitiesForContext(taskDirs, undefined, 15);
 
         if (relevantUtilities.length < 5 && agentScope) {
@@ -244,3 +246,18 @@ ${hints.map(h => `- ${h}`).join("\n")}
 `;
     return { name: "HINTS", content, priority: 10 };
 }
+
+export function buildReferencesSection(data: ContextData): ContextSection | null {
+    if (data.taskFiles.length === 0) return null;
+
+    const projectRoot = process.cwd();
+    const refs = findReferenceFiles(data.taskFiles, projectRoot);
+    if (refs.length === 0) return null;
+
+    const content = `
+### REFERENCIA DE ESTILO (${refs.length})
+**ANTES de criar/modificar arquivos, leia estas referencias e replique o mesmo estilo** (nomenclatura, estrutura, imports, error handling):
+${refs.map(r => `- \`${r.path}\` (${r.reason})`).join("\n")}
+`;
+    return { name: "REFERENCIAS", content, priority: 2 };
+}

package/db/schema.ts

@@ -237,7 +237,6 @@ export function initSchema(): void {
       relation TEXT NOT NULL,     -- uses, implements, depends_on, modifies, contradicts, extracted_from
 
       -- Metadados
-      strength REAL DEFAULT 1.0,  -- 0-1, peso da relacao
       metadata TEXT,              -- JSON com informacoes adicionais
 
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
@@ -459,6 +458,28 @@ const MIGRATIONS: Migration[] = [
       }
     },
   },
+  {
+    version: "9.5.0",
+    description: "Adicionar superseded_by na tabela decisions",
+    up: (db) => {
+      db.exec(`ALTER TABLE decisions ADD COLUMN superseded_by TEXT`);
+    },
+  },
+  {
+    version: "9.6.0",
+    description: "Adicionar semantic_query e expect na tabela standards para validacao semantica stack-agnostica",
+    up: (db) => {
+      db.exec(`ALTER TABLE standards ADD COLUMN semantic_query TEXT`);
+      db.exec(`ALTER TABLE standards ADD COLUMN expect TEXT DEFAULT 'no_match'`);
+    },
+  },
+  {
+    version: "9.7.0",
+    description: "Adicionar typecheck_command na tabela project para typecheck agnostico de stack",
+    up: (db) => {
+      db.exec(`ALTER TABLE project ADD COLUMN typecheck_command TEXT`);
+    },
+  },
 ];
 
 export function runMigrations(): void {
@@ -521,6 +542,22 @@ export function claimTask(taskId: number): boolean {
   return result.changes > 0;
 }
 
+const STUCK_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutos
+
+export function detectStuckTasks(specId: string): any[] {
+  const db = getDb();
+  const running = db.query(
+    "SELECT * FROM tasks WHERE spec_id = ? AND status = 'running'"
+  ).all(specId) as any[];
+
+  const now = Date.now();
+  return running.filter((task: any) => {
+    if (!task.started_at) return true;
+    const elapsed = now - new Date(task.started_at).getTime();
+    return elapsed > STUCK_THRESHOLD_MS;
+  });
+}
+
 export function getPatternsByScope(scope: string): any[] {
   const db = getDb();
   return db.query(
@@ -582,7 +619,6 @@ export interface GraphRelation {
   targetType: string;
   targetId: string;
   relation: string;
-  strength?: number;
   metadata?: Record<string, any>;
 }
 
@@ -591,8 +627,8 @@ export function addGraphRelation(specId: string | null, relation: GraphRelation)
   const now = new Date().toISOString();
 
   db.run(
-    `INSERT INTO knowledge_graph (spec_id, source_type, source_id, target_type, target_id, relation, strength, metadata, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    `INSERT INTO knowledge_graph (spec_id, source_type, source_id, target_type, target_id, relation, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
     [
       specId,
       relation.sourceType,
@@ -600,7 +636,6 @@ export function addGraphRelation(specId: string | null, relation: GraphRelation)
       relation.targetType,
       relation.targetId,
       relation.relation,
-      relation.strength || 1.0,
       relation.metadata ? JSON.stringify(relation.metadata) : null,
       now,
     ]

package/db/test-helpers.ts

@@ -0,0 +1,33 @@
+import { getDb } from "./connection";
+
+/**
+ * Limpa todas as tabelas do DB respeitando ordem de FK constraints.
+ * Usa PRAGMA foreign_keys = OFF como safety net.
+ *
+ * Uso: beforeEach(() => { initSchema(); cleanDb(); });
+ */
+export function cleanDb() {
+  const db = getDb();
+  db.run("PRAGMA foreign_keys = OFF");
+  try {
+    // Folhas (sem dependentes) primeiro
+    db.run("DELETE FROM knowledge_acknowledgments");
+    db.run("DELETE FROM agent_performance");
+    db.run("DELETE FROM reasoning_log");
+    db.run("DELETE FROM knowledge_graph");
+    db.run("DELETE FROM gate_bypasses");
+    db.run("DELETE FROM snapshots");
+    db.run("DELETE FROM review");
+    db.run("DELETE FROM project_utilities");
+    db.run("DELETE FROM artifacts");
+    db.run("DELETE FROM decisions");
+    // Dependentes de knowledge (antes de knowledge)
+    db.run("DELETE FROM knowledge");
+    // Dependentes de tasks/specs
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM context");
+    db.run("DELETE FROM specs");
+  } finally {
+    db.run("PRAGMA foreign_keys = ON");
+  }
+}