muonroi-cli 1.2.0

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "muonroi-cli",
+  "version": "1.2.0",
+  "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "muonroi-cli": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "tsc",
+    "build:binary": "bun build --compile --outfile ./dist/muonroi-cli-standalone ./src/index.ts",
+    "start": "bun run dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "bunx vitest run",
+    "test:watch": "bunx vitest",
+    "lint": "biome check src/",
+    "format": "biome format src/",
+    "format:fix": "biome format --write src/",
+    "lint:fix": "biome check --fix src/",
+    "pre-commit": "lint-staged",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,mjs,cjs,json}": "biome check --write --no-errors-on-unmatched"
+  },
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "keywords": [
+    "cli",
+    "agent",
+    "ai",
+    "coding",
+    "terminal",
+    "opentui"
+  ],
+  "author": "muonroi",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/anthropic": "3.0.72",
+    "@ai-sdk/google": "3.0.65",
+    "@ai-sdk/mcp": "1.0.37",
+    "@ai-sdk/openai": "3.0.54",
+    "@ai-sdk/openai-compatible": "2.0.42",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@npmcli/arborist": "^9.4.3",
+    "@opentui/core": "0.1.107",
+    "@opentui/react": "0.1.107",
+    "@qdrant/js-client-rest": "1.17.0",
+    "ai": "6.0.169",
+    "commander": "^12.1.0",
+    "diff": "^8.0.3",
+    "keytar": "^7.9.0",
+    "ollama-ai-provider-v2": "1.5.5",
+    "proper-lockfile": "^4.1.2",
+    "react": "19.2.5",
+    "ripgrep": "^0.3.1",
+    "semver": "^7.7.4",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-typescript": "^0.23.2",
+    "vscode-jsonrpc": "8.2.1",
+    "vscode-languageserver-types": "3.17.5",
+    "web-tree-sitter": "0.26.8",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.13",
+    "@types/diff": "^8.0.0",
+    "@types/node": "^22.19.15",
+    "@types/npmcli__arborist": "^6.3.3",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^19.2.14",
+    "@types/semver": "^7.7.1",
+    "husky": "9.1.7",
+    "lint-staged": "16.4.0",
+    "typescript": "5.9.3",
+    "vitest": "4.1.5"
+  },
+  "engines": {
+    "bun": ">=1.3.13",
+    "node": ">=20.0.0"
+  },
+  "preferGlobal": true
+}

package/src/__test-stubs__/ee-server.ts

