muonroi-cli 1.4.0 → 1.4.1

package/src/reporter/index.ts

@@ -1,210 +0,0 @@
-/**
- * src/reporter/index.ts
- *
- * P8 Reporter Agent — main loop.
- *
- * Runs as a separate long-lived process: muonroi reporter --run <runId>
- * Polls the product's Discord channel for messages, classifies them,
- * dispatches to handlers, and posts replies.
- *
- * Manual smoke test:
- *   1. Start a worker: muonroi ideal "build X" in terminal A.
- *   2. In terminal B: muonroi reporter --run <runId> --product-slug <slug>
- *   3. In the product's Discord channel, type "progress?"
- *   4. Reporter should reply within 5s with a ProgressSnapshot markdown card.
- *
- * Worker process is UNTOUCHED — reporter is read-only on all worker artifacts
- * (backlog.json, sprint-plan.json, interaction_logs). Only writes:
- *   - Discord messages
- *   - reporter-budget.json (LLM spend tracking)
- *   - interaction_logs (heartbeat rows with event_type="reporter")
- */
-
-import type { ChatClient } from "../chat/types.js";
-import type { CouncilLLM } from "../council/types.js";
-import { getDatabase } from "../storage/db.js";
-import { buildUnauthorizedReply, checkStakeholder } from "./acl-check.js";
-import {
-  handleFreeformQuery,
-  handleItemQuery,
-  handleProgressQuery,
-  handleSprintQuery,
-  type ReporterDeps,
-} from "./handlers.js";
-import { classifyQuery } from "./query-router.js";
-
-// ─── Config / Deps types ──────────────────────────────────────────────────────
-
-export interface ReporterRuntimeConfig {
-  runId: string;
-  flowDir: string;
-  productSlug: string;
-  channelId: string;
-  pollIntervalMs?: number;
-  dailyLlmBudgetUsd?: number;
-  signal?: AbortSignal;
-}
-
-export interface ReporterDepsExt {
-  chat: ChatClient;
-  llm: CouncilLLM;
-  leaderModelId: string;
-}
-
-// ─── Heartbeat ────────────────────────────────────────────────────────────────
-
-const HEARTBEAT_EVERY_N_POLLS = 12; // ~60s at default 5s poll interval
-
-function emitHeartbeat(runId: string): void {
-  try {
-    const db = getDatabase();
-    db.prepare(
-      `INSERT INTO interaction_logs (session_id, event_type, event_subtype, metadata_json, created_at)
-       VALUES (?, 'reporter', 'heartbeat', '{}', ?)`,
-    ).run(runId, new Date().toISOString());
-  } catch {
-    // Best-effort — never crash the reporter over a heartbeat write failure.
-  }
-}
-
-// ─── Main loop ────────────────────────────────────────────────────────────────
-
-/**
- * Run the reporter loop until signal fires or an unrecoverable error occurs.
- *
- * Separating deps (injectable, testable) from config (runtime scalars) allows
- * unit tests to inject mock chat + llm without touching the CLI layer.
- */
-export async function runReporter(deps: ReporterDepsExt, config: ReporterRuntimeConfig): Promise<void> {
-  const { chat, llm, leaderModelId } = deps;
-  const { runId, flowDir, productSlug, channelId } = config;
-  const pollIntervalMs = config.pollIntervalMs ?? 5_000;
-  const dailyBudget = config.dailyLlmBudgetUsd ?? 0.5;
-  const signal = config.signal;
-
-  const handlerDeps: ReporterDeps = {
-    flowDir,
-    runId,
-    productSlug,
-    llm,
-    leaderModelId,
-    dailyBudget,
-  };
-
-  // Prime the cursor — skip messages that existed before reporter started.
-  let lastSeenId: string | undefined;
-  try {
-    const seed = await chat.getChannelMessages(channelId, { limit: 1 });
-    lastSeenId = seed.length > 0 ? seed[0]!.id : undefined;
-  } catch {
-    lastSeenId = undefined;
-  }
-
-  let botId: string;
-  try {
-    botId = await chat.getCurrentUserId();
-  } catch (err) {
-    throw new Error(`Reporter: failed to get bot user id — ${(err as Error).message}`);
-  }
-
-  let pollCount = 0;
-
-  while (true) {
-    if (signal?.aborted) break;
-
-    // Heartbeat
-    pollCount++;
-    if (pollCount % HEARTBEAT_EVERY_N_POLLS === 0) {
-      emitHeartbeat(runId);
-    }
-
-    // Fetch new messages
-    let messages;
-    try {
-      messages = await chat.getChannelMessages(channelId, {
-        afterId: lastSeenId,
-        limit: 50,
-      });
-    } catch (err) {
-      console.error(`[reporter] Discord poll error: ${(err as Error).message}`);
-      await sleep(pollIntervalMs, signal);
-      continue;
-    }
-
-    // Process messages in chronological order (Discord returns newest-first).
-    const ordered = [...messages].reverse();
-
-    for (const msg of ordered) {
-      if (signal?.aborted) break;
-
-      // Skip bot's own messages to avoid reply loops.
-      if (msg.author.id === botId) continue;
-
-      // Update cursor before handling (so a crash doesn't re-process).
-      lastSeenId = msg.id;
-
-      // ACL check
-      let aclResult;
-      try {
-        aclResult = await checkStakeholder(productSlug, msg.author.id);
-      } catch {
-        aclResult = { authorized: false as const, stakeholderUsernames: [] as string[] };
-      }
-
-      if (!aclResult.authorized) {
-        const reply = buildUnauthorizedReply(aclResult);
-        await chat.postMessage(channelId, reply).catch((e: Error) => {
-          console.error(`[reporter] postMessage (acl deny) failed: ${e.message}`);
-        });
-        continue;
-      }
-
-      // Classify + dispatch
-      const classified = classifyQuery(msg.content);
-      let reply: string;
-
-      try {
-        switch (classified.kind) {
-          case "progress":
-            reply = await handleProgressQuery(handlerDeps);
-            break;
-          case "sprint":
-            reply = await handleSprintQuery(handlerDeps, classified.sprintNumber ?? 1);
-            break;
-          case "item":
-            reply = await handleItemQuery(handlerDeps, classified.itemQuery ?? "");
-            break;
-          default:
-            reply = await handleFreeformQuery(handlerDeps, msg.content);
-            break;
-        }
-      } catch (err) {
-        reply = `Reporter encountered an error: ${(err as Error).message}`;
-      }
-
-      await chat.postMessage(channelId, reply).catch((e: Error) => {
-        console.error(`[reporter] postMessage failed: ${e.message}`);
-      });
-    }
-
-    // Update cursor to the last message in the batch even if we skipped bot msgs.
-    if (ordered.length > 0) {
-      lastSeenId = ordered[ordered.length - 1]!.id;
-    }
-
-    if (signal?.aborted) break;
-    await sleep(pollIntervalMs, signal);
-  }
-}
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-  });
-}

