@codexa/cli 9.0.7 → 9.0.9

package/context/domains.test.ts

@@ -0,0 +1,300 @@
+import { describe, it, expect } from "bun:test";
+import {
+  getAgentDomain,
+  domainToScope,
+  adjustSectionPriorities,
+  AGENT_DOMAIN,
+  DOMAIN_PROFILES,
+} from "./domains";
+import type { ContextSection } from "./assembly";
+
+function makeSections(): ContextSection[] {
+  return [
+    { name: "STANDARDS", content: "...", priority: 1 },
+    { name: "REFERENCIAS", content: "...", priority: 2 },
+    { name: "ALERTAS", content: "...", priority: 2 },
+    { name: "ARQUITETURA", content: "...", priority: 3 },
+    { name: "DECISOES", content: "...", priority: 4 },
+    { name: "CONTEXTO DE TASKS ANTERIORES", content: "...", priority: 5 },
+    { name: "GRAPH", content: "...", priority: 6 },
+    { name: "PRODUTO", content: "...", priority: 7 },
+    { name: "DISCOVERIES", content: "...", priority: 8 },
+    { name: "UTILITIES", content: "...", priority: 8 },
+    { name: "PATTERNS", content: "...", priority: 9 },
+    { name: "HINTS", content: "...", priority: 10 },
+    { name: "STACK", content: "...", priority: 11 },
+  ];
+}
+
+// ── getAgentDomain ───────────────────────────────────────────
+
+describe("getAgentDomain", () => {
+  it("maps backend agents correctly", () => {
+    expect(getAgentDomain("backend-javascript")).toBe("backend");
+    expect(getAgentDomain("expert-csharp-developer")).toBe("backend");
+    expect(getAgentDomain("golang-pro")).toBe("backend");
+  });
+
+  it("maps frontend agents correctly", () => {
+    expect(getAgentDomain("expert-nextjs-developer")).toBe("frontend");
+    expect(getAgentDomain("frontend-flutter")).toBe("frontend");
+  });
+
+  it("maps database agent correctly", () => {
+    expect(getAgentDomain("expert-postgres-developer")).toBe("database");
+  });
+
+  it("maps testing agent correctly", () => {
+    expect(getAgentDomain("testing-unit")).toBe("testing");
+  });
+
+  it("maps review agent correctly", () => {
+    expect(getAgentDomain("expert-code-reviewer")).toBe("review");
+  });
+
+  it("maps security agent correctly", () => {
+    expect(getAgentDomain("security-specialist")).toBe("security");
+  });
+
+  it("maps explore agent correctly", () => {
+    expect(getAgentDomain("deep-explore")).toBe("explore");
+  });
+
+  it("maps architecture agent correctly", () => {
+    expect(getAgentDomain("architect")).toBe("architecture");
+  });
+
+  it("returns null for unknown agents", () => {
+    expect(getAgentDomain("unknown-agent")).toBeNull();
+    expect(getAgentDomain("general-purpose")).toBeNull();
+  });
+
+  it("returns null for null/undefined/empty input", () => {
+    expect(getAgentDomain(null)).toBeNull();
+    expect(getAgentDomain(undefined)).toBeNull();
+    expect(getAgentDomain("")).toBeNull();
+  });
+});
+
+// ── domainToScope ────────────────────────────────────────────
+
+describe("domainToScope", () => {
+  it("maps code domains to their scope names", () => {
+    expect(domainToScope("backend")).toBe("backend");
+    expect(domainToScope("frontend")).toBe("frontend");
+    expect(domainToScope("database")).toBe("database");
+    expect(domainToScope("testing")).toBe("testing");
+  });
+
+  it("maps cross-cutting domains to 'all'", () => {
+    expect(domainToScope("review")).toBe("all");
+    expect(domainToScope("security")).toBe("all");
+    expect(domainToScope("explore")).toBe("all");
+    expect(domainToScope("architecture")).toBe("all");
+  });
+
+  it("returns 'all' for null domain", () => {
+    expect(domainToScope(null)).toBe("all");
+  });
+
+  // Regression: verifies the split("-")[0] bug is fixed
+  it("expert-postgres-developer resolves to 'database' scope (not 'expert')", () => {
+    const domain = getAgentDomain("expert-postgres-developer");
+    expect(domainToScope(domain)).toBe("database");
+  });
+
+  it("expert-nextjs-developer resolves to 'frontend' scope (not 'expert')", () => {
+    const domain = getAgentDomain("expert-nextjs-developer");
+    expect(domainToScope(domain)).toBe("frontend");
+  });
+
+  it("golang-pro resolves to 'backend' scope (not 'golang')", () => {
+    const domain = getAgentDomain("golang-pro");
+    expect(domainToScope(domain)).toBe("backend");
+  });
+});
+
+// ── adjustSectionPriorities ──────────────────────────────────
+
+describe("adjustSectionPriorities", () => {
+  it("null domain passes all sections through unchanged", () => {
+    const sections = makeSections();
+    const result = adjustSectionPriorities(sections, null);
+    expect(result).toHaveLength(13);
+    expect(result).toEqual(sections);
+  });
+
+  it("explore domain excludes relevance-0 sections", () => {
+    const result = adjustSectionPriorities(makeSections(), "explore");
+    const names = result.map(s => s.name);
+
+    // explore profile: 8 sections have relevance 0
+    expect(names).not.toContain("STANDARDS");
+    expect(names).not.toContain("REFERENCIAS");
+    expect(names).not.toContain("CONTEXTO DE TASKS ANTERIORES");
+    expect(names).not.toContain("GRAPH");
+    expect(names).not.toContain("PRODUTO");
+    expect(names).not.toContain("UTILITIES");
+    expect(names).not.toContain("PATTERNS");
+    expect(names).not.toContain("HINTS");
+
+    // Should contain the 5 non-zero sections
+    expect(names).toContain("ALERTAS");
+    expect(names).toContain("ARQUITETURA");
+    expect(names).toContain("DECISOES");
+    expect(names).toContain("DISCOVERIES");
+    expect(names).toContain("STACK");
+    expect(result).toHaveLength(5);
+  });
+
+  it("essential sections (relevance=3) get priority boosted by -2", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: DECISOES=3 (base 4 + offset -2 = 2)
+    const decisoes = result.find(s => s.name === "DECISOES");
+    expect(decisoes?.priority).toBe(2);
+
+    // backend: UTILITIES=3 (base 8 + offset -2 = 6)
+    const utilities = result.find(s => s.name === "UTILITIES");
+    expect(utilities?.priority).toBe(6);
+  });
+
+  it("priority floor is 1 (never goes below)", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: STANDARDS=3 (base 1 + offset -2 = -1 → floor 1)
+    const standards = result.find(s => s.name === "STANDARDS");
+    expect(standards?.priority).toBe(1);
+
+    // backend: ALERTAS=3 (base 2 + offset -2 = 0 → floor 1)
+    const alertas = result.find(s => s.name === "ALERTAS");
+    expect(alertas?.priority).toBe(1);
+  });
+
+  it("nice-to-have sections (relevance=1) get deprioritized by +4", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: PRODUTO=1 (base 7 + offset +4 = 11)
+    const produto = result.find(s => s.name === "PRODUTO");
+    expect(produto?.priority).toBe(11);
+  });
+
+  it("useful sections (relevance=2) keep base priority", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: ARQUITETURA=2 (base 3 + offset 0 = 3)
+    const arq = result.find(s => s.name === "ARQUITETURA");
+    expect(arq?.priority).toBe(3);
+  });
+
+  it("testing domain excludes only PRODUTO (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "testing");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+    expect(result).toHaveLength(12);
+  });
+
+  it("testing domain boosts CONTEXTO DE TASKS ANTERIORES (relevance=3)", () => {
+    const result = adjustSectionPriorities(makeSections(), "testing");
+    const ctx = result.find(s => s.name === "CONTEXTO DE TASKS ANTERIORES");
+    // base 5 + offset -2 = 3
+    expect(ctx?.priority).toBe(3);
+  });
+
+  it("database domain excludes PRODUTO (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "database");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+  });
+
+  it("frontend domain keeps PRODUTO with boosted priority", () => {
+    const result = adjustSectionPriorities(makeSections(), "frontend");
+    const produto = result.find(s => s.name === "PRODUTO");
+    // frontend: PRODUTO=3 (base 7 + offset -2 = 5)
+    expect(produto?.priority).toBe(5);
+  });
+
+  it("backend domain boosts REFERENCIAS (relevance=3)", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+    const refs = result.find(s => s.name === "REFERENCIAS");
+    // backend: REFERENCIAS=3 (base 2 + offset -2 = 0 → floor 1)
+    expect(refs?.priority).toBe(1);
+  });
+
+  it("explore domain excludes REFERENCIAS (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "explore");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("REFERENCIAS");
+  });
+
+  it("architecture domain excludes REFERENCIAS (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "architecture");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("REFERENCIAS");
+  });
+
+  it("security domain excludes PRODUTO and REFERENCIAS (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "security");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+    expect(names).not.toContain("REFERENCIAS");
+    expect(result).toHaveLength(11);
+  });
+
+  it("handles unknown section names gracefully (forward compatibility)", () => {
+    const sections: ContextSection[] = [
+      { name: "FUTURE_SECTION", content: "...", priority: 5 },
+      { name: "STANDARDS", content: "...", priority: 1 },
+    ];
+    const result = adjustSectionPriorities(sections, "backend");
+    expect(result).toHaveLength(2);
+    const future = result.find(s => s.name === "FUTURE_SECTION");
+    expect(future?.priority).toBe(5); // unchanged
+  });
+});
+
+// ── DOMAIN_PROFILES completeness ─────────────────────────────
+
+describe("DOMAIN_PROFILES completeness", () => {
+  const allSectionNames = [
+    "STANDARDS", "REFERENCIAS", "ALERTAS", "ARQUITETURA", "DECISOES",
+    "CONTEXTO DE TASKS ANTERIORES", "GRAPH", "PRODUTO",
+    "DISCOVERIES", "UTILITIES", "PATTERNS", "HINTS", "STACK",
+  ];
+
+  it("every domain profile covers all 13 sections", () => {
+    for (const [domain, profile] of Object.entries(DOMAIN_PROFILES)) {
+      for (const section of allSectionNames) {
+        expect(profile[section as keyof typeof profile]).toBeDefined();
+      }
+    }
+  });
+
+  it("all relevance values are 0, 1, 2, or 3", () => {
+    for (const [domain, profile] of Object.entries(DOMAIN_PROFILES)) {
+      for (const [section, relevance] of Object.entries(profile)) {
+        expect([0, 1, 2, 3]).toContain(relevance);
+      }
+    }
+  });
+});
+
+// ── AGENT_DOMAIN completeness ────────────────────────────────
+
+describe("AGENT_DOMAIN completeness", () => {
+  it("maps all 11 known agents", () => {
+    const knownAgents = [
+      "backend-javascript", "expert-csharp-developer", "golang-pro",
+      "expert-nextjs-developer", "frontend-flutter",
+      "expert-postgres-developer",
+      "testing-unit",
+      "expert-code-reviewer",
+      "security-specialist",
+      "deep-explore",
+      "architect",
+    ];
+    for (const agent of knownAgents) {
+      expect(AGENT_DOMAIN[agent]).toBeDefined();
+    }
+  });
+});

