ndomo 0.1.0 → 0.2.1

package/src/orchestrator/memory-hook.ts

@@ -1,182 +0,0 @@
-/**
- * Pre-add caveman compression for memory entries.
- * Transforms verbose text into compressed caveman format before
- * storing in opencode-mem, saving tokens on retrieval.
- *
- * All compression is regex-based (0 LLM tokens).
- */
-
-/** A memory entry ready for storage. */
-export interface MemoryEntry {
-  /** The content to store. */
-  content: string;
-  /** Topic/category for the memory. */
-  topic: string;
-  /** Whether this is project-scoped or global. */
-  scope: "project" | "all-projects";
-  /** Optional tags for filtering. */
-  tags?: string[];
-}
-
-/**
- * Regex patterns for caveman compression.
- * Each pattern is applied sequentially to the text.
- */
-const COMPRESSION_PATTERNS = [
-  // Drop leading conjunctions: "And then...", "But actually...", "So basically..."
-  { pattern: /^(?:and|but|or|so|then|also|well)\s+/gi, replacement: "" },
-
-  // Drop filler adverbs anywhere in the sentence
-  {
-    pattern:
-      /\b(?:just|really|basically|actually|simply|literally|honestly|seriously|obviously|definitely|probably|certainly|essentially|fundamentally|effectively)\b\s*/gi,
-    replacement: "",
-  },
-
-  // Drop articles: English
-  { pattern: /\b(?:the|a|an)\b\s*/gi, replacement: "" },
-
-  // Drop articles: Spanish (for bilingual contexts)
-  { pattern: /\b(?:el|la|los|las|un|una|unos|unas)\b\s*/gi, replacement: "" },
-
-  // Drop filler phrases
-  {
-    pattern:
-      /\b(?:in order to|due to the fact that|it is important to note that|it should be noted that|as a matter of fact|at the end of the day|for what it's worth|the thing is|what I mean is)\b\s*/gi,
-    replacement: "",
-  },
-
-  // Collapse multiple spaces into one
-  { pattern: / {2,}/g, replacement: " " },
-
-  // Collapse multiple newlines into max two
-  { pattern: /\n{3,}/g, replacement: "\n\n" },
-] as const;
-
-/**
- * URL pattern to protect URLs from compression.
- * Matches http://, https://, and common git/ssh URLs.
- */
-const URL_PATTERN = /(?:https?:\/\/|git@|ssh:\/\/)[^\s`)\]]+/g;
-
-/**
- * Code block pattern to protect code from compression.
- * Matches fenced code blocks: ```...```
- */
-const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
-
-/**
- * Compress text into caveman format using regex transformations.
- *
- * Preserves:
- * - Fenced code blocks (```...```)
- * - URLs (http://, https://, git@, ssh://)
- *
- * Removes:
- * - Articles (a, an, the, el, la, los, las, un, una)
- * - Filler words (just, really, basically, actually, simply, etc.)
- * - Leading conjunctions (and, but, or, so, then, also)
- * - Filler phrases ("in order to", "it is important to note that", etc.)
- * - Excess whitespace
- *
- * @param text - Input text to compress.
- * @returns Compressed caveman text.
- */
-export function cavemanCompress(text: string): string {
-  if (!text || text.trim().length === 0) return text;
-
-  // Step 1: Extract protected regions (code blocks and URLs)
-  const protectedRegions: Array<{ start: number; end: number; text: string }> = [];
-
-  // Extract code blocks first
-  for (const match of text.matchAll(CODE_BLOCK_PATTERN)) {
-    if (match.index !== undefined) {
-      protectedRegions.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        text: match[0],
-      });
-    }
-  }
-
-  // Extract URLs (skip those inside code blocks)
-  for (const match of text.matchAll(URL_PATTERN)) {
-    if (match.index !== undefined) {
-      const idx = match.index;
-      const isInsideCodeBlock = protectedRegions.some((r) => idx >= r.start && idx < r.end);
-      if (!isInsideCodeBlock) {
-        protectedRegions.push({
-          start: idx,
-          end: idx + match[0].length,
-          text: match[0],
-        });
-      }
-    }
-  }
-
-  // Sort by start position (descending) for safe replacement
-  protectedRegions.sort((a, b) => b.start - a.start);
-
-  // Step 2: Replace protected regions with placeholders
-  let workingText = text;
-  const placeholders: string[] = [];
-
-  for (const region of protectedRegions) {
-    const placeholder = `\x00PROTECTED_${placeholders.length}\x00`;
-    placeholders.push(region.text);
-    workingText = workingText.slice(0, region.start) + placeholder + workingText.slice(region.end);
-  }
-
-  // Step 3: Apply compression patterns
-  for (const { pattern, replacement } of COMPRESSION_PATTERNS) {
-    workingText = workingText.replace(pattern, replacement);
-  }
-
-  // Step 4: Restore protected regions
-  for (const [i, region] of placeholders.entries()) {
-    workingText = workingText.replace(`\x00PROTECTED_${i}\x00`, region);
-  }
-
-  // Step 5: Final trim
-  return workingText.trim();
-}
-
-/**
- * Prepare a memory entry for storage by compressing its content.
- * Returns a new MemoryEntry — does not mutate the original.
- *
- * @param entry - Raw memory entry.
- * @returns New MemoryEntry with compressed content.
- */
-export function prepareForMemory(entry: MemoryEntry): MemoryEntry {
-  return {
-    ...entry,
-    content: cavemanCompress(entry.content),
-  };
-}
-
-/**
- * Determine whether content is worth storing in memory.
- *
- * Filters out:
- * - Trivial content (< 20 chars after compression)
- * - Pure code blocks with no prose to summarize
- *
- * @param content - Content to evaluate.
- * @returns `true` if the content should be stored.
- */
-export function shouldStoreMemory(content: string): boolean {
-  const compressed = cavemanCompress(content);
-
-  // Too short after compression — not worth storing
-  if (compressed.length < 20) return false;
-
-  // Check if content is purely code blocks
-  const withoutCodeBlocks = compressed.replace(CODE_BLOCK_PATTERN, "").trim();
-  if (withoutCodeBlocks.length < 10) {
-    // Almost all code, very little prose — not useful for memory search
-    return false;
-  }
-
-  return true;
-}

package/src/orchestrator/reconciler.ts

@@ -1,123 +0,0 @@
-/**
- * Result reconciliation for parallel agent tasks.
- * Merges outputs from multiple specialist agents into a unified report.
- */
-
-/** Result from a single completed task. */
-export interface TaskResult {
-  /** Task ID from the dispatcher. */
-  taskId: string;
-  /** Agent that produced this result. */
-  agent: string;
-  /** Agent's output text. */
-  output: string;
-  /** Files the agent modified or created. */
-  filesModified: string[];
-  /** Whether the task succeeded. */
-  success: boolean;
-}
-
-/** Unified report after reconciling multiple task results. */
-export interface ReconciliationReport {
-  /** Merged summary of all agent outputs. */
-  mergedSummary: string;
-  /** File paths where two or more agents wrote (potential conflicts). */
-  conflicts: string[];
-  /** Deduplicated list of all files touched across all tasks. */
-  allFilesModified: string[];
-  /** Actionable next steps based on the results. */
-  recommendations: string[];
-}
-
-/**
- * Reconcile results from multiple parallel agent tasks.
- *
- * Detects file conflicts (two agents modified the same file),
- * merges output summaries, and generates recommendations.
- *
- * @param results - Array of task results to reconcile.
- * @returns A unified reconciliation report.
- */
-export function reconcileResults(results: TaskResult[]): ReconciliationReport {
-  const conflicts: string[] = [];
-  const allFilesModified: string[] = [];
-  const recommendations: string[] = [];
-  const summaryParts: string[] = [];
-
-  // Track which agents modified each file
-  const fileAgents = new Map<string, Set<string>>();
-
-  for (const result of results) {
-    // Build summary
-    const status = result.success ? "ok" : "FAILED";
-    summaryParts.push(`[${result.agent}:${status}] ${truncate(result.output, 200)}`);
-
-    // Track file ownership
-    for (const file of result.filesModified) {
-      allFilesModified.push(file);
-
-      const agents = fileAgents.get(file);
-      if (agents) {
-        agents.add(result.agent);
-      } else {
-        fileAgents.set(file, new Set([result.agent]));
-      }
-    }
-
-    // Flag failures as recommendations
-    if (!result.success) {
-      recommendations.push(
-        `Task ${result.taskId} (${result.agent}) failed: ${truncate(result.output, 100)}`,
-      );
-    }
-  }
-
-  // Detect conflicts: files modified by multiple agents
-  for (const [file, agents] of fileAgents.entries()) {
-    if (agents.size > 1) {
-      const agentList = Array.from(agents).join(", ");
-      conflicts.push(`CONFLICT: ${file} modified by ${agentList}`);
-      recommendations.push(
-        `Review merge conflict in ${file} — touched by: ${agentList}. Manual resolution may be needed.`,
-      );
-    }
-  }
-
-  // Deduplicate file list
-  const uniqueFiles = [...new Set(allFilesModified)];
-
-  // General recommendations
-  if (conflicts.length === 0 && results.length > 1) {
-    recommendations.push("No file conflicts detected. Safe to merge.");
-  }
-
-  if (results.every((r) => r.success)) {
-    recommendations.push("All tasks succeeded. Run tests to verify integration.");
-  }
-
-  const failedCount = results.filter((r) => !r.success).length;
-  if (failedCount > 0) {
-    recommendations.push(
-      `${failedCount}/${results.length} tasks failed. Review failures before proceeding.`,
-    );
-  }
-
-  return {
-    mergedSummary: summaryParts.join("\n"),
-    conflicts,
-    allFilesModified: uniqueFiles,
-    recommendations,
-  };
-}
-
-/**
- * Truncate text to a maximum length, appending "…" if truncated.
- *
- * @param text - Text to truncate.
- * @param maxLength - Maximum character count.
- * @returns Truncated string.
- */
-function truncate(text: string, maxLength: number): string {
-  if (text.length <= maxLength) return text;
-  return `${text.slice(0, maxLength - 1)}…`;
-}

package/src/orchestrator/scheduler.test.ts

@@ -1,300 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { RoutedTask, RoutingDecision, TaskRequest } from "./scheduler.ts";
-import { canRunParallel, routeTask } from "./scheduler.ts";
-
-const mk = (overrides: Partial<TaskRequest> & Pick<TaskRequest, "type">): TaskRequest => ({
-  description: "test task",
-  risk: "low",
-  ...overrides,
-});
-
-// ─── routeTask ────────────────────────────────────────────────────────
-
-describe("routeTask", () => {
-  describe("priority rules", () => {
-    test("explore → scout", () => {
-      const d = routeTask(mk({ type: "explore" }));
-      expect(d.agent).toBe("scout");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("research → scribe", () => {
-      const d = routeTask(mk({ type: "research" }));
-      expect(d.agent).toBe("scribe");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("design + vue → painter", () => {
-      const d = routeTask(mk({ type: "design", stack: "vue" }));
-      expect(d.agent).toBe("painter");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("design + non-vue stack → smith (default)", () => {
-      const d = routeTask(mk({ type: "design", stack: "js" }));
-      expect(d.agent).toBe("smith");
-    });
-
-    test("audit → inspector", () => {
-      const d = routeTask(mk({ type: "audit" }));
-      expect(d.agent).toBe("inspector");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("document → chronicler", () => {
-      const d = routeTask(mk({ type: "document" }));
-      expect(d.agent).toBe("chronicler");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("debate → guild, not parallel", () => {
-      const d = routeTask(mk({ type: "debate" }));
-      expect(d.agent).toBe("guild");
-      expect(d.parallel).toBe(false);
-    });
-
-    test("debug + high risk → sage, not parallel", () => {
-      const d = routeTask(mk({ type: "debug", risk: "high" }));
-      expect(d.agent).toBe("sage");
-      expect(d.parallel).toBe(false);
-    });
-
-    test("debug + low risk → smith (default)", () => {
-      const d = routeTask(mk({ type: "debug", risk: "low" }));
-      expect(d.agent).toBe("smith");
-    });
-
-    test("implement + js → js-smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "js" }));
-      expect(d.agent).toBe("js-smith");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("implement + go → go-smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "go" }));
-      expect(d.agent).toBe("go-smith");
-    });
-
-    test("implement + python → python-smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "python" }));
-      expect(d.agent).toBe("python-smith");
-    });
-
-    test("implement + zig → zig-smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "zig" }));
-      expect(d.agent).toBe("zig-smith");
-    });
-
-    test("implement + vue → vue-smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "vue" }));
-      expect(d.agent).toBe("vue-smith");
-    });
-
-    test("implement + generic → smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "generic" }));
-      expect(d.agent).toBe("smith");
-    });
-
-    test("implement + unknown → smith", () => {
-      const d = routeTask(mk({ type: "implement", stack: "unknown" }));
-      expect(d.agent).toBe("smith");
-    });
-
-    test("implement + no stack → smith", () => {
-      const d = routeTask(mk({ type: "implement" }));
-      expect(d.agent).toBe("smith");
-    });
-  });
-
-  describe("dependencies semantics", () => {
-    test("all routeTask results have empty dependencies (task IDs set externally)", () => {
-      const cases: TaskRequest[] = [
-        mk({ type: "explore" }),
-        mk({ type: "research" }),
-        mk({ type: "design", stack: "vue" }),
-        mk({ type: "audit" }),
-        mk({ type: "document" }),
-        mk({ type: "debate" }),
-        mk({ type: "debug", risk: "high" }),
-        mk({ type: "implement", stack: "js" }),
-      ];
-      for (const req of cases) {
-        const d = routeTask(req);
-        expect(d.dependencies).toEqual([]);
-      }
-    });
-
-    test("dependencies are task IDs, never agent names", () => {
-      const d = routeTask(mk({ type: "implement", stack: "js", risk: "high" }));
-      // Bug was: dependencies: ["sage"] — agent name in task ID field
-      expect(d.dependencies).toEqual([]);
-      expect(d.dependencies).not.toContain("sage");
-    });
-  });
-
-  describe("requiresReview (sage advisory)", () => {
-    test("high-risk implement sets requiresReview to sage", () => {
-      const d = routeTask(mk({ type: "implement", stack: "js", risk: "high" }));
-      expect(d.requiresReview).toBe("sage");
-      expect(d.agent).toBe("js-smith");
-      expect(d.parallel).toBe(true);
-    });
-
-    test("high-risk implement + go → go-smith with sage review", () => {
-      const d = routeTask(mk({ type: "implement", stack: "go", risk: "high" }));
-      expect(d.agent).toBe("go-smith");
-      expect(d.requiresReview).toBe("sage");
-    });
-
-    test("low-risk implement has no requiresReview", () => {
-      const d = routeTask(mk({ type: "implement", stack: "js" }));
-      expect(d.requiresReview).toBeUndefined();
-    });
-
-    test("non-implement tasks have no requiresReview", () => {
-      const d = routeTask(mk({ type: "explore", risk: "high" }));
-      expect(d.requiresReview).toBeUndefined();
-    });
-
-    test("debug + high risk has no requiresReview (goes to sage directly)", () => {
-      const d = routeTask(mk({ type: "debug", risk: "high" }));
-      expect(d.requiresReview).toBeUndefined();
-      expect(d.agent).toBe("sage");
-    });
-  });
-});
-
-// ─── canRunParallel ───────────────────────────────────────────────────
-
-describe("canRunParallel", () => {
-  const makeRouted = (
-    id: string,
-    agent: string,
-    opts: Partial<Pick<RoutingDecision, "parallel" | "dependencies">> = {},
-  ): RoutedTask => ({
-    id,
-    decision: {
-      agent,
-      reason: "test",
-      parallel: opts.parallel ?? true,
-      dependencies: opts.dependencies ?? [],
-    },
-  });
-
-  test("all parallel, no deps → true", () => {
-    expect(
-      canRunParallel([
-        makeRouted("t1", "scout"),
-        makeRouted("t2", "scribe"),
-        makeRouted("t3", "js-smith"),
-      ]),
-    ).toBe(true);
-  });
-
-  test("one non-parallel task → false", () => {
-    expect(
-      canRunParallel([makeRouted("t1", "scout"), makeRouted("t2", "guild", { parallel: false })]),
-    ).toBe(false);
-  });
-
-  test("dependency on external task (not in batch) → true", () => {
-    expect(
-      canRunParallel([
-        makeRouted("t1", "js-smith", { dependencies: ["t-external"] }),
-        makeRouted("t2", "scout"),
-      ]),
-    ).toBe(true);
-  });
-
-  test("dependency on task in same batch → false", () => {
-    expect(
-      canRunParallel([
-        makeRouted("t1", "scout"),
-        makeRouted("t2", "js-smith", { dependencies: ["t1"] }),
-      ]),
-    ).toBe(false);
-  });
-
-  test("circular dependency in batch → false", () => {
-    const result = canRunParallel([
-      makeRouted("t1", "js-smith", { dependencies: ["t2"] }),
-      makeRouted("t2", "scout", { dependencies: ["t1"] }),
-    ]);
-    expect(result).toBe(false);
-  });
-
-  test("empty batch → true", () => {
-    expect(canRunParallel([])).toBe(true);
-  });
-
-  test("single task, parallel, no deps → true", () => {
-    expect(canRunParallel([makeRouted("t1", "scout")])).toBe(true);
-  });
-
-  test("single task, non-parallel → false", () => {
-    expect(canRunParallel([makeRouted("t1", "guild", { parallel: false })])).toBe(false);
-  });
-
-  test("multiple deps, only one in batch → false", () => {
-    expect(
-      canRunParallel([
-        makeRouted("t1", "scout"),
-        makeRouted("t2", "scribe"),
-        makeRouted("t3", "js-smith", { dependencies: ["t-external", "t1"] }),
-      ]),
-    ).toBe(false);
-  });
-
-  test("requiresReview does not affect parallelism", () => {
-    // sage review is advisory, not a blocking dependency
-    const tasks: RoutedTask[] = [
-      {
-        id: "t1",
-        decision: {
-          agent: "js-smith",
-          reason: "test",
-          parallel: true,
-          dependencies: [],
-          requiresReview: "sage",
-        },
-      },
-      makeRouted("t2", "scout"),
-    ];
-    expect(canRunParallel(tasks)).toBe(true);
-  });
-});
-
-// ─── canRunParallel (legacy RoutingDecision[] path) ───────────────────
-
-describe("canRunParallel (legacy RoutingDecision[])", () => {
-  test("all parallel, no deps → true", () => {
-    const decisions: RoutingDecision[] = [
-      { agent: "scout", reason: "test", parallel: true, dependencies: [] },
-      { agent: "scribe", reason: "test", parallel: true, dependencies: [] },
-    ];
-    expect(canRunParallel(decisions)).toBe(true);
-  });
-
-  test("one non-parallel → false", () => {
-    const decisions: RoutingDecision[] = [
-      { agent: "scout", reason: "test", parallel: true, dependencies: [] },
-      { agent: "guild", reason: "test", parallel: false, dependencies: [] },
-    ];
-    expect(canRunParallel(decisions)).toBe(false);
-  });
-
-  test("agent-name dependency in batch → false (legacy semantic)", () => {
-    const decisions: RoutingDecision[] = [
-      { agent: "scout", reason: "test", parallel: true, dependencies: [] },
-      { agent: "js-smith", reason: "test", parallel: true, dependencies: ["scout"] },
-    ];
-    expect(canRunParallel(decisions)).toBe(false);
-  });
-
-  test("agent-name dependency not in batch → true", () => {
-    const decisions: RoutingDecision[] = [
-      { agent: "js-smith", reason: "test", parallel: true, dependencies: ["sage"] },
-    ];
-    expect(canRunParallel(decisions)).toBe(true);
-  });
-});