package/src/reporter/query-router.ts

@@ -1,51 +0,0 @@
-/**
- * src/reporter/query-router.ts
- *
- * Classifies a user's Discord message into a query kind using deterministic
- * pattern matching — no LLM, fast, zero cost.
- */
-
-export type QueryKind = "progress" | "sprint" | "item" | "freeform";
-
-export interface ClassifiedQuery {
-  kind: QueryKind;
-  /** Populated when kind="sprint" — the sprint number requested. */
-  sprintNumber?: number;
-  /** Populated when kind="item" — the user's item search string. */
-  itemQuery?: string;
-  rawText: string;
-}
-
-const PROGRESS_RE =
-  /^(progress|status|ti[eế]n\s*[đd][oộ]|b[aá]o\s*c[aá]o|how\s+is\s+it\s+going|how's\s+it\s+going|\/status)\??\s*$/iu;
-
-const SPRINT_NUMBER_RE = /^(?:show\s+)?sprint\s+(\d+)/i;
-
-// Matches: "show item X", "tell me about item X", "explain feature X", "show task X"
-const ITEM_RE = /^(?:show|tell(?:\s+me\s+about)?|explain)\s+(?:item|task|feature)\s+(.+)/i;
-
-/**
- * Classify a raw user message text into a QueryKind.
- *
- * Priority: progress > sprint > item > freeform
- */
-export function classifyQuery(text: string): ClassifiedQuery {
-  const trimmed = text.trim();
-
-  if (PROGRESS_RE.test(trimmed)) {
-    return { kind: "progress", rawText: trimmed };
-  }
-
-  const sprintMatch = SPRINT_NUMBER_RE.exec(trimmed);
-  if (sprintMatch) {
-    return { kind: "sprint", sprintNumber: Number(sprintMatch[1]), rawText: trimmed };
-  }
-
-  const itemMatch = ITEM_RE.exec(trimmed);
-  if (itemMatch) {
-    // Group [1] is the query text after "item|task|feature <query>"
-    return { kind: "item", itemQuery: itemMatch[1]?.trim(), rawText: trimmed };
-  }
-
-  return { kind: "freeform", rawText: trimmed };
-}

package/src/router/__tests__/step-router.test.ts

@@ -1,150 +0,0 @@
-/**
- * Tests for Step-Aware Model Routing (SAMR).
- */
-
-import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
-import { loadCatalog, MODELS } from "../../models/registry.js";
-import { decideStepRouting, getStepRouterConfig, type StepRouterConfig } from "../step-router.js";
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function mockConfig(overrides: Partial<StepRouterConfig> = {}): StepRouterConfig {
-  return {
-    enabled: true,
-    toolExecutionTier: "fast",
-    premiumSynthesis: false,
-    ...overrides,
-  };
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe("decideStepRouting", () => {
-  beforeAll(async () => {
-    await loadCatalog();
-  });
-
-  it("returns phase2ModelId=null when disabled", () => {
-    const decision = decideStepRouting("claude-sonnet-4-6", "anthropic", mockConfig({ enabled: false }));
-    expect(decision.phase2ModelId).toBeNull();
-    expect(decision.reason).toContain("disabled");
-  });
-
-  it("returns phase2ModelId=null when phase 1 model is already fast tier", () => {
-    const fastModel = MODELS.find((m) => m.tier === "fast" && m.provider);
-    if (!fastModel?.provider) return;
-
-    const decision = decideStepRouting(fastModel.id, fastModel.provider, mockConfig({ toolExecutionTier: "fast" }));
-    expect(decision.phase1ModelId).toBe(fastModel.id);
-  });
-
-  it("returns a fast execution model for premium phase 1", () => {
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-    if (!premiumModel?.provider) return;
-
-    const decision = decideStepRouting(premiumModel.id, premiumModel.provider, mockConfig());
-
-    if (decision.phase2ModelId) {
-      expect(decision.phase2ModelId).not.toBe(premiumModel.id);
-      expect(decision.reason).toContain("→");
-    }
-  });
-
-  it("respects toolExecutionTier setting", () => {
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-    if (!premiumModel?.provider) return;
-
-    const balancedCfg = mockConfig({ toolExecutionTier: "balanced" });
-    const decision = decideStepRouting(premiumModel.id, premiumModel.provider, balancedCfg);
-
-    if (decision.phase2ModelId) {
-      const execModel = MODELS.find((m) => m.id === decision.phase2ModelId);
-      expect(execModel?.tier).toBe("balanced");
-    }
-  });
-
-  it("phase1ModelId is always preserved", () => {
-    const decision = decideStepRouting("claude-sonnet-4-6", "anthropic", mockConfig({ enabled: false }));
-    expect(decision.phase1ModelId).toBe("claude-sonnet-4-6");
-  });
-});
-
-describe("getStepRouterConfig", () => {
-  it("returns a well-formed config (values depend on user-settings)", () => {
-    const config = getStepRouterConfig();
-    expect(typeof config.enabled).toBe("boolean");
-    expect(["fast", "balanced"]).toContain(config.toolExecutionTier);
-    expect(typeof config.premiumSynthesis).toBe("boolean");
-  });
-});
-
-describe("default-off safety", () => {
-  // SAMR is opt-in: default off until Phase1→Phase2 transition is covered
-  // by an integration test against the real AI SDK. This test asserts the
-  // DEFAULT_CONFIG behavior by passing { enabled: false } explicitly — what
-  // a user with no stepRouter setting would get.
-  it("explicit enabled=false returns phase2ModelId=null", () => {
-    const decision = decideStepRouting("claude-opus-4-7", "anthropic", mockConfig({ enabled: false }));
-    expect(decision.phase2ModelId).toBeNull();
-    expect(decision.reason).toContain("disabled");
-  });
-});
-
-describe("resolveExecutionModel disability checks (Phase 19)", () => {
-  beforeAll(async () => {
-    await loadCatalog();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("does not return same-provider candidate when provider is disabled", async () => {
-    const settingsMod = await import("../../utils/settings.js");
-    vi.spyOn(settingsMod, "isProviderDisabled").mockImplementation((p) => p === "anthropic");
-    vi.spyOn(settingsMod, "isModelDisabled").mockReturnValue(false);
-
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider === "anthropic");
-    if (!premiumModel) return; // skip if no anthopic premium model loaded
-
-    const decision = decideStepRouting(premiumModel.id, "anthropic", mockConfig());
-    if (decision.phase2ModelId) {
-      const execModel = MODELS.find((m) => m.id === decision.phase2ModelId);
-      expect(execModel?.provider).not.toBe("anthropic");
-    } else {
-      // No alternative model found — acceptable (disabled provider, no cross-provider fallback)
-      expect(decision.phase2ModelId).toBeNull();
-    }
-  });
-
-  it("does not return a model that is in disabledModels", async () => {
-    const settingsMod = await import("../../utils/settings.js");
-    vi.spyOn(settingsMod, "isProviderDisabled").mockReturnValue(false);
-
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-    if (!premiumModel) return;
-    const fastModel = MODELS.find((m) => m.tier === "fast" && m.provider === premiumModel.provider);
-    if (!fastModel) return;
-
-    vi.spyOn(settingsMod, "isModelDisabled").mockImplementation((id) => id === fastModel.id);
-
-    const decision = decideStepRouting(premiumModel.id, premiumModel.provider!, mockConfig());
-    expect(decision.phase2ModelId).not.toBe(fastModel.id);
-  });
-
-  it("falls through to cross-provider when same-provider model is disabled", async () => {
-    const settingsMod = await import("../../utils/settings.js");
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider === "anthropic");
-    if (!premiumModel) return;
-    const sameFast = MODELS.find((m) => m.tier === "fast" && m.provider === "anthropic");
-    if (!sameFast) return;
-
-    // Disable the same-provider fast model; allow cross-provider
-    vi.spyOn(settingsMod, "isModelDisabled").mockImplementation((id) => id === sameFast.id);
-    vi.spyOn(settingsMod, "isProviderDisabled").mockReturnValue(false);
-
-    const decision = decideStepRouting(premiumModel.id, "anthropic", mockConfig());
-    // Either a different model is chosen or null — but NOT sameFast.id
-    expect(decision.phase2ModelId).not.toBe(sameFast.id);
-  });
-});

package/src/router/classifier/grammars.ts

@@ -1,17 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-
-export type GrammarId = "typescript" | "python";
-
-export const GRAMMARS: Record<GrammarId, string> = {
-  typescript: "tree-sitter-typescript/tree-sitter-typescript.wasm",
-  python: "tree-sitter-python/tree-sitter-python.wasm",
-};
-
-export async function loadGrammarBytes(id: GrammarId): Promise<Uint8Array> {
-  const rel = GRAMMARS[id];
-  // Resolve under node_modules -- works under Bun + Node
-  const p = path.join(process.cwd(), "node_modules", rel);
-  const buf = await fs.readFile(p);
-  return new Uint8Array(buf);
-}

package/src/router/classifier/index.test.ts

@@ -1,33 +0,0 @@
-import { beforeAll, describe, expect, it } from "vitest";
-import { classify, warm } from "./index.js";
-
-describe("classify orchestrator", () => {
-  beforeAll(async () => {
-    await warm();
-  }, 30_000);
-
-  it("returns hot for generic greeting (short message fast path)", () => {
-    const result = classify("hi");
-    expect(result.tier).toBe("hot");
-    expect(result.confidence).toBe(0.6);
-    expect(result.reason).toBe("regex:short-message");
-  });
-
-  it("returns hot for regex-matchable prompts", () => {
-    const result = classify("create a file called hello.ts");
-    expect(result.tier).toBe("hot");
-    expect(result.confidence).toBeGreaterThanOrEqual(0.55);
-  });
-
-  it("threshold gating: prompt scoring 0.6 returns abstain when threshold is 0.8", () => {
-    // "explain something" matches regex with ~0.70 confidence
-    const result = classify("explain what this does", 0.8);
-    expect(result.tier).toBe("abstain");
-  });
-
-  it("returns hot for tree-sitter-detectable code prompts", () => {
-    const result = classify("```ts\nconst x: number = 1;\n```");
-    expect(result.tier).toBe("hot");
-    expect(result.confidence).toBeGreaterThanOrEqual(0.55);
-  });
-});

package/src/router/classifier/index.ts

@@ -1,21 +0,0 @@
-// FORBIDDEN imports (enforced by tests/arch/no-network-in-classifier.test.ts):
-//   node:net | node:http(s) | undici | axios | ../ee/* | global-fetch
-import type { ClassifierResult } from "../types.js";
-import { matchRegex } from "./regex.js";
-import { initTreeSitter, lazyTreeSitter } from "./tree-sitter.js";
-
-export function classify(prompt: string, threshold = 0.55): ClassifierResult {
-  const r = matchRegex(prompt);
-  if (r.confidence >= threshold) return r;
-  const t = lazyTreeSitter(prompt);
-  if (t.confidence >= threshold) return t;
-  return {
-    tier: "abstain",
-    confidence: Math.max(r.confidence, t.confidence),
-    reason: "low-confidence",
-  };
-}
-
-export async function warm(): Promise<void> {
-  await initTreeSitter(["typescript", "python"]);
-}

package/src/router/classifier/regex.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { matchRegex } from "./regex.js";
-
-describe("matchRegex", () => {
-  it('classifies "create file foo.ts with hello world" with confidence >= 0.55', () => {
-    const result = matchRegex("create file foo.ts with hello world");
-    expect(result.confidence).toBeGreaterThanOrEqual(0.55);
-    expect(result.reason).toMatch(/^regex:/);
-  });
-
-  it('classifies "hi how are you" as short message with moderate confidence', () => {
-    const result = matchRegex("hi how are you");
-    expect(result.confidence).toBe(0.6);
-    expect(result.reason).toBe("regex:short-message");
-    expect(result.tierHint).toBe("fast");
-  });
-
-  describe("seed intents (>= 7 patterns at >= 0.55 confidence)", () => {
-    const seeds = [
-      { prompt: "create a file called app.ts", intent: "create-file" },
-      // PIL-L6 fix — "fix the bug" now correctly routes to debug, not edit.
-      // Use a pure-edit prompt without bug/error/fix-the-X cues here.
-      { prompt: "edit the main.ts file to change the layout", intent: "edit" },
-      { prompt: "run the test command", intent: "run-command" },
-      { prompt: "explain what this code does", intent: "explain" },
-      { prompt: "refactor the auth module", intent: "refactor" },
-      { prompt: "search for the function declaration", intent: "search" },
-      { prompt: "install package express", intent: "install" },
-    ];
-
-    for (const { prompt, intent } of seeds) {
-      it(`matches "${prompt}" as regex:${intent} with >= 0.55`, () => {
-        const result = matchRegex(prompt);
-        expect(result.confidence).toBeGreaterThanOrEqual(0.55);
-        expect(result.reason).toBe(`regex:${intent}`);
-      });
-    }
-  });
-
-  it('returns tier "hot" for high confidence matches', () => {
-    const result = matchRegex("create a file called foo.ts");
-    expect(result.tier).toBe("hot");
-  });
-
-  it('returns tier "abstain" for long complex input', () => {
-    const result = matchRegex(
-      "I need you to analyze the distributed system architecture across all microservices and identify race conditions in the payment processing pipeline",
-    );
-    expect(result.tier).toBe("abstain");
-  });
-});