package/context/domains.ts

@@ -0,0 +1,157 @@
+// ═══════════════════════════════════════════════════════════════
+// DOMAIN-BASED CONTEXT PRIORITY (v9.4)
+// Replaces binary AGENT_SECTIONS with relevance-based filtering.
+// ═══════════════════════════════════════════════════════════════
+
+import type { ContextSection } from "./assembly";
+
+export type AgentDomain =
+  | "backend"
+  | "frontend"
+  | "database"
+  | "testing"
+  | "review"
+  | "security"
+  | "explore"
+  | "architecture";
+
+export type Relevance = 0 | 1 | 2 | 3;
+
+export type SectionName =
+  | "STANDARDS"
+  | "REFERENCIAS"
+  | "ALERTAS"
+  | "ARQUITETURA"
+  | "DECISOES"
+  | "CONTEXTO DE TASKS ANTERIORES"
+  | "GRAPH"
+  | "PRODUTO"
+  | "DISCOVERIES"
+  | "UTILITIES"
+  | "PATTERNS"
+  | "HINTS"
+  | "STACK";
+
+export type DomainProfile = Record<SectionName, Relevance>;
+
+// ── Agent → Domain mapping ───────────────────────────────────
+
+export const AGENT_DOMAIN: Record<string, AgentDomain> = {
+  "backend-javascript":       "backend",
+  "expert-csharp-developer":  "backend",
+  "golang-pro":               "backend",
+  "expert-nextjs-developer":  "frontend",
+  "frontend-flutter":         "frontend",
+  "expert-postgres-developer": "database",
+  "testing-unit":             "testing",
+  "expert-code-reviewer":     "review",
+  "security-specialist":      "security",
+  "deep-explore":             "explore",
+  "architect":                "architecture",
+};
+
+// ── Domain → Section relevance profiles ──────────────────────
+//
+// 3 = essential  (priority offset -2, survives truncation)
+// 2 = useful     (priority offset  0, base priority kept)
+// 1 = nice-to-have (priority offset +4, dropped first on truncation)
+// 0 = noise      (excluded entirely)
+
+export const DOMAIN_PROFILES: Record<AgentDomain, DomainProfile> = {
+  backend: {
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 1,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 2, "HINTS": 2, "STACK": 2,
+  },
+  frontend: {
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 3,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 3, "HINTS": 2, "STACK": 2,
+  },
+  database: {
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 0,
+    "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 2, "HINTS": 2, "STACK": 3,
+  },
+  testing: {
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 1, "DECISOES": 2,
+    "CONTEXTO DE TASKS ANTERIORES": 3, "GRAPH": 1, "PRODUTO": 0,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 3, "HINTS": 2, "STACK": 1,
+  },
+  review: {
+    "STANDARDS": 3, "REFERENCIAS": 1, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 1,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 2, "HINTS": 3, "STACK": 2,
+  },
+  security: {
+    "STANDARDS": 3, "REFERENCIAS": 0, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 2,
+    "CONTEXTO DE TASKS ANTERIORES": 1, "GRAPH": 1, "PRODUTO": 0,
+    "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 1, "HINTS": 2, "STACK": 3,
+  },
+  explore: {
+    "STANDARDS": 0, "REFERENCIAS": 0, "ALERTAS": 1, "ARQUITETURA": 3, "DECISOES": 1,
+    "CONTEXTO DE TASKS ANTERIORES": 0, "GRAPH": 0, "PRODUTO": 0,
+    "DISCOVERIES": 1, "UTILITIES": 0, "PATTERNS": 0, "HINTS": 0, "STACK": 3,
+  },
+  architecture: {
+    "STANDARDS": 2, "REFERENCIAS": 0, "ALERTAS": 2, "ARQUITETURA": 3, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 3,
+    "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 2, "HINTS": 1, "STACK": 3,
+  },
+};
+
+// ── Priority offset per relevance level ──────────────────────
+
+const RELEVANCE_OFFSET: Record<Relevance, number> = {
+  3: -2,  // essential: boost
+  2: 0,   // useful: keep as-is
+  1: 4,   // nice-to-have: deprioritize
+  0: 0,   // noise: excluded before this applies
+};
+
+// ── Functions ────────────────────────────────────────────────
+
+export function getAgentDomain(agentName: string | null | undefined): AgentDomain | null {
+  if (!agentName) return null;
+  return AGENT_DOMAIN[agentName] ?? null;
+}
+
+export function domainToScope(domain: AgentDomain | null): string {
+  if (!domain) return "all";
+
+  const scopeMap: Record<AgentDomain, string> = {
+    backend: "backend",
+    frontend: "frontend",
+    database: "database",
+    testing: "testing",
+    review: "all",
+    security: "all",
+    explore: "all",
+    architecture: "all",
+  };
+
+  return scopeMap[domain];
+}
+
+export function adjustSectionPriorities(
+  sections: ContextSection[],
+  domain: AgentDomain | null,
+): ContextSection[] {
+  if (!domain) return sections;
+
+  const profile = DOMAIN_PROFILES[domain];
+
+  return sections
+    .filter(s => {
+      const relevance = profile[s.name as SectionName];
+      // Unknown section names pass through (forward compatibility)
+      return relevance === undefined || relevance > 0;
+    })
+    .map(s => {
+      const relevance = profile[s.name as SectionName];
+      if (relevance === undefined) return s;
+
+      const offset = RELEVANCE_OFFSET[relevance];
+      return { ...s, priority: Math.max(1, s.priority + offset) };
+    });
+}

