muonroi-cli 1.4.0 → 1.5.0

package/src/flow/parser.ts

@@ -1,78 +0,0 @@
-/**
- * Heading-delimited section parser/writer for .muonroi-flow/ markdown files.
- *
- * All reads are tolerant: missing sections return undefined, empty input returns
- * empty map, malformed input never throws. All writes are deterministic: same
- * sections produce same output.
- */
-
-export interface SectionMap {
-  sections: Map<string, string>;
-  preamble: string;
-}
-
-/**
- * Parse heading-delimited markdown into a SectionMap.
- * Splits on `## Heading` lines. Content before the first heading is the preamble.
- * Empty or malformed input returns empty map with empty preamble (never throws).
- */
-export function parseSections(markdown: string): SectionMap {
-  const sections = new Map<string, string>();
-  let preamble = "";
-  let currentHeading: string | null = null;
-  let currentLines: string[] = [];
-
-  const lines = markdown.split("\n");
-
-  for (const line of lines) {
-    const match = line.match(/^##\s+(.+)$/);
-    if (match) {
-      if (currentHeading !== null) {
-        sections.set(currentHeading, currentLines.join("\n").trim());
-      } else {
-        preamble = currentLines.join("\n").trim();
-      }
-      currentHeading = match[1].trim();
-      currentLines = [];
-    } else {
-      currentLines.push(line);
-    }
-  }
-
-  // Flush last section or preamble
-  if (currentHeading !== null) {
-    sections.set(currentHeading, currentLines.join("\n").trim());
-  } else {
-    preamble = currentLines.join("\n").trim();
-  }
-
-  return { sections, preamble };
-}
-
-/**
- * Serialize a SectionMap back to heading-delimited markdown.
- * Preamble comes first, then headings in the specified order.
- * Headings not in the order array are appended at the end.
- */
-export function serializeSections(map: SectionMap, order?: string[]): string {
-  const parts: string[] = [];
-  if (map.preamble) parts.push(map.preamble);
-
-  const headings = order ? [...new Set([...order, ...map.sections.keys()])] : [...map.sections.keys()];
-
-  for (const h of headings) {
-    const content = map.sections.get(h);
-    if (content !== undefined) {
-      parts.push(`## ${h}\n\n${content}`);
-    }
-  }
-
-  return `${parts.join("\n\n")}\n`;
-}
-
-/**
- * Tolerant getter — returns undefined for missing sections, never throws.
- */
-export function getSection(map: SectionMap, heading: string): string | undefined {
-  return map.sections.get(heading);
-}

package/src/flow/run-manager.ts

@@ -1,162 +0,0 @@
-/**
- * Create/load/update runs/<run-id>/ subdirectories in .muonroi-flow/.
- *
- * Run IDs are sortable (Date.now().toString(36)) + collision-safe
- * (randomBytes(2).toString('hex')).
- */
-
-import { randomBytes } from "node:crypto";
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { readArtifact, writeArtifact } from "./artifact-io.js";
-import type { SectionMap } from "./parser.js";
-
-export interface RunState {
-  id: string;
-  roadmap: SectionMap;
-  state: SectionMap;
-  delegations: SectionMap;
-  grayAreas: SectionMap;
-  iterations: SectionMap;
-  manifest: SectionMap;
-}
-
-const RUN_FILES = [
-  "roadmap.md",
-  "state.md",
-  "delegations.md",
-  "gray-areas.md",
-  "iterations.md",
-  "manifest.md",
-] as const;
-
-/**
- * Generate a sortable, human-readable, collision-safe run ID.
- * Format: Date.now().toString(36) + randomBytes(2).toString('hex')
- */
-function generateRunId(): string {
-  return Date.now().toString(36) + randomBytes(2).toString("hex");
-}
-
-/**
- * Create a new run directory with 4 empty .md files.
- * Initializes state.md with Resume Digest and Experience Snapshot headings.
- */
-export async function createRun(flowDir: string): Promise<RunState> {
-  const id = generateRunId();
-  const runDir = path.join(flowDir, "runs", id);
-  await fs.mkdir(runDir, { recursive: true });
-
-  // Create empty files
-  for (const file of RUN_FILES) {
-    await fs.writeFile(path.join(runDir, file), "", "utf8");
-  }
-
-  // Initialize state.md with required headings
-  const stateMap: SectionMap = {
-    preamble: "",
-    sections: new Map([
-      ["Resume Digest", ""],
-      ["Experience Snapshot", ""],
-    ]),
-  };
-  await writeArtifact(path.join(flowDir, "runs", id), "state.md", stateMap);
-
-  // Initialize iterations.md
-  const iterationsMap: SectionMap = {
-    preamble: "",
-    sections: new Map([["Iterations", ""]]),
-  };
-  await writeArtifact(path.join(flowDir, "runs", id), "iterations.md", iterationsMap);
-
-  // Initialize manifest.md
-  const manifestMap: SectionMap = {
-    preamble: "",
-    sections: new Map([["Manifest", ""]]),
-  };
-  await writeArtifact(path.join(flowDir, "runs", id), "manifest.md", manifestMap);
-
-  // Return the initial RunState
-  const emptyMap: SectionMap = { preamble: "", sections: new Map() };
-  return {
-    id,
-    roadmap: emptyMap,
-    state: stateMap,
-    delegations: emptyMap,
-    grayAreas: emptyMap,
-    iterations: iterationsMap,
-    manifest: manifestMap,
-  };
-}
-
-/**
- * Load a run by ID. Returns null if the run directory does not exist.
- */
-export async function loadRun(flowDir: string, runId: string): Promise<RunState | null> {
-  const runDir = path.join(flowDir, "runs", runId);
-
-  try {
-    await fs.access(runDir);
-  } catch {
-    return null;
-  }
-
-  const roadmap = (await readArtifact(runDir, "roadmap.md")) ?? {
-    preamble: "",
-    sections: new Map(),
-  };
-  const state = (await readArtifact(runDir, "state.md")) ?? {
-    preamble: "",
-    sections: new Map(),
-  };
-  const delegations = (await readArtifact(runDir, "delegations.md")) ?? {
-    preamble: "",
-    sections: new Map(),
-  };
-  const grayAreas = (await readArtifact(runDir, "gray-areas.md")) ?? {
-    preamble: "",
-    sections: new Map(),
-  };
-  const iterations = (await readArtifact(runDir, "iterations.md")) ?? {
-    preamble: "",
-    sections: new Map(),
-  };
-  const manifest = (await readArtifact(runDir, "manifest.md")) ?? {
-    preamble: "",
-    sections: new Map(),
-  };
-
-  return { id: runId, roadmap, state, delegations, grayAreas, iterations, manifest };
-}
-
-/**
- * Read the active run ID from the top-level state.md "Active Run" section.
- * Returns null if no active run is set or section is missing/empty.
- */
-export async function getActiveRunId(flowDir: string): Promise<string | null> {
-  const stateMap = await readArtifact(flowDir, "state.md");
-  if (!stateMap) return null;
-  const section = stateMap.sections.get("Active Run");
-  if (!section?.trim()) return null;
-  return section.trim();
-}
-
-/**
- * Write the active run ID to the top-level state.md "Active Run" section.
- */
-export async function setActiveRunId(flowDir: string, id: string): Promise<void> {
-  let stateMap = await readArtifact(flowDir, "state.md");
-  if (!stateMap) {
-    stateMap = { preamble: "", sections: new Map() };
-  }
-  stateMap.sections.set("Active Run", id);
-  await writeArtifact(flowDir, "state.md", stateMap);
-}
-
-/**
- * Write a run file atomically.
- */
-export async function updateRunFile(flowDir: string, runId: string, filename: string, map: SectionMap): Promise<void> {
-  const runDir = path.join(flowDir, "runs", runId);
-  await writeArtifact(runDir, filename, map);
-}

package/src/flow/scaffold-checkpoint.ts

@@ -1,132 +0,0 @@
-/**
- * Plan 23-fix — persist scaffold inputs to `.muonroi-flow/runs/<runId>/` so a
- * scaffold failure (BB template not installed, restore conflict, etc.) can be
- * retried across CLI restarts without re-running the council debate.
- *
- * Design notes:
- *   - `runId` is the loop-driver run id when available. When the user reached
- *     the init-new form via the manual halt-card path (no preceding /ideal
- *     debate), runId falls back to the DB session id so each session gets its
- *     own checkpoint dir.
- *   - Inputs are stored as plain JSON. Functions (`onPackageProgress`,
- *     `onTemplateMissing`) are NOT serialised — they get re-attached when the
- *     checkpoint is replayed by the TUI.
- *   - Status transitions: `submitted` → (`done` | `error`). `submitted` rows
- *     left behind from a hard crash surface as resumable candidates on
- *     startup.
- *   - File is rewritten on every state change. Single-writer (the TUI) so a
- *     simple `writeFile` is sufficient — no lockfile dance.
- */
-
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { FLOW_DIR_NAME } from "./scaffold.js";
-
-export interface ScaffoldCheckpoint {
-  /** Schema version — bump when the JSON shape changes. */
-  schemaVersion: 1;
-  runId: string;
-  /** ISO timestamp when this checkpoint was first written. */
-  createdAt: string;
-  /** ISO timestamp of the last status update. */
-  updatedAt: string;
-  status: "submitted" | "done" | "error";
-  /** Last error message when status === "error". Surfaced in the resume UI. */
-  errorMessage?: string;
-  /** Project dir when status === "done". */
-  projectDir?: string;
-  /** Original /ideal prompt that triggered this scaffold, if any. */
-  originalPrompt?: string | null;
-  /** Inputs replayable by initNewProject(). */
-  inputs: {
-    projectName: string;
-    feStack: "react" | "angular" | "none";
-    bbTemplate?: { shortName: string; nugetId: string; version: string };
-    eePackages?: string[];
-    commercial?: boolean;
-  };
-}
-
-const CHECKPOINT_FILE = "scaffold-checkpoint.json";
-
-function runDir(cwd: string, runId: string): string {
-  return path.join(cwd, FLOW_DIR_NAME, "runs", runId);
-}
-
-function checkpointPath(cwd: string, runId: string): string {
-  return path.join(runDir(cwd, runId), CHECKPOINT_FILE);
-}
-
-/**
- * Write or update the scaffold checkpoint for `runId` under `cwd`. Creates the
- * .muonroi-flow/runs/<runId>/ directory if missing. Safe to call repeatedly —
- * only the `updatedAt` and the mutable fields change after the first write.
- */
-export async function writeScaffoldCheckpoint(
-  cwd: string,
-  runId: string,
-  patch: Omit<ScaffoldCheckpoint, "schemaVersion" | "createdAt" | "updatedAt" | "runId">,
-): Promise<string> {
-  const dir = runDir(cwd, runId);
-  await fs.mkdir(dir, { recursive: true });
-  const filePath = checkpointPath(cwd, runId);
-
-  const now = new Date().toISOString();
-  let createdAt = now;
-  try {
-    const existing = await fs.readFile(filePath, "utf8");
-    const prev = JSON.parse(existing) as ScaffoldCheckpoint;
-    if (prev.createdAt) createdAt = prev.createdAt;
-  } catch {
-    // First write — keep createdAt = now.
-  }
-
-  const checkpoint: ScaffoldCheckpoint = {
-    schemaVersion: 1,
-    runId,
-    createdAt,
-    updatedAt: now,
-    ...patch,
-  };
-  await fs.writeFile(filePath, JSON.stringify(checkpoint, null, 2), "utf8");
-  return filePath;
-}
-
-/**
- * Read a scaffold checkpoint. Returns null when the file is missing or the
- * shape is unrecognised — corrupted checkpoints should not crash the TUI.
- */
-export async function readScaffoldCheckpoint(cwd: string, runId: string): Promise<ScaffoldCheckpoint | null> {
-  try {
-    const raw = await fs.readFile(checkpointPath(cwd, runId), "utf8");
-    const parsed = JSON.parse(raw) as ScaffoldCheckpoint;
-    if (parsed.schemaVersion !== 1) return null;
-    if (typeof parsed.runId !== "string" || !parsed.inputs?.projectName) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Scan `.muonroi-flow/runs/*` for checkpoints whose status is not `done`.
- * Returned newest-first. Used at TUI startup to offer cross-session resume.
- */
-export async function listResumableScaffoldCheckpoints(cwd: string): Promise<ScaffoldCheckpoint[]> {
-  const runsRoot = path.join(cwd, FLOW_DIR_NAME, "runs");
-  let entries: string[];
-  try {
-    entries = await fs.readdir(runsRoot);
-  } catch {
-    return [];
-  }
-  const out: ScaffoldCheckpoint[] = [];
-  for (const id of entries) {
-    const ck = await readScaffoldCheckpoint(cwd, id);
-    if (ck && ck.status !== "done") {
-      out.push(ck);
-    }
-  }
-  out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-  return out;
-}

package/src/flow/scaffold.ts

@@ -1,52 +0,0 @@
-/**
- * Directory scaffolding for .muonroi-flow/.
- *
- * Creates the locked directory structure on first access. Idempotent —
- * second call does not overwrite existing files.
- */
-
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-
-export const FLOW_DIR_NAME = ".muonroi-flow";
-
-const TOP_LEVEL_FILES = ["roadmap.md", "state.md", "backlog.md", "decisions.md"];
-const SUBDIRS = ["history", "runs"];
-
-/**
- * Ensure the .muonroi-flow/ directory exists with the locked structure:
- *
- * .muonroi-flow/
- * ├── roadmap.md
- * ├── state.md
- * ├── backlog.md
- * ├── decisions.md
- * ├── history/
- * └── runs/
- *
- * Returns the absolute path to the .muonroi-flow/ directory.
- * Only creates files if they do NOT already exist (idempotent).
- */
-export async function ensureFlowDir(cwd: string): Promise<string> {
-  const flowDir = path.join(cwd, FLOW_DIR_NAME);
-
-  // Create the root directory and subdirectories
-  await fs.mkdir(flowDir, { recursive: true });
-  for (const sub of SUBDIRS) {
-    await fs.mkdir(path.join(flowDir, sub), { recursive: true });
-  }
-
-  // Create top-level files only if absent (idempotent)
-  for (const file of TOP_LEVEL_FILES) {
-    const filePath = path.join(flowDir, file);
-    try {
-      await fs.access(filePath);
-      // File exists — do not overwrite
-    } catch {
-      // ENOENT — create empty file
-      await fs.writeFile(filePath, "", "utf8");
-    }
-  }
-
-  return flowDir;
-}

package/src/flow/warning-persist.ts

@@ -1,84 +0,0 @@
-/**
- * Persists EE hook warnings into the active run's state.md.
- *
- * Fire-and-forget: errors are caught and logged, never thrown.
- * Cap: keeps the last MAX_STORED_WARNINGS unique warnings (deduplicated by
- * principle_uuid) to prevent unbounded context growth in state.md.
- */
-
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { renderInterceptWarning } from "../ee/render.js";
-import type { InterceptMatch } from "../ee/types.js";
-import { getSection } from "./parser.js";
-import { getActiveRunId, loadRun, updateRunFile } from "./run-manager.js";
-import { FLOW_DIR_NAME } from "./scaffold.js";
-
-const MAX_STORED_WARNINGS = 20;
-
-/** Parse stored warning lines back to principle_uuid for dedup. */
-function _extractUuids(snapshot: string): string[] {
-  const uuids: string[] = [];
-  for (const line of snapshot.split("\n")) {
-    // Warnings rendered with renderInterceptWarning contain principle_uuid implicitly
-    // via the message. We tag each entry with UUID in the persisted format below.
-    const m = line.match(/\[uuid:([^\]]+)\]/);
-    if (m) uuids.push(m[1]);
-  }
-  return uuids;
-}
-
-function tagWarning(match: InterceptMatch, text: string): string {
-  return `[uuid:${match.principle_uuid}] ${text}`;
-}
-
-/** Keep only the last MAX_STORED_WARNINGS unique-uuid entries. */
-function trimSnapshot(snapshot: string, _newUuid: string): string {
-  // Split into per-warning blocks (each starts with a timestamp tag)
-  const entries = snapshot.split(/(?=\[\d{4}-\d{2}-\d{2})/);
-  const seen = new Set<string>();
-  const kept: string[] = [];
-
-  for (const entry of entries.reverse()) {
-    // newest first
-    const m = entry.match(/\[uuid:([^\]]+)\]/);
-    const uuid = m ? m[1] : entry.slice(0, 40); // fallback key
-    if (!seen.has(uuid) && seen.size < MAX_STORED_WARNINGS - 1) {
-      seen.add(uuid);
-      kept.unshift(entry);
-    }
-  }
-
-  return kept.filter(Boolean).join("").trim();
-}
-
-export async function persistWarning(cwd: string, match: InterceptMatch): Promise<void> {
-  try {
-    const flowDir = path.join(cwd, FLOW_DIR_NAME);
-    try {
-      await fs.access(flowDir);
-    } catch {
-      return;
-    }
-
-    const runId = await getActiveRunId(flowDir);
-    if (!runId) return;
-
-    const runState = await loadRun(flowDir, runId);
-    if (!runState) return;
-
-    const warningText = tagWarning(match, renderInterceptWarning(match));
-    const timestampedWarning = `[${new Date().toISOString()}] ${warningText}`;
-
-    const existing = getSection(runState.state, "Experience Snapshot") ?? "";
-
-    // Deduplicate and cap
-    const trimmed = trimSnapshot(existing, match.principle_uuid);
-    const updated = trimmed ? `${trimmed}\n${timestampedWarning}` : timestampedWarning;
-
-    runState.state.sections.set("Experience Snapshot", updated);
-    await updateRunFile(flowDir, runId, "state.md", runState.state);
-  } catch (err) {
-    console.warn("[warning-persist] Failed to persist warning:", err);
-  }
-}

package/src/generated/version.ts

@@ -1,5 +0,0 @@
-// AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
-// Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.4.0";
-export const PACKAGE_DESCRIPTION =
-  "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/src/gsd/__tests__/directives.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { scoreComplexity } from "../complexity";
-import { buildDirective } from "../directives";
-import { detectGrayAreas } from "../gray-areas";
-
-describe("buildDirective", () => {
-  it("emits a blocking heavy directive with mandatory steps", () => {
-    const prompt = "redo the entire architecture and map everything across all repos";
-    const complexity = scoreComplexity(prompt);
-    expect(complexity.tier).toBe("heavy");
-
-    const grayAreas = detectGrayAreas(prompt).questions;
-    const out = buildDirective({ complexity, phase: null, grayAreas });
-
-    expect(out.tier).toBe("heavy");
-    expect(out.blocking).toBe(true);
-    expect(out.text).toContain("MANDATORY");
-    expect(out.text).toMatch(/AskUserQuestion/);
-    expect(out.text).toMatch(/IN PARALLEL/);
-    expect(out.text).toMatch(/research/i);
-    expect(out.text).toMatch(/verify/i);
-  });
-
-  it("emits a non-blocking standard directive", () => {
-    const complexity = scoreComplexity("add a /health endpoint");
-    const out = buildDirective({ complexity, phase: "execute", grayAreas: [] });
-    expect(out.tier).toBe("standard");
-    expect(out.blocking).toBe(false);
-    expect(out.text).toMatch(/GSD-quick/i);
-  });
-
-  it("emits a fix-first debug variant when phase is debug (session 7d56a049e1e3 regression)", () => {
-    const complexity = scoreComplexity("fix CI fail");
-    const out = buildDirective({ complexity, phase: "debug", grayAreas: [] });
-    expect(out.tier).toBe("standard");
-    expect(out.text).toMatch(/DEBUG task/);
-    expect(out.text).toMatch(/FIX-FIRST/);
-    expect(out.text).toMatch(/≤ 8 read_file/);
-    expect(out.text).toMatch(/edit_file/);
-  });
-
-  it("standard non-debug phases use the generic GSD-quick directive (regression: don't apply fix-first cap to plan/execute)", () => {
-    const complexity = scoreComplexity("add a counter feature");
-    const out = buildDirective({ complexity, phase: "execute", grayAreas: [] });
-    expect(out.text).not.toMatch(/FIX-FIRST/);
-    expect(out.text).not.toMatch(/read_file calls before/);
-  });
-
-  it("emits a human-facing question directive for informational/meta prompts (session 829a83888dd2)", () => {
-    // A self/meta CLI question routed through GSD must NOT get the
-    // implement/verify scaffold — that leaked a "2-3 line plan" preamble +
-    // process narration into the human-facing answer.
-    const complexity = scoreComplexity("how does this CLI affect you?");
-    const out = buildDirective({ complexity, phase: null, grayAreas: [], informational: true });
-    expect(out.blocking).toBe(false);
-    expect(out.text).toMatch(/QUESTION \/ explanatory/);
-    expect(out.text).toMatch(/written for the HUMAN/);
-    expect(out.text).not.toMatch(/2-3 line plan/);
-    expect(out.text).not.toMatch(/Implement directly/);
-  });
-
-  it("informational overrides even a heavy tier (a question never implements)", () => {
-    const complexity = scoreComplexity("redo the entire architecture and map everything across all repos");
-    expect(complexity.tier).toBe("heavy");
-    const out = buildDirective({ complexity, phase: null, grayAreas: [], informational: true });
-    expect(out.blocking).toBe(false);
-    expect(out.text).toMatch(/QUESTION \/ explanatory/);
-    expect(out.text).not.toMatch(/MANDATORY/);
-  });
-
-  it("emits a minimal quick directive", () => {
-    const complexity = scoreComplexity("fix typo");
-    const out = buildDirective({ complexity, phase: null, grayAreas: [] });
-    expect(out.tier).toBe("quick");
-    expect(out.blocking).toBe(false);
-    expect(out.text.length).toBeLessThan(300);
-  });
-
-  it("renders the recommended option first in gray-area block", () => {
-    const prompt = "redo everything from scratch";
-    const complexity = scoreComplexity(prompt);
-    const grayAreas = detectGrayAreas(prompt).questions;
-    const out = buildDirective({ complexity, phase: null, grayAreas });
-    if (grayAreas.length > 0) {
-      expect(out.text).toMatch(/\[recommended\]/);
-    }
-  });
-});

package/src/gsd/__tests__/gray-areas.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectGrayAreas } from "../gray-areas";
-
-describe("detectGrayAreas", () => {
-  it("returns no questions for empty input", () => {
-    expect(detectGrayAreas("").questions).toHaveLength(0);
-  });
-
-  it("flags scope when prompt is broad", () => {
-    const r = detectGrayAreas("rewrite everything for better performance");
-    const dims = r.questions.map((q) => q.dimension);
-    expect(dims).toContain("scope");
-  });
-
-  it("does not flag scope when prompt names a single file", () => {
-    const r = detectGrayAreas("rename foo to bar in src/index.ts");
-    const dims = r.questions.map((q) => q.dimension);
-    expect(dims).not.toContain("scope");
-  });
-
-  it("each question's first option is the recommended default", () => {
-    const r = detectGrayAreas("redo the architecture");
-    for (const q of r.questions) {
-      expect(q.options[0]).toBeTruthy();
-      expect(q.options.length).toBeGreaterThanOrEqual(2);
-    }
-  });
-
-  it("caps the number of questions at 4", () => {
-    const r = detectGrayAreas("do everything everywhere all at once");
-    expect(r.questions.length).toBeLessThanOrEqual(4);
-  });
-});