@codexa/cli 9.0.6 → 9.0.8

package/context/assembly.ts

@@ -0,0 +1,81 @@
+// v8.3: Limite maximo de contexto para subagents (16KB)
+export const MAX_CONTEXT_SIZE = 16384;
+
+export interface ContextSection {
+    name: string;
+    content: string;
+    priority: number; // Lower = kept during truncation
+}
+
+export interface ContextData {
+    db: any;
+    task: any;
+    spec: any;
+    context: any;
+    project: any;
+    taskFiles: string[];
+    domain: string;
+    archAnalysis: any;
+    decisions: any[];
+    allDecisions: any[];
+    relevantStandards: any[];
+    criticalKnowledge: any[];
+    truncatedCritical: number;
+    infoKnowledge: any[];
+    truncatedInfo: number;
+    productContext: any;
+    patterns: any[];
+    depReasoning: any[];
+    libContexts: any[];
+    graphDecisions: any[];
+    discoveredPatterns: any[];
+}
+
+export function assembleSections(header: string, sections: ContextSection[]): string {
+    // Sort by priority (lower = higher priority, kept during truncation)
+    const sorted = [...sections].sort((a, b) => a.priority - b.priority);
+
+    let output = header;
+    for (const section of sorted) {
+        output += section.content;
+    }
+
+    // Protocolo de retorno (sempre incluido)
+    output += `
+### RETORNO OBRIGATORIO
+\`\`\`json
+{"status": "completed|blocked", "summary": "...", "files_created": [], "files_modified": [], "reasoning": {"approach": "como abordou", "challenges": [], "recommendations": "para proximas tasks"}}
+\`\`\`
+`;
+
+    // v8.3: Overall size cap com truncamento inteligente por secao
+    if (output.length > MAX_CONTEXT_SIZE) {
+        const parts = output.split('\n### ');
+        let trimmed = parts[0]; // Sempre manter header
+        let breakIndex = parts.length;
+
+        for (let i = 1; i < parts.length; i++) {
+            const candidate = trimmed + '\n### ' + parts[i];
+            if (candidate.length > MAX_CONTEXT_SIZE - 200) {
+                breakIndex = i;
+                break;
+            }
+            trimmed = candidate;
+        }
+
+        // Coletar nomes das secoes omitidas
+        const omittedNames: string[] = [];
+        for (let i = breakIndex; i < parts.length; i++) {
+            const name = parts[i].split('\n')[0].trim();
+            if (name) omittedNames.push(name);
+        }
+
+        if (omittedNames.length > 0) {
+            trimmed += `\n\n[CONTEXTO TRUNCADO: ${omittedNames.length} secao(oes) omitida(s) (${omittedNames.join(', ')}). Use: codexa context detail <secao>]`;
+        }
+
+        output = trimmed;
+    }
+
+    return output;
+}

package/context/domains.test.ts

@@ -0,0 +1,278 @@
+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: "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(12);
+    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: 7 sections have relevance 0
+    expect(names).not.toContain("STANDARDS");
+    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(11);
+  });
+
+  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("security domain excludes PRODUTO (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "security");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+    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", "ALERTAS", "ARQUITETURA", "DECISOES",
+    "CONTEXTO DE TASKS ANTERIORES", "GRAPH", "PRODUTO",
+    "DISCOVERIES", "UTILITIES", "PATTERNS", "HINTS", "STACK",
+  ];
+
+  it("every domain profile covers all 12 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,156 @@
+// ═══════════════════════════════════════════════════════════════
+// 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"
+  | "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, "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, "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, "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, "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, "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, "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, "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, "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) };
+    });
+}