package/context/generator.ts

@@ -2,7 +2,8 @@ import { getDb } from "../db/connection";
 import { initSchema, getPatternsForFiles, getRelatedDecisions, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { getKnowledgeForTask } from "../commands/knowledge";
 import type { ContextSection, ContextData } from "./assembly";
-import { assembleSections, AGENT_SECTIONS } from "./assembly";
+import { assembleSections } from "./assembly";
+import { getAgentDomain, adjustSectionPriorities, domainToScope } from "./domains";
 import { filterRelevantDecisions, filterRelevantStandards } from "./scoring";
 import {
     buildProductSection,
@@ -17,6 +18,7 @@ import {
     buildGraphSection,
     buildStackSection,
     buildHintsSection,
+    buildReferencesSection,
 } from "./sections";
 
 // v9.0: Contexto minimo para subagent (max ~2KB)
@@ -33,7 +35,7 @@ export function getMinimalContextForSubagent(taskId: number): string {
     const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(task.spec_id) as any;
 
     const taskFiles = task.files ? JSON.parse(task.files) : [];
-    const domain = task.agent?.split("-")[0] || "all";
+    const domain = domainToScope(getAgentDomain(task.agent));
 
     // 1. Standards REQUIRED apenas (nao recommended)
     const requiredStandards = db.query(
@@ -42,11 +44,12 @@ export function getMinimalContextForSubagent(taskId: number): string {
          LIMIT 10`
     ).all(domain) as any[];
 
-    // 2. Blockers CRITICAL apenas
+    // 2. Blockers CRITICAL (spec atual + cross-feature)
     const criticalBlockers = db.query(
-        `SELECT content FROM knowledge
-         WHERE spec_id = ? AND severity = 'critical'
-         ORDER BY created_at DESC LIMIT 5`
+        `SELECT DISTINCT content FROM knowledge
+         WHERE severity = 'critical'
+         ORDER BY CASE WHEN spec_id = ? THEN 0 ELSE 1 END, created_at DESC
+         LIMIT 5`
     ).all(task.spec_id) as any[];
 
     // 3. Decisoes da task anterior (dependency direta)
@@ -124,7 +127,7 @@ function fetchContextData(taskId: number): ContextData | null {
 
     // Arquivos da task para filtrar contexto relevante
     const taskFiles = task.files ? JSON.parse(task.files) : [];
-    const domain = task.agent?.split("-")[0] || "all";
+    const domain = domainToScope(getAgentDomain(task.agent));
 
     // Decisoes relevantes (max 8, priorizando as que mencionam arquivos da task)
     const allDecisions = db
@@ -251,6 +254,7 @@ export function getContextForSubagent(taskId: number): string {
         buildProductSection(data),
         buildArchitectureSection(data),
         buildStandardsSection(data),
+        buildReferencesSection(data),
         buildDecisionsSection(data),
         buildReasoningSection(data),
         buildAlertsSection(data),
@@ -262,12 +266,9 @@ export function getContextForSubagent(taskId: number): string {
         buildHintsSection(data),
     ].filter((s): s is ContextSection => s !== null);
 
-    // v9.3: Filtrar secoes por tipo de agente
-    const agentType = data.task.agent || "";
-    const allowedSections = AGENT_SECTIONS[agentType];
-    const sections = allowedSections
-        ? allSections.filter(s => allowedSections.includes(s.name))
-        : allSections;
+    // v9.4: Domain-based priority adjustment (replaces binary AGENT_SECTIONS)
+    const agentDomain = getAgentDomain(data.task.agent);
+    const sections = adjustSectionPriorities(allSections, agentDomain);
 
     return assembleSections(header, sections);
 }

package/context/index.ts

@@ -1,6 +1,8 @@
 // Re-exports for backward compatibility
 export { getContextForSubagent, getMinimalContextForSubagent } from "./generator";
-export { assembleSections, MAX_CONTEXT_SIZE, AGENT_SECTIONS } from "./assembly";
+export { assembleSections, MAX_CONTEXT_SIZE } from "./assembly";
+export { AGENT_DOMAIN, DOMAIN_PROFILES, getAgentDomain, adjustSectionPriorities, domainToScope } from "./domains";
+export type { AgentDomain, Relevance, SectionName, DomainProfile } from "./domains";
 export type { ContextSection, ContextData } from "./assembly";
 export { filterRelevantDecisions, filterRelevantStandards } from "./scoring";
 export {
@@ -16,4 +18,7 @@ export {
     buildGraphSection,
     buildStackSection,
     buildHintsSection,
+    buildReferencesSection,
 } from "./sections";
+export { findReferenceFiles } from "./references";
+export type { ReferenceFile } from "./references";