@@ -0,0 +1,173 @@
+/**
+ * Local HTTP stub server for Experience Engine endpoints.
+ * Reused by plans 03/07/08 -- do not couple to a single test file.
+ *
+ * Uses Node http module for compatibility with vitest (runs under Node, not Bun).
+ */
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+
+export interface StubConfig {
+  port?: number;
+  routeModel?: (req: any) => any;
+  coldRoute?: (req: any) => any;
+  intercept?: (req: any) => any;
+  posttool?: (req: any) => void;
+  feedback?: (req: any) => void;
+  touch?: (id: string) => void;
+  extract?: (req: any) => any;
+  promptStale?: (req: any) => any;
+  health?: () => boolean;
+  latencyMs?: number;
+}
+
+export interface StubHandle {
+  server: Server;
+  port: number;
+  stop(): Promise<void>;
+  calls: Record<string, any[]>;
+}
+
+function readBody(req: IncomingMessage): Promise<any> {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (c: Buffer) => chunks.push(c));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve({});
+      }
+    });
+    req.on("error", () => resolve({}));
+  });
+}
+
+function sendJson(res: ServerResponse, data: any, status = 200): void {
+  const body = JSON.stringify(data);
+  res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) });
+  res.end(body);
+}
+
+function sendText(res: ServerResponse, text: string, status = 200): void {
+  res.writeHead(status, { "Content-Type": "text/plain" });
+  res.end(text);
+}
+
+export async function startStubEEServer(cfg: StubConfig = {}): Promise<StubHandle> {
+  const calls: Record<string, any[]> = {
+    intercept: [],
+    posttool: [],
+    routeModel: [],
+    coldRoute: [],
+    feedback: [],
+    touch: [],
+    extract: [],
+    promptStale: [],
+  };
+
+  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const url = new URL(req.url ?? "/", `http://localhost`);
+
+    if (cfg.latencyMs) {
+      await new Promise((r) => setTimeout(r, cfg.latencyMs));
+    }
+
+    // Health endpoint
+    if (url.pathname === "/health") {
+      const ok = cfg.health ? cfg.health() : true;
+      sendJson(res, { ok }, ok ? 200 : 503);
+      return;
+    }
+
+    const body = req.method === "POST" ? await readBody(req) : {};
+
+    // Route model (warm path)
+    if (url.pathname === "/api/route-model") {
+      calls.routeModel.push(body);
+      const r = cfg.routeModel?.(body);
+      if (r) {
+        sendJson(res, r);
+      } else {
+        sendText(res, "no handler", 500);
+      }
+      return;
+    }
+
+    // Cold route
+    if (url.pathname === "/api/cold-route") {
+      calls.coldRoute.push(body);
+      const r = cfg.coldRoute?.(body);
+      if (r) {
+        sendJson(res, r);
+      } else {
+        sendText(res, "no handler", 500);
+      }
+      return;
+    }
+
+    // Intercept
+    if (url.pathname === "/api/intercept") {
+      calls.intercept.push(body);
+      const r = cfg.intercept?.(body) ?? { decision: "allow" };
+      sendJson(res, r);
+      return;
+    }
+
+    // PostTool
+    if (url.pathname === "/api/posttool") {
+      calls.posttool.push(body);
+      cfg.posttool?.(body);
+      sendText(res, "ok");
+      return;
+    }
+
+    // Feedback
+    if (url.pathname === "/api/feedback") {
+      calls.feedback.push(body);
+      cfg.feedback?.(body);
+      sendText(res, "ok");
+      return;
+    }
+
+    // Principle touch
+    if (url.pathname.startsWith("/api/principle/touch")) {
+      const id = url.searchParams.get("id") ?? body?.id;
+      calls.touch.push(id);
+      cfg.touch?.(id);
+      sendText(res, "ok");
+      return;
+    }
+
+    // Extract
+    if (url.pathname === "/api/extract") {
+      calls.extract.push(body);
+      const r = cfg.extract?.(body) ?? { ok: true, mistakes: 0 };
+      sendJson(res, r);
+      return;
+    }
+
+    // Prompt-stale reconciliation
+    if (url.pathname === "/api/prompt-stale") {
+      calls.promptStale.push(body);
+      const r = cfg.promptStale?.(body) ?? { ok: true, unused: [], irrelevant: [], expired: [] };
+      sendJson(res, r);
+      return;
+    }
+
+    sendText(res, "not found", 404);
+  });
+
+  return new Promise((resolve) => {
+    server.listen(cfg.port ?? 0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolve({
+        server,
+        port,
+        stop: () => new Promise<void>((r) => server.close(() => r())),
+        calls,
+      });
+    });
+  });
+}

package/src/billing/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Phase 4: LemonSqueezy subscription, webhook handler, tier management.
+ * This barrel will export billing functionality once implemented.
+ */
+export {};

package/src/bun-sqlite.d.ts

@@ -0,0 +1,15 @@
+declare module "bun:sqlite" {
+  export interface SQLiteQuery {
+    get(binding?: unknown): unknown;
+    all(binding?: unknown): unknown[];
+  }
+
+  export class Database {
+    constructor(filename?: string, options?: { create?: boolean; strict?: boolean; readonly?: boolean });
+    exec(sql: string): void;
+    run(sql: string, binding?: unknown): unknown;
+    query(sql: string): SQLiteQuery;
+    transaction<T>(fn: () => T): () => T;
+    close(): void;
+  }
+}

package/src/cloud/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Phase 4: Cloud EE client, auth, migration, pricing.
+ * This barrel will export cloud-mode functionality once implemented.
+ */
+export {};

