muonroi-cli 1.8.3 → 1.8.5

package/dist/src/gsd/native-state.js

@@ -0,0 +1,220 @@
+/**
+ * native-state.ts — Native replacements for the STATE.md-oriented gsd-tools
+ * subcommands (`state update`, `state json`, `init progress`).
+ *
+ * Part B: these fully replace the former `@opengsd/gsd-core` subprocess (removed
+ * in step 2). Output shapes follow the old gsd-tools `--raw`/JSON contract:
+ * state update → {updated:boolean, reason?}, state json → frontmatter object,
+ * init progress → progress projection.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { planningArtifact, planningPhasesRoot, planningRoot } from "./paths.js";
+import { computeProgressPercent, normalizeStateStatus, stateExtractField, stateReplaceField, } from "./state-document.js";
+/** Split a STATE.md into (frontmatter, body). Frontmatter is the text between
+ * the leading `---` fences (exclusive); body is everything after. */
+function splitFrontmatter(content) {
+    const m = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m)
+        return { frontmatter: null, body: content };
+    return { frontmatter: m[1], body: m[2] };
+}
+/**
+ * Native `state update <field> <value>`.
+ * Mirrors gsd-core updateCore: strip frontmatter, `stateReplaceField` on the
+ * BODY only, reassemble. Returns {updated:false, reason} when the field is not
+ * present or STATE.md is missing (never throws). Caller invalidates cache.
+ */
+export function nativeStateUpdate(cwd, field, value) {
+    const path = planningArtifact(cwd, "STATE.md");
+    if (!existsSync(path))
+        return { updated: false, reason: "STATE.md not found" };
+    let content;
+    try {
+        content = readFileSync(path, "utf8");
+    }
+    catch {
+        return { updated: false, reason: "STATE.md not found" };
+    }
+    const { frontmatter, body } = splitFrontmatter(content);
+    const replaced = stateReplaceField(body, field, value);
+    if (replaced === null) {
+        return { updated: false, reason: `Field "${field}" not found in STATE.md` };
+    }
+    const next = frontmatter !== null ? `---\n${frontmatter}\n---\n\n${replaced.replace(/^\n+/, "")}` : replaced;
+    try {
+        // gsd-core writes under lock; a plain write matches the prior subprocess
+        // behavior for the single-writer product loop.
+        writeFileSync(path, next, "utf8");
+    }
+    catch (err) {
+        return { updated: false, reason: err.message };
+    }
+    return { updated: true };
+}
+/** Count digit-prefixed phase headings in a ROADMAP.md milestone body. */
+function countRoadmapPhases(cwd) {
+    const roadmap = planningArtifact(cwd, "ROADMAP.md");
+    if (!existsSync(roadmap))
+        return 0;
+    try {
+        const text = readFileSync(roadmap, "utf8");
+        const re = /#{2,4}\s*(?:\[[^\]]+\]\s*)?Phase\s+(\d+[A-Za-z]?(?:[.-]\d+)*)\s*:/gi;
+        const seen = new Set();
+        for (let m = re.exec(text); m; m = re.exec(text)) {
+            const n = m[1];
+            if (n === "0" || n.startsWith("999"))
+                continue;
+            seen.add(n);
+        }
+        return seen.size;
+    }
+    catch {
+        return 0;
+    }
+}
+/** List phase directories with lightweight disk counts. */
+function scanPhaseDirs(cwd) {
+    const root = planningPhasesRoot(cwd);
+    if (!existsSync(root))
+        return [];
+    try {
+        return readdirSync(root, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => {
+            let plan_count = 0;
+            let summary_count = 0;
+            try {
+                for (const f of readdirSync(`${root}/${e.name}`)) {
+                    if (/PLAN.*\.md$/i.test(f))
+                        plan_count += 1;
+                    if (/SUMMARY.*\.md$/i.test(f))
+                        summary_count += 1;
+                }
+            }
+            catch {
+                /* unreadable phase dir — count as empty */
+            }
+            return { dir: e.name, plan_count, summary_count };
+        })
+            .sort((a, b) => a.dir.localeCompare(b.dir));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Native `state json` — frontmatter snapshot derived from STATE.md body fields
+ * + roadmap phase count. Note: gsd-core emits a fresh `last_updated` ISO stamp;
+ * we OMIT that non-deterministic field so consumers/tests get a stable object
+ * (workflow-engine only reads it loosely as `state_frontmatter`).
+ */
+export function nativeStateJson(cwd) {
+    const path = planningArtifact(cwd, "STATE.md");
+    if (!existsSync(path))
+        return { error: "STATE.md not found" };
+    const content = readFileSync(path, "utf8");
+    const get = (f) => stateExtractField(content, f);
+    const totalPhasesFromRoadmap = countRoadmapPhases(cwd);
+    const totalPhases = Number.parseInt(get("Total Phases") ?? "", 10);
+    const completedPhases = Number.parseInt(get("Completed Phases") ?? "", 10);
+    const totalPlans = Number.parseInt(get("Total Plans in Phase") ?? get("Total Plans") ?? "", 10);
+    const completedPlans = Number.parseInt(get("Completed Plans") ?? "", 10);
+    const tp = Number.isFinite(totalPhases) ? totalPhases : totalPhasesFromRoadmap || null;
+    const cp = Number.isFinite(completedPhases) ? completedPhases : null;
+    const tpl = Number.isFinite(totalPlans) ? totalPlans : null;
+    const cpl = Number.isFinite(completedPlans) ? completedPlans : null;
+    const out = { gsd_state_version: "1.0" };
+    const currentPhase = get("Current Phase") ?? get("Phase");
+    if (currentPhase)
+        out.current_phase = currentPhase;
+    const currentPlan = get("Current Plan");
+    if (currentPlan)
+        out.current_plan = currentPlan;
+    out.status = normalizeStateStatus(get("Status") ?? "", get("Paused At") ?? undefined);
+    const lastActivity = get("Last Activity");
+    if (lastActivity)
+        out.last_activity = lastActivity;
+    const progress = {};
+    if (tp !== null)
+        progress.total_phases = tp;
+    if (cp !== null)
+        progress.completed_phases = cp;
+    if (tpl !== null)
+        progress.total_plans = tpl;
+    if (cpl !== null)
+        progress.completed_plans = cpl;
+    const percent = computeProgressPercent(cpl, tpl, cp, tp);
+    if (percent !== null)
+        progress.percent = percent;
+    if (Object.keys(progress).length > 0)
+        out.progress = progress;
+    return out;
+}
+/**
+ * Native `init progress` — the projection consumed by workflow-engine.readProgress.
+ * Mirrors the subset of gsd-core's cmdInitProgress that muonroi actually reads:
+ * existence flags, phase list + counts, current/next phase.
+ */
+export function nativeInitProgress(cwd) {
+    const stateExists = existsSync(planningArtifact(cwd, "STATE.md"));
+    const roadmapExists = existsSync(planningArtifact(cwd, "ROADMAP.md"));
+    const projectExists = existsSync(planningArtifact(cwd, "PROJECT.md"));
+    const phaseDirs = scanPhaseDirs(cwd);
+    const phases = phaseDirs.map((p) => {
+        const numMatch = p.dir.match(/(\d+)/);
+        return {
+            number: numMatch ? numMatch[1] : p.dir,
+            directory: p.dir,
+            plan_count: p.plan_count,
+            summary_count: p.summary_count,
+            status: p.summary_count >= p.plan_count && p.plan_count > 0
+                ? "complete"
+                : p.plan_count > 0
+                    ? "in_progress"
+                    : "not_started",
+        };
+    });
+    const completed = phases.filter((p) => p.status === "complete").length;
+    const inProgress = phases.filter((p) => p.status === "in_progress").length;
+    const current = phases.find((p) => p.status !== "complete");
+    return {
+        phases,
+        phase_count: Math.max(phases.length, countRoadmapPhases(cwd)),
+        completed_count: completed,
+        in_progress_count: inProgress,
+        current_phase: current?.number ?? null,
+        project_exists: projectExists,
+        roadmap_exists: roadmapExists,
+        state_exists: stateExists,
+        state_path: planningArtifact(cwd, "STATE.md"),
+        roadmap_path: planningArtifact(cwd, "ROADMAP.md"),
+        project_root: planningRoot(cwd),
+        has_work_in_progress: inProgress > 0,
+    };
+}
+/** True when STATE.md exists (used by callers to decide native vs. bootstrap). */
+export function stateFileMtime(cwd) {
+    try {
+        const p = planningArtifact(cwd, "STATE.md");
+        return existsSync(p) ? statSync(p).mtimeMs : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Native `config-ensure-section` — ensure the `.planning/` directory exists.
+ * muonroi's only caller (loop-host.ensureHost) invokes this immediately before
+ * `ensurePlanningWorkspace`, which writes the real model-bound config.json. So
+ * native config-ensure MUST NOT write a stub config here — that would shadow the
+ * proper config (ensurePlanningWorkspace only writes when config.json is absent).
+ * We just guarantee the directory, matching the pair's net effect.
+ */
+export function nativeConfigEnsure(cwd) {
+    const root = planningRoot(cwd);
+    const existed = existsSync(root);
+    if (!existed)
+        mkdirSync(root, { recursive: true });
+    return { ok: true, created: !existed };
+}
+//# sourceMappingURL=native-state.js.map

package/dist/src/gsd/paths.d.ts

@@ -0,0 +1,23 @@
+export declare const PLANNING_DIR = ".planning";
+/**
+ * Consolidated home for GSD planning state once it is folded under the flow
+ * directory (`.muonroi-flow/planning/`). See `src/flow/fold-planning.ts`.
+ */
+export declare const FOLDED_PLANNING_DIR: string;
+/**
+ * Resolve the active GSD planning root.
+ *
+ * Sprint-2 (Part A, staged per REV-3 Kill B): `.planning/` still WINS whenever
+ * it exists — that is where the `gsd-tools.cjs` subprocess writes phases today,
+ * so reads and writes stay in sync and behavior is byte-identical to before.
+ * The folded location (`.muonroi-flow/planning/`) is used only as a READ
+ * fallback — i.e. once the subprocess writer is removed (Part B) and `.planning/`
+ * no longer exists, GSD reads transparently continue from the consolidated tree.
+ * This is purely additive: no live cutover, no desync risk.
+ */
+export declare function planningRoot(cwd: string): string;
+export declare function planningArtifact(cwd: string, name: string): string;
+export declare function planningPhasesRoot(cwd: string): string;
+export declare function listPhaseDirs(cwd: string): string[];
+export declare function latestPhaseDir(cwd: string): string | null;
+export declare function phaseDirPath(cwd: string, dirName: string, artifact?: string): string;

package/dist/src/gsd/paths.js

@@ -0,0 +1,66 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+export const PLANNING_DIR = ".planning";
+/**
+ * Consolidated home for GSD planning state once it is folded under the flow
+ * directory (`.muonroi-flow/planning/`). See `src/flow/fold-planning.ts`.
+ */
+export const FOLDED_PLANNING_DIR = join(".muonroi-flow", "planning");
+/**
+ * Resolve the active GSD planning root.
+ *
+ * Sprint-2 (Part A, staged per REV-3 Kill B): `.planning/` still WINS whenever
+ * it exists — that is where the `gsd-tools.cjs` subprocess writes phases today,
+ * so reads and writes stay in sync and behavior is byte-identical to before.
+ * The folded location (`.muonroi-flow/planning/`) is used only as a READ
+ * fallback — i.e. once the subprocess writer is removed (Part B) and `.planning/`
+ * no longer exists, GSD reads transparently continue from the consolidated tree.
+ * This is purely additive: no live cutover, no desync risk.
+ */
+export function planningRoot(cwd) {
+    const canonical = join(cwd, PLANNING_DIR);
+    // Existing `.planning/` projects keep using it (back-compat, no disruption).
+    if (existsSync(canonical))
+        return canonical;
+    const folded = join(cwd, FOLDED_PLANNING_DIR);
+    if (existsSync(folded))
+        return folded;
+    // Part B step 2 — LIVE CUTOVER: now that native code owns all GSD path
+    // resolution (the subprocess that hardcoded `.planning/` is gone), a FRESH
+    // project consolidates its GSD state under `.muonroi-flow/planning/` — one
+    // state tree alongside the /ideal `.muonroi-flow/runs/`. Opt back into the
+    // legacy split location with MUONROI_GSD_LEGACY_PLANNING=1.
+    if (process.env.MUONROI_GSD_LEGACY_PLANNING === "1")
+        return canonical;
+    return folded;
+}
+export function planningArtifact(cwd, name) {
+    return join(planningRoot(cwd), name);
+}
+export function planningPhasesRoot(cwd) {
+    return join(planningRoot(cwd), "phases");
+}
+export function listPhaseDirs(cwd) {
+    const root = planningPhasesRoot(cwd);
+    if (!existsSync(root))
+        return [];
+    try {
+        return readdirSync(root, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .sort();
+    }
+    catch (err) {
+        console.error(`[gsd-paths] listPhaseDirs failed: ${err.message}`);
+        return [];
+    }
+}
+export function latestPhaseDir(cwd) {
+    const dirs = listPhaseDirs(cwd);
+    return dirs.length ? dirs[dirs.length - 1] : null;
+}
+export function phaseDirPath(cwd, dirName, artifact) {
+    const base = join(planningPhasesRoot(cwd), dirName);
+    return artifact ? join(base, artifact) : base;
+}
+//# sourceMappingURL=paths.js.map

package/dist/src/gsd/phase-dag.d.ts

@@ -0,0 +1,12 @@
+import type { Phase } from "../product-loop/types.js";
+/** Kahn topological sort — same algorithm as legacy phase-runner orderByDeps. */
+export declare function topologicalPhaseOrder(phases: Phase[]): Phase[];
+/**
+ * Resolve phase execution order: gsd-core roadmap analyze when native + ROADMAP.md,
+ * otherwise legacy topological sort on dependsOn.
+ */
+export declare function orderPhasesForExecution(cwd: string, phases: Phase[]): Phase[];
+export declare function syncPhasePlanToRoadmap(cwd: string, idea: string, plan: {
+    phases: Phase[];
+}): void;
+export declare function mapPhaseDependsToRoadmapNumbers(phases: Phase[]): Record<string, string>;

package/dist/src/gsd/phase-dag.js

@@ -0,0 +1,94 @@
+import { isGsdNativeEnabled } from "./flags.js";
+import { dispatchRoadmapAnalyze } from "./gsd-dispatch.js";
+import { syncRoadmapFromPhasePlan } from "./product-workspace.js";
+/** Kahn topological sort — same algorithm as legacy phase-runner orderByDeps. */
+export function topologicalPhaseOrder(phases) {
+    const remaining = new Map(phases.map((p) => [p.id, new Set(p.dependsOn.filter((d) => phases.some((x) => x.id === d)))]));
+    const byId = new Map(phases.map((p) => [p.id, p]));
+    const out = [];
+    while (remaining.size > 0) {
+        let progressed = false;
+        for (const [id, deps] of remaining) {
+            if (deps.size === 0) {
+                out.push(byId.get(id));
+                remaining.delete(id);
+                for (const [, set] of remaining)
+                    set.delete(id);
+                progressed = true;
+                break;
+            }
+        }
+        if (!progressed)
+            break;
+    }
+    if (out.length < phases.length) {
+        const stuck = phases.filter((p) => !out.some((o) => o.id === p.id));
+        console.error(`[gsd-phase-dag] dependency cycle or unresolved deps — falling back to declaration order for: ${stuck.map((p) => p.id).join(", ")}`);
+        for (const p of phases) {
+            if (!out.some((o) => o.id === p.id))
+                out.push(p);
+        }
+    }
+    return out;
+}
+function phaseIdToRoadmapNumber(phaseId) {
+    const match = phaseId.match(/phase-(\d+)/i);
+    return match ? match[1] : null;
+}
+function reorderByRoadmapAnalyze(phases, analysis) {
+    if (!analysis.phases?.length)
+        return topologicalPhaseOrder(phases);
+    const byNum = new Map();
+    for (const p of phases) {
+        const num = phaseIdToRoadmapNumber(p.id);
+        if (num)
+            byNum.set(num, p);
+    }
+    const ordered = [];
+    for (const entry of analysis.phases) {
+        const num = entry.number;
+        if (!num)
+            continue;
+        const phase = byNum.get(String(num));
+        if (phase && !ordered.some((o) => o.id === phase.id)) {
+            ordered.push(phase);
+        }
+    }
+    for (const p of phases) {
+        if (!ordered.some((o) => o.id === p.id))
+            ordered.push(p);
+    }
+    return ordered.length ? ordered : topologicalPhaseOrder(phases);
+}
+/**
+ * Resolve phase execution order: gsd-core roadmap analyze when native + ROADMAP.md,
+ * otherwise legacy topological sort on dependsOn.
+ */
+export function orderPhasesForExecution(cwd, phases) {
+    if (!isGsdNativeEnabled())
+        return topologicalPhaseOrder(phases);
+    const analysis = dispatchRoadmapAnalyze(cwd);
+    if (analysis.ok && analysis.data && !analysis.data.error) {
+        return reorderByRoadmapAnalyze(phases, analysis.data);
+    }
+    return topologicalPhaseOrder(phases);
+}
+export function syncPhasePlanToRoadmap(cwd, idea, plan) {
+    if (!isGsdNativeEnabled())
+        return;
+    syncRoadmapFromPhasePlan(cwd, idea, plan);
+    const analysis = dispatchRoadmapAnalyze(cwd);
+    if (!analysis.ok) {
+        console.error(`[gsd-phase-dag] roadmap analyze after sync failed: ${analysis.error ?? "unknown"}`);
+    }
+}
+export function mapPhaseDependsToRoadmapNumbers(phases) {
+    const out = {};
+    for (const p of phases) {
+        const num = phaseIdToRoadmapNumber(p.id);
+        if (num)
+            out[p.id] = num;
+    }
+    return out;
+}
+//# sourceMappingURL=phase-dag.js.map

package/dist/src/gsd/phase-sync.d.ts

@@ -0,0 +1,42 @@
+import type { TaskListSnapshot } from "../types/index.js";
+export interface PhaseSyncStep {
+    op: string;
+    ok: boolean;
+    detail?: string;
+    error?: string;
+}
+export interface PhaseSyncResult {
+    ok: boolean;
+    skipped: boolean;
+    skipReason?: string;
+    phaseNumber?: string;
+    phaseDirName?: string;
+    error?: string;
+    steps: PhaseSyncStep[];
+}
+export declare function extractPlanTitle(planBody: string): string;
+export declare function derivePhaseSlug(title: string): string;
+export declare function findPhaseDirBySlug(cwd: string, slug: string): string | null;
+export declare function readMilestonePhaseDir(cwd: string): string | null;
+/** Minimal gsd-compatible ROADMAP required before `phase add`. */
+export declare function ensureTaskRoadmap(cwd: string, milestoneTitle: string): void;
+export declare function copyPlanToPhaseDir(cwd: string, phaseDirName: string, planBody: string): void;
+export declare function writePhaseVerificationPassed(cwd: string, phaseDirName: string, phaseNumber: string, evidence?: string): string;
+export declare function writePhaseSummaryStub(cwd: string, phaseDirName: string, evidence?: string): string;
+/** After gsd_plan writes PLAN.md — task workflow only. */
+export declare function syncTaskPhaseOnPlan(cwd: string, opts: {
+    planTitle: string;
+    planBody: string;
+    sessionId?: string;
+}): PhaseSyncResult;
+/** After gsd_verify pass — task workflow only. */
+export declare function syncTaskPhaseOnVerifyPass(cwd: string, opts?: {
+    evidence?: string;
+    sessionId?: string;
+}): PhaseSyncResult;
+/** Copy root VERIFY.md into phase dir when present (best-effort). */
+export declare function mirrorVerifyMdToPhaseDir(cwd: string, phaseDirName: string): void;
+/** Automatically append user AskCard answers as clarifications to CONTEXT.md under GSD. */
+export declare function appendClarificationToContext(cwd: string, question: string, answer: string): void;
+/** Build TaskListSnapshot directly from GSD PLAN.md and STATE.md for automatic TUI checklist synchronization. */
+export declare function getTaskListSnapshotFromGsd(cwd: string): TaskListSnapshot | null;