muonroi-cli 1.4.0 → 1.4.1

package/src/pil/__tests__/response-tools.test.ts

@@ -1,239 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  AnalyzeSchema,
-  buildResponseTools,
-  DebugSchema,
-  DocsSchema,
-  GeneralSchema,
-  GenerateSchema,
-  getResponseTaskType,
-  isResponseTool,
-  PlanSchema,
-  RESPONSE_TOOL_PREFIX,
-  RefactorSchema,
-  shouldHaltOnResponseTool,
-  stepEmittedResponseTool,
-} from "../response-tools";
-
-type Step = { toolCalls?: ReadonlyArray<{ toolName?: string }> };
-const step = (...names: Array<string | undefined>): Step => ({
-  toolCalls: names.map((toolName) => ({ toolName })),
-});
-
-describe("isResponseTool", () => {
-  it("returns true for response tool names", () => {
-    expect(isResponseTool("respond_refactor")).toBe(true);
-    expect(isResponseTool("respond_debug")).toBe(true);
-    expect(isResponseTool("respond_plan")).toBe(true);
-  });
-
-  it("returns false for action tools", () => {
-    expect(isResponseTool("bash")).toBe(false);
-    expect(isResponseTool("read_file")).toBe(false);
-    expect(isResponseTool("edit_file")).toBe(false);
-  });
-});
-
-describe("getResponseTaskType", () => {
-  it("extracts task type from tool name", () => {
-    expect(getResponseTaskType("respond_refactor")).toBe("refactor");
-    expect(getResponseTaskType("respond_debug")).toBe("debug");
-    expect(getResponseTaskType("respond_plan")).toBe("plan");
-    expect(getResponseTaskType("respond_analyze")).toBe("analyze");
-    expect(getResponseTaskType("respond_documentation")).toBe("documentation");
-    expect(getResponseTaskType("respond_generate")).toBe("generate");
-  });
-
-  it("returns null for unknown task types", () => {
-    expect(getResponseTaskType("respond_unknown")).toBeNull();
-    expect(getResponseTaskType("bash")).toBeNull();
-  });
-});
-
-describe("buildResponseTools", () => {
-  it("returns a ToolSet with one tool for valid task type", () => {
-    const tools = buildResponseTools("refactor");
-    expect(Object.keys(tools)).toEqual(["respond_refactor"]);
-    expect(tools.respond_refactor.description).toContain("refactor");
-    expect(tools.respond_refactor.inputSchema).toBeDefined();
-    expect(tools.respond_refactor.execute).toBeTypeOf("function");
-  });
-
-  it("execute returns input unchanged", async () => {
-    const tools = buildResponseTools("debug");
-    const input = {
-      hypothesis: "test",
-      root_cause: "bug",
-      fix: { file: "a.ts", diff: "+" },
-      verify_command: "npm test",
-    };
-    const result = await tools.respond_debug.execute!(input, {
-      toolCallId: "1",
-      messages: [],
-      abortSignal: new AbortController().signal,
-    });
-    expect(result).toEqual(input);
-  });
-
-  it("builds tools for all 6 task types", () => {
-    for (const taskType of ["refactor", "debug", "plan", "analyze", "documentation", "generate"] as const) {
-      const tools = buildResponseTools(taskType);
-      expect(Object.keys(tools)).toHaveLength(1);
-      expect(Object.keys(tools)[0]).toBe(`${RESPONSE_TOOL_PREFIX}${taskType}`);
-    }
-  });
-});
-
-describe("stepEmittedResponseTool", () => {
-  it("returns true when a step emitted a response tool", () => {
-    expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "respond_general" }] })).toBe(true);
-    expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "read_file" }, { toolName: "respond_analyze" }] })).toBe(
-      true,
-    );
-  });
-
-  it("returns false for action-only steps", () => {
-    expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "bash" }, { toolName: "read_file" }] })).toBe(false);
-  });
-
-  it("returns false for steps with no tool calls", () => {
-    expect(stepEmittedResponseTool({ toolCalls: [] })).toBe(false);
-    expect(stepEmittedResponseTool({})).toBe(false);
-    expect(stepEmittedResponseTool(undefined)).toBe(false);
-  });
-
-  it("ignores malformed entries without a toolName", () => {
-    expect(stepEmittedResponseTool({ toolCalls: [{}, { toolName: undefined }] })).toBe(false);
-  });
-});
-
-describe("shouldHaltOnResponseTool", () => {
-  it("does not halt when the last step did not emit a response tool", () => {
-    expect(shouldHaltOnResponseTool([step("read_file"), step("grep")])).toBe(false);
-    expect(shouldHaltOnResponseTool([])).toBe(false);
-    expect(shouldHaltOnResponseTool(undefined)).toBe(false);
-  });
-
-  it("halts on a response tool emitted AFTER real tool work (terminal answer)", () => {
-    // d95113d3 seq=27: 7 grep/read calls, THEN respond_general → halt at call #1.
-    expect(
-      shouldHaltOnResponseTool([step("grep"), step("read_file"), step("read_file"), step("respond_general")]),
-    ).toBe(true);
-    // Real work + response in the SAME step also counts as investigated.
-    expect(shouldHaltOnResponseTool([step("read_file", "respond_analyze")])).toBe(true);
-    // d95113d3 seq=3: deep investigation → single respond_analyze.
-    expect(shouldHaltOnResponseTool([step("bash"), step("read_file"), step("respond_analyze")])).toBe(true);
-  });
-
-  it("does NOT halt on a single blind response tool (no prior investigation)", () => {
-    // e4a9d97a90: lone blind respond_general at step 0 — give the model the
-    // step it announced it would use to read code instead of force-stopping.
-    expect(shouldHaltOnResponseTool([step("respond_general")])).toBe(false);
-  });
-
-  it("halts on a 2nd blind response tool with still no real work (narration loop)", () => {
-    // 9b1b3: 2× blind respond_general, zero investigation → bounded at 2.
-    expect(shouldHaltOnResponseTool([step("respond_general"), step("respond_general")])).toBe(true);
-  });
-
-  it("treats a blind response then real work then response as terminal (investigated)", () => {
-    // Announce → investigate → answer: the final response is after real work.
-    expect(shouldHaltOnResponseTool([step("respond_general"), step("read_file"), step("respond_general")])).toBe(true);
-  });
-});
-
-describe("schemas validate correct input", () => {
-  it("RefactorSchema accepts valid input", () => {
-    const result = RefactorSchema.safeParse({
-      summary: "Extract helper function",
-      changes: [{ file: "src/utils.ts", diff: "- old\n+ new" }],
-      verify_command: "bun test",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("RefactorSchema rejects missing changes", () => {
-    const result = RefactorSchema.safeParse({ summary: "test" });
-    expect(result.success).toBe(false);
-  });
-
-  it("DebugSchema accepts valid input", () => {
-    const result = DebugSchema.safeParse({
-      hypothesis: "Race condition",
-      root_cause: "Shared mutable state",
-      fix: { file: "src/store.ts", diff: "+ const lock = new Mutex();" },
-      verify_command: "bun test",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("PlanSchema accepts valid input", () => {
-    const result = PlanSchema.safeParse({
-      steps: [{ action: "Add tests", criterion: "Coverage > 80%" }],
-      assumptions: ["CI is green"],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("AnalyzeSchema accepts valid input", () => {
-    const result = AnalyzeSchema.safeParse({
-      findings: [{ text: "SQL injection risk", evidence: "src/db.ts:42", severity: "high" }],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("AnalyzeSchema rejects invalid severity", () => {
-    const result = AnalyzeSchema.safeParse({
-      findings: [{ text: "issue", evidence: "file:1", severity: "critical" }],
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("DocsSchema accepts valid input", () => {
-    const result = DocsSchema.safeParse({
-      content: "# API Reference\n\nUse `foo()` to...",
-      examples: [{ code: "foo()", description: "Basic usage" }],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("GenerateSchema accepts valid input", () => {
-    const result = GenerateSchema.safeParse({
-      files: [{ path: "src/hello.ts", content: 'console.log("hi")', language: "typescript" }],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("GeneralSchema accepts valid input with response only", () => {
-    const result = GeneralSchema.safeParse({ response: "The answer is 42." });
-    expect(result.success).toBe(true);
-  });
-
-  it("GeneralSchema accepts valid input with optional reasoning", () => {
-    const result = GeneralSchema.safeParse({ response: "Yes", reasoning: "Because it satisfies the constraints." });
-    expect(result.success).toBe(true);
-  });
-
-  it("GeneralSchema rejects missing response", () => {
-    const result = GeneralSchema.safeParse({ reasoning: "some reasoning" });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("respond_general catch-all tool", () => {
-  it("respond_general tool exists with correct schema", () => {
-    const tools = buildResponseTools("general");
-    expect(Object.keys(tools)).toEqual(["respond_general"]);
-    expect(tools.respond_general.description).toContain("general");
-    expect(tools.respond_general.inputSchema).toBeDefined();
-    expect(tools.respond_general.execute).toBeTypeOf("function");
-  });
-
-  it("getResponseTaskType returns 'general' for 'respond_general'", () => {
-    expect(getResponseTaskType("respond_general")).toBe("general");
-  });
-
-  it("isResponseTool returns true for 'respond_general'", () => {
-    expect(isResponseTool("respond_general")).toBe(true);
-  });
-});

package/src/pil/__tests__/schema.test.ts

@@ -1,233 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  OutputStyleSchema,
-  PilContextResponseSchema,
-  PipelineContextSchema,
-  PipelineMetricsSchema,
-  TaskTypeSchema,
-} from "../schema.js";
-
-describe("PipelineContextSchema", () => {
-  const validCtx = {
-    raw: "test",
-    enriched: "test",
-    taskType: "refactor" as const,
-    domain: null,
-    confidence: 0.85,
-    outputStyle: "concise" as const,
-    tokenBudget: 500,
-    metrics: null,
-    layers: [{ name: "intent-detection", applied: true, delta: "taskType=refactor" }],
-  };
-
-  it("accepts valid PipelineContext", () => {
-    const result = PipelineContextSchema.safeParse(validCtx);
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts null taskType and outputStyle", () => {
-    const result = PipelineContextSchema.safeParse({
-      ...validCtx,
-      taskType: null,
-      outputStyle: null,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects confidence > 1", () => {
-    const result = PipelineContextSchema.safeParse({ ...validCtx, confidence: 1.5 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects confidence < 0", () => {
-    const result = PipelineContextSchema.safeParse({ ...validCtx, confidence: -0.1 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects invalid taskType", () => {
-    const result = PipelineContextSchema.safeParse({ ...validCtx, taskType: "invalid" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects invalid outputStyle", () => {
-    const result = PipelineContextSchema.safeParse({ ...validCtx, outputStyle: "verbose" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects tokenBudget <= 0", () => {
-    const result = PipelineContextSchema.safeParse({ ...validCtx, tokenBudget: 0 });
-    expect(result.success).toBe(false);
-  });
-
-  it("safeParse never throws", () => {
-    expect(() => PipelineContextSchema.safeParse(null)).not.toThrow();
-    expect(() => PipelineContextSchema.safeParse(undefined)).not.toThrow();
-    expect(() => PipelineContextSchema.safeParse(42)).not.toThrow();
-    expect(() => PipelineContextSchema.safeParse("string")).not.toThrow();
-  });
-
-  it("accepts valid metrics object", () => {
-    const result = PipelineContextSchema.safeParse({
-      ...validCtx,
-      metrics: {
-        totalMs: 5,
-        layerTimings: [{ name: "l1", ms: 2 }],
-        inputChars: 10,
-        outputChars: 10,
-        suffixInstructionTokens: 20,
-        enrichmentTokensAdded: 0,
-      },
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts null metrics", () => {
-    const result = PipelineContextSchema.safeParse({ ...validCtx, metrics: null });
-    expect(result.success).toBe(true);
-  });
-});
-
-describe("PipelineMetricsSchema", () => {
-  it("accepts valid metrics", () => {
-    const result = PipelineMetricsSchema.safeParse({
-      totalMs: 10,
-      layerTimings: [],
-      inputChars: 5,
-      outputChars: 5,
-      suffixInstructionTokens: 0,
-      enrichmentTokensAdded: 0,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects negative totalMs", () => {
-    const result = PipelineMetricsSchema.safeParse({
-      totalMs: -1,
-      layerTimings: [],
-      inputChars: 0,
-      outputChars: 0,
-      suffixInstructionTokens: 0,
-      enrichmentTokensAdded: 0,
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("TaskTypeSchema", () => {
-  it.each(["refactor", "debug", "plan", "analyze", "documentation", "generate"])("accepts %s", (t) => {
-    expect(TaskTypeSchema.safeParse(t).success).toBe(true);
-  });
-
-  it("rejects unknown type", () => {
-    expect(TaskTypeSchema.safeParse("unknown").success).toBe(false);
-  });
-});
-
-describe("OutputStyleSchema", () => {
-  it.each(["concise", "detailed", "balanced"])("accepts %s", (s) => {
-    expect(OutputStyleSchema.safeParse(s).success).toBe(true);
-  });
-
-  it("rejects unknown style", () => {
-    expect(OutputStyleSchema.safeParse("verbose").success).toBe(false);
-  });
-});
-
-describe("PilContextResponseSchema", () => {
-  const validResponse = {
-    taskType: "debug",
-    intentKind: "task",
-    outputStyle: "balanced",
-    confidence: 0.85,
-    domain: "typescript",
-    gsd_phase: "execute",
-    gsd_route_source: "ee",
-    t0_principles: [{ text: "principle one", score: 0.9 }],
-    t1_rules: ["always run tests after edit"],
-    t2_patterns: [{ text: "pattern one", score: 0.7 }],
-    retrieval_skipped_reason: null,
-    cache_hit: false,
-    inference_ms: 1234,
-    schema_version: "1.0",
-  };
-
-  it("accepts a complete valid response", () => {
-    const result = PilContextResponseSchema.safeParse(validResponse);
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts nullable taskType / intentKind / domain / gsd_phase", () => {
-    const r = PilContextResponseSchema.safeParse({
-      ...validResponse,
-      taskType: null,
-      intentKind: null,
-      domain: null,
-      gsd_phase: null,
-    });
-    expect(r.success).toBe(true);
-  });
-
-  it("rejects when outputStyle is missing (must always be provided)", () => {
-    const { outputStyle, ...rest } = validResponse;
-    void outputStyle;
-    const r = PilContextResponseSchema.safeParse(rest);
-    expect(r.success).toBe(false);
-  });
-
-  it("rejects when confidence is out of [0,1]", () => {
-    const r = PilContextResponseSchema.safeParse({ ...validResponse, confidence: 1.5 });
-    expect(r.success).toBe(false);
-  });
-
-  it("rejects when schema_version is missing", () => {
-    const { schema_version, ...rest } = validResponse;
-    void schema_version;
-    const r = PilContextResponseSchema.safeParse(rest);
-    expect(r.success).toBe(false);
-  });
-
-  it("ignores unknown fields (forward-compat for v1.1)", () => {
-    const r = PilContextResponseSchema.safeParse({ ...validResponse, whoami_directives: ["x"] });
-    expect(r.success).toBe(true);
-  });
-});
-
-describe("PipelineContext _brainData field", () => {
-  it("PipelineContextSchema accepts optional _brainData", () => {
-    const ctx = {
-      raw: "x",
-      enriched: "x",
-      taskType: null,
-      domain: null,
-      confidence: 0,
-      outputStyle: null,
-      tokenBudget: 500,
-      metrics: null,
-      layers: [],
-      _brainData: {
-        t0_principles: [{ text: "a", score: 0.8 }],
-        t1_rules: ["b"],
-        t2_patterns: [],
-        retrieval_skipped_reason: null,
-      },
-    };
-    const r = PipelineContextSchema.safeParse(ctx);
-    expect(r.success).toBe(true);
-  });
-
-  it("PipelineContextSchema accepts missing _brainData (legacy path)", () => {
-    const ctx = {
-      raw: "x",
-      enriched: "x",
-      taskType: null,
-      domain: null,
-      confidence: 0,
-      outputStyle: null,
-      tokenBudget: 500,
-      metrics: null,
-      layers: [],
-    };
-    const r = PipelineContextSchema.safeParse(ctx);
-    expect(r.success).toBe(true);
-  });
-});

package/src/pil/__tests__/scoreComplexity.test.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { scoreComplexity } from "../layer1-intent.js";
-
-// Helper: build a string of exactly `n` characters (plain ASCII 'a').
-const str = (n: number) => "a".repeat(n);
-
-describe("scoreComplexity — signal isolation", () => {
-  it("1. empty text → score 0, complexity low", () => {
-    const out = scoreComplexity({ rawText: "", taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.score).toBe(0);
-    expect(out.complexity).toBe("low");
-  });
-
-  it("2. 100-char text → score 1 (length +1), complexity low", () => {
-    const out = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.score).toBe(1);
-    expect(out.complexity).toBe("low");
-  });
-
-  it("3. 250-char text → score 2 (length +2), complexity low", () => {
-    const out = scoreComplexity({ rawText: str(250), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.score).toBe(2);
-    expect(out.complexity).toBe("low");
-  });
-
-  it("4. 800-char text → score 3 (length +3), complexity medium", () => {
-    const out = scoreComplexity({ rawText: str(800), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.score).toBe(3);
-    expect(out.complexity).toBe("medium");
-  });
-
-  it("5. text with 2 file references + 60-char length → score 2, complexity low", () => {
-    // 60 chars ensures length +1; 2 file refs → +1; total = 2 → low
-    const base = "Update foo.ts and bar.py";
-    const padded = base + " ".repeat(60 - base.length);
-    const out = scoreComplexity({ rawText: padded, taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.score).toBe(2);
-    expect(out.complexity).toBe("low");
-  });
-
-  it("6. 'fix typo in readme' → keyword -3, score negative, complexity low", () => {
-    const out = scoreComplexity({
-      rawText: "fix typo in readme",
-      taskType: null,
-      t0HitCount: 0,
-      hasMaxSprintsOne: false,
-    });
-    expect(out.score).toBeLessThan(0);
-    expect(out.complexity).toBe("low");
-  });
-
-  it("7. high-complexity keywords → score ≥ 3 (medium/high), never low", () => {
-    // 'Architecture migration plan for multi-tenant SaaS' is 49 chars → length +0,
-    // FORCE_HIGH_RE matches → +3; score = 3 → medium per the bucketing table.
-    // A longer variant (200+ chars) pushes it to high.
-    const shortOut = scoreComplexity({
-      rawText: "Architecture migration plan for multi-tenant SaaS",
-      taskType: null,
-      t0HitCount: 0,
-      hasMaxSprintsOne: false,
-    });
-    expect(shortOut.score).toBeGreaterThanOrEqual(3);
-    expect(shortOut.complexity).not.toBe("low");
-
-    // 250-char version: length +2 + FORCE_HIGH_RE +3 = 5 → medium; still not low.
-    const medOut = scoreComplexity({
-      rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(200)}`,
-      taskType: null,
-      t0HitCount: 0,
-      hasMaxSprintsOne: false,
-    });
-    expect(medOut.score).toBeGreaterThanOrEqual(5);
-    expect(medOut.complexity).not.toBe("low");
-
-    // 600-char version: length +3 + FORCE_HIGH_RE +3 = 6 → high.
-    const highOut = scoreComplexity({
-      rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(560)}`,
-      taskType: null,
-      t0HitCount: 0,
-      hasMaxSprintsOne: false,
-    });
-    expect(highOut.score).toBeGreaterThanOrEqual(6);
-    expect(highOut.complexity).toBe("high");
-  });
-
-  it("8. hasMaxSprintsOne=true with short text → score -2, low", () => {
-    const out = scoreComplexity({ rawText: str(20), taskType: null, t0HitCount: 0, hasMaxSprintsOne: true });
-    // length=0, hasMaxSprintsOne=-2 → -2
-    expect(out.score).toBe(-2);
-    expect(out.complexity).toBe("low");
-  });
-
-  it("9. t0HitCount=5 reduces score by 1", () => {
-    const baseline = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    const withHits = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 5, hasMaxSprintsOne: false });
-    expect(withHits.score).toBe(baseline.score - 1);
-  });
-
-  it("10. taskType='debug' adds +1 (medium boundary case)", () => {
-    // 250 chars → length +2, debug +1 → 3 → medium
-    const out = scoreComplexity({ rawText: str(250), taskType: "debug", t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.score).toBe(3);
-    expect(out.complexity).toBe("medium");
-  });
-});
-
-describe("scoreComplexity — integration", () => {
-  it("11a. 'fix typo in README' → low", () => {
-    const out = scoreComplexity({
-      rawText: "fix typo in README.md",
-      taskType: null,
-      t0HitCount: 0,
-      hasMaxSprintsOne: false,
-    });
-    expect(out.complexity).toBe("low");
-  });
-
-  it("11b. 'refactor the auth subsystem' (60 chars + refactor keyword) → high", () => {
-    const text = "refactor the auth subsystem".padEnd(60, " ");
-    const out = scoreComplexity({ rawText: text, taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    // length=60 → +1, refactor kw → +3 → 4 → medium, but let's check actual
-    // 'refactor' matches FORCE_HIGH_RE (+3) + length 60 chars (+1) = 4 → medium
-    // The plan says "high" but 4 is medium with the current table.
-    // Per the plan: "60 chars + refactor kw → high" — reconcile: 60 chars = +1, refactor = +3 → 4 = medium.
-    // The plan description appears to be approximate; trust the heuristic table.
-    expect(out.score).toBeGreaterThanOrEqual(3);
-    expect(["medium", "high"]).toContain(out.complexity);
-  });
-
-  it("11c. 'build a counter' (short, no keywords) → low", () => {
-    const out = scoreComplexity({ rawText: "build a counter", taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-    expect(out.complexity).toBe("low");
-  });
-});