package/src/daemon/scheduler.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+async function importSchedulerModule(mocks: {
+  list: ReturnType<typeof vi.fn>;
+  touchLastRunAt: ReturnType<typeof vi.fn>;
+  startDetachedHeadlessRun?: ReturnType<typeof vi.fn>;
+  getScheduleDaemonStatus?: ReturnType<typeof vi.fn>;
+  writeScheduleDaemonPid?: ReturnType<typeof vi.fn>;
+  removeScheduleDaemonPid?: ReturnType<typeof vi.fn>;
+  cronMatchesDate?: ReturnType<typeof vi.fn>;
+}) {
+  vi.resetModules();
+
+  const startDetachedHeadlessRun = mocks.startDetachedHeadlessRun ?? vi.fn(async () => 9876);
+  const getScheduleDaemonStatus = mocks.getScheduleDaemonStatus ?? vi.fn(async () => ({ running: false, pid: null }));
+  const writeScheduleDaemonPid = mocks.writeScheduleDaemonPid ?? vi.fn(async () => {});
+  const removeScheduleDaemonPid = mocks.removeScheduleDaemonPid ?? vi.fn(async () => {});
+  const cronMatchesDate = mocks.cronMatchesDate ?? vi.fn(() => true);
+
+  vi.doMock("../tools/schedule", () => ({
+    ScheduleManager: class {
+      list = mocks.list;
+      touchLastRunAt = mocks.touchLastRunAt;
+    },
+    cronMatchesDate,
+    getScheduleDaemonStatus,
+    getScheduleRunLogPath: (id: string) => `/tmp/${id}.log`,
+    removeScheduleDaemonPid,
+    startDetachedHeadlessRun,
+    writeScheduleDaemonPid,
+  }));
+
+  const mod = await import("./scheduler");
+  return {
+    SchedulerDaemon: mod.SchedulerDaemon,
+    startDetachedHeadlessRun,
+    getScheduleDaemonStatus,
+    writeScheduleDaemonPid,
+    removeScheduleDaemonPid,
+    cronMatchesDate,
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  vi.resetModules();
+});
+
+describe("SchedulerDaemon", () => {
+  it("fires matching recurring schedules and records lastRunAt", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-25T09:00:00"));
+
+    const list = vi.fn(async () => [
+      {
+        id: "daily-security-scan",
+        name: "Daily Security Scan",
+        instruction: "Scan the repo.",
+        cron: "0 9 * * 1-5",
+        model: "muonroi-test-model",
+        directory: "/repo",
+        enabled: true,
+        maxToolRounds: 400,
+        createdAt: "2026-03-25T08:00:00.000Z",
+        updatedAt: "2026-03-25T08:00:00.000Z",
+      },
+    ]);
+    const touchLastRunAt = vi.fn(async () => {});
+
+    const { SchedulerDaemon, startDetachedHeadlessRun, writeScheduleDaemonPid, removeScheduleDaemonPid } =
+      await importSchedulerModule({
+        list,
+        touchLastRunAt,
+      });
+
+    const daemon = new SchedulerDaemon();
+    await daemon.start();
+
+    expect(writeScheduleDaemonPid).toHaveBeenCalledWith(process.pid);
+    expect(startDetachedHeadlessRun).toHaveBeenCalledWith({
+      instruction: "Scan the repo.",
+      directory: "/repo",
+      model: "muonroi-test-model",
+      maxToolRounds: 400,
+      logPath: "/tmp/daily-security-scan.log",
+    });
+    expect(touchLastRunAt).toHaveBeenCalledWith("daily-security-scan", expect.any(Date));
+
+    await daemon.stop();
+    expect(removeScheduleDaemonPid).toHaveBeenCalled();
+  });
+
+  it("does not refire a schedule that already ran in the same minute", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-25T09:00:30.000Z"));
+
+    const list = vi.fn(async () => [
+      {
+        id: "daily-security-scan",
+        name: "Daily Security Scan",
+        instruction: "Scan the repo.",
+        cron: "* * * * *",
+        model: "muonroi-test-model",
+        directory: "/repo",
+        enabled: true,
+        maxToolRounds: 400,
+        lastRunAt: "2026-03-25T09:00:00.000Z",
+        createdAt: "2026-03-25T08:00:00.000Z",
+        updatedAt: "2026-03-25T09:00:00.000Z",
+      },
+    ]);
+    const touchLastRunAt = vi.fn(async () => {});
+
+    const { SchedulerDaemon, startDetachedHeadlessRun } = await importSchedulerModule({
+      list,
+      touchLastRunAt,
+    });
+
+    const daemon = new SchedulerDaemon();
+    await daemon.start();
+
+    expect(startDetachedHeadlessRun).not.toHaveBeenCalled();
+    expect(touchLastRunAt).not.toHaveBeenCalled();
+
+    await daemon.stop();
+  });
+});

package/src/daemon/scheduler.ts

@@ -0,0 +1,152 @@
+import {
+  cronMatchesDate,
+  getScheduleDaemonStatus,
+  getScheduleRunLogPath,
+  removeScheduleDaemonPid,
+  type ScheduleDaemonStatus,
+  ScheduleManager,
+  type StoredSchedule,
+  startDetachedHeadlessRun,
+  writeScheduleDaemonPid,
+} from "../tools/schedule";
+import { getDefaultEEClient } from "../ee/intercept.js";
+
+export class SchedulerDaemon {
+  private readonly schedules = new ScheduleManager();
+  private tickTimer: ReturnType<typeof setInterval> | null = null;
+  private shuttingDown = false;
+  private tickRunning = false;
+  private signalHandlersInstalled = false;
+  private tickCount = 0;
+  private static readonly EVOLVE_INTERVAL_TICKS = 360; // 6 hours at 60s/tick
+
+  async start(): Promise<void> {
+    const status = await getScheduleDaemonStatus();
+    if (status.running && status.pid !== process.pid) {
+      throw new Error(`Schedule daemon is already running (pid ${status.pid}).`);
+    }
+
+    await writeScheduleDaemonPid(process.pid);
+    this.installSignalHandlers();
+
+    const allSchedules = await this.schedules.list();
+    const recurringCount = allSchedules.filter((schedule) => schedule.enabled && schedule.cron).length;
+    console.error(`Schedule daemon started (pid ${process.pid}). Watching ${recurringCount} recurring schedule(s).`);
+
+    await this.tick();
+    this.tickTimer = setInterval(() => {
+      void this.tick();
+    }, 60_000);
+  }
+
+  async stop(): Promise<void> {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+
+    await removeScheduleDaemonPid();
+  }
+
+  async getStatus(): Promise<ScheduleDaemonStatus> {
+    return getScheduleDaemonStatus();
+  }
+
+  private installSignalHandlers(): void {
+    if (this.signalHandlersInstalled) return;
+    this.signalHandlersInstalled = true;
+
+    const shutdown = (signal: NodeJS.Signals) => {
+      console.error(`Schedule daemon stopping (${signal}).`);
+      void this.stop().finally(() => {
+        process.exit(0);
+      });
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+
+  private async tick(): Promise<void> {
+    if (this.tickRunning || this.shuttingDown) return;
+    this.tickRunning = true;
+
+    try {
+      this.tickCount++;
+      if (this.tickCount % SchedulerDaemon.EVOLVE_INTERVAL_TICKS === 0) {
+        getDefaultEEClient()
+          .evolve("daemon-periodic")
+          .then((res) => {
+            if (res) console.error("Daemon evolve completed.");
+          })
+          .catch((err: unknown) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Daemon evolve failed: ${msg}`);
+          });
+      }
+
+      const now = new Date();
+      const schedules = await this.schedules.list();
+
+      for (const schedule of schedules) {
+        if (!shouldRunScheduleNow(schedule, now)) {
+          continue;
+        }
+
+        try {
+          const pid = await startDetachedHeadlessRun({
+            instruction: schedule.instruction,
+            directory: schedule.directory,
+            model: schedule.model,
+            maxToolRounds: schedule.maxToolRounds,
+            logPath: getScheduleRunLogPath(schedule.id),
+          });
+
+          await this.schedules.touchLastRunAt(schedule.id, now);
+          const pidText = pid ? ` (pid ${pid})` : "";
+          console.error(`Fired schedule ${schedule.id}${pidText}.`);
+        } catch (err: unknown) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`Schedule ${schedule.id} failed: ${msg}`);
+        }
+      }
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Schedule daemon tick failed: ${message}`);
+    } finally {
+      this.tickRunning = false;
+    }
+  }
+}
+
+function shouldRunScheduleNow(schedule: StoredSchedule, now: Date): boolean {
+  if (!schedule.enabled || !schedule.cron) {
+    return false;
+  }
+  if (!cronMatchesDate(schedule.cron, now)) {
+    return false;
+  }
+  if (!schedule.lastRunAt) {
+    return true;
+  }
+
+  const last = new Date(schedule.lastRunAt);
+  if (Number.isNaN(last.getTime())) {
+    return true;
+  }
+
+  return !isSameMinute(last, now);
+}
+
+function isSameMinute(a: Date, b: Date): boolean {
+  return (
+    a.getFullYear() === b.getFullYear() &&
+    a.getMonth() === b.getMonth() &&
+    a.getDate() === b.getDate() &&
+    a.getHours() === b.getHours() &&
+    a.getMinutes() === b.getMinutes()
+  );
+}