@goodtek/vibeops 0.3.0 → 0.7.22

package/dist/lib/done-follow-up.js

@@ -0,0 +1,308 @@
+import { join } from "node:path";
+import { notionSyncCommand } from "../commands/notion-sync.js";
+import { askYesNo } from "./inquirer-helpers.js";
+import { readConfig } from "./config.js";
+import { pathExists, readText, readTextOrNull, writeText } from "./filesystem.js";
+import { detectDefaultBranch, gitAddPaths, gitCheckoutNewBranch, gitHeadCommit, gitMergeInProgress, gitRemoteUrl, listUnmergedRelPaths, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, tryResolveGovernanceUnmerged, } from "./git.js";
+import { bold, cyan, dim, log, yellow } from "./logger.js";
+import { llmCompleteJson, resolveAvailableLlmProvider } from "./llm-complete.js";
+import { NEXT_TASK_SUGGESTION_REL } from "./mvp-constants.js";
+import { LAST_DONE_SUMMARY_REL, readLastDoneSummary, } from "./mvp-done-summary.js";
+import { mergeTaskBranch } from "./task-merge.js";
+import { parseTaskFilename, readSection } from "./task.js";
+const BRIEF_REL = ".vibeops/brief/project-brief.md";
+async function gitDiffStatSummary(cwd) {
+    try {
+        const stat = await runGit(cwd, ["diff", "--stat"]);
+        const body = stat.stdout.trim();
+        return body.length > 0 ? body : "(no staged/unstaged diff — check untracked files with git status)";
+    }
+    catch {
+        return "(could not read git diff)";
+    }
+}
+export async function syncNotionAfterDone(opts) {
+    if (opts.noNotionSync === true) {
+        log.info(dim("Notion sync skipped (--no-notion-sync)."));
+        return;
+    }
+    const config = await readConfig(opts.cwd);
+    if (config?.notion?.enabled !== true) {
+        log.info(dim("Notion sync skipped (not enabled in .vibeops.json)."));
+        return;
+    }
+    log.blank();
+    log.step(bold("Notion sync"));
+    if (opts.dryRun === true) {
+        log.info(dim("  dry-run: would run vibeops notion sync"));
+        return;
+    }
+    const prevCode = process.exitCode;
+    await notionSyncCommand({ cwd: opts.cwd, dryRun: false });
+    if (process.exitCode === 1) {
+        log.warn("Notion sync failed — fix integration and run `vibeops notion sync`.");
+    }
+    else {
+        log.ok("Notion sync complete.");
+    }
+    if (prevCode === 1)
+        process.exitCode = 1;
+}
+async function handleMergeInProgressDirtyTree(opts) {
+    const unmerged = await listUnmergedRelPaths(opts.cwd);
+    if (unmerged.length > 0) {
+        log.warn("Unmerged files from the task merge:");
+        for (const p of unmerged.slice(0, 12))
+            log.info(`  ${dim("·")} ${p}`);
+        if (unmerged.length > 12)
+            log.info(`  ${dim("·")} … and ${unmerged.length - 12} more`);
+        const resolved = await tryResolveGovernanceUnmerged(opts.cwd);
+        if (resolved.length > 0) {
+            log.ok(`Auto-resolved ${resolved.length} governance conflict(s) (kept incoming branch version).`);
+        }
+        const still = await listUnmergedRelPaths(opts.cwd);
+        if (still.length > 0) {
+            log.error("Remaining conflicts — resolve manually, then:");
+            for (const p of still)
+                log.info(`  ${dim("·")} ${p}`);
+            log.info(dim("  git add <paths> && git commit   (completes merge)"));
+            log.info(dim("  Or abort: git merge --quit"));
+            return false;
+        }
+    }
+    const allPaths = await listWorkingTreeRelPaths(opts.cwd);
+    const { committable } = partitionPathsForAutoCommit(allPaths, {
+        unmerged: await listUnmergedRelPaths(opts.cwd),
+    });
+    if (committable.length > 0) {
+        await gitAddPaths(opts.cwd, committable);
+        log.info(dim("Staged remaining changes."));
+    }
+    log.warn("Complete the merge on this branch:");
+    log.info(dim("  git commit -m \"merge: complete TASK merge and post-done files\""));
+    return false;
+}
+async function cleanupDirtyTree(opts) {
+    const git = await readGitInfo(opts.cwd);
+    if (!git.isRepo || git.dirty !== true)
+        return true;
+    if (await gitMergeInProgress(opts.cwd)) {
+        log.blank();
+        log.warn(`${yellow("!")} Git merge still in progress — cannot create a cleanup branch yet.`);
+        return handleMergeInProgressDirtyTree(opts);
+    }
+    const unmerged = await listUnmergedRelPaths(opts.cwd);
+    const allPaths = await listWorkingTreeRelPaths(opts.cwd);
+    const { committable, excluded, unmerged: unmergedListed } = partitionPathsForAutoCommit(allPaths, { unmerged });
+    log.blank();
+    log.warn(`${yellow("!")} Working tree is still dirty after done.`);
+    const summary = await gitDiffStatSummary(opts.cwd);
+    log.info(dim("Changes:"));
+    log.info(dim(summary.split("\n").map((l) => `  ${l}`).join("\n")));
+    if (unmergedListed.length > 0) {
+        log.warn("Skipping unmerged paths until conflicts are resolved:");
+        for (const p of unmergedListed.slice(0, 8))
+            log.info(`  ${dim("·")} ${p}`);
+    }
+    if (excluded.length > 0) {
+        log.blank();
+        log.warn("These paths are build/install artifacts — VibeOps will not commit them:");
+        for (const p of excluded.slice(0, 8))
+            log.info(`  ${dim("·")} ${p}`);
+        if (excluded.length > 8)
+            log.info(`  ${dim("·")} … and ${excluded.length - 8} more`);
+        log.info(dim("  Add node_modules/, .next/, etc. to .gitignore if they are not already ignored."));
+    }
+    if (committable.length === 0) {
+        log.warn("Nothing safe to auto-commit — fix .gitignore and remove tracked artifacts before the next TASK.");
+        return false;
+    }
+    log.blank();
+    log.info(dim("Would commit:"));
+    for (const p of committable.slice(0, 12))
+        log.info(`  ${dim("·")} ${p}`);
+    if (committable.length > 12)
+        log.info(`  ${dim("·")} … and ${committable.length - 12} more`);
+    let proceed = false;
+    if (opts.interactive === true) {
+        proceed = await askYesNo({
+            message: "Create a cleanup branch, commit the paths above (not node_modules/.next), merge, and delete the branch?",
+            nonInteractive: false,
+            defaultValue: true,
+        });
+    }
+    if (!proceed) {
+        log.info(dim("Cleanup skipped — commit manually before starting the next TASK."));
+        return false;
+    }
+    if (opts.dryRun === true) {
+        log.info(dim("  dry-run: would create chore/vibeops-post-done-* branch, commit, merge"));
+        return false;
+    }
+    const taskId = parseTaskFilename(opts.taskFile).id;
+    const baseBranch = (await detectDefaultBranch(opts.cwd)) ?? "main";
+    const baseCommit = (await gitHeadCommit(opts.cwd, false)) ?? "";
+    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+    const cleanupBranch = `chore/vibeops-post-done-${stamp}`;
+    await gitCheckoutNewBranch(opts.cwd, cleanupBranch);
+    await gitAddPaths(opts.cwd, committable);
+    await runGit(opts.cwd, [
+        "commit",
+        "-q",
+        "-m",
+        `chore(post-done): cleanup uncommitted work after ${taskId}`,
+    ]);
+    log.ok(`Committed on ${cleanupBranch}`);
+    const remote = (await gitRemoteUrl(opts.cwd, "origin")) ?? "";
+    if (remote.length === 0) {
+        log.warn("No origin remote — merge locally only.");
+        await runGit(opts.cwd, ["switch", baseBranch]);
+        await runGit(opts.cwd, ["merge", "--no-ff", cleanupBranch, "-m", `merge: post-mvp cleanup`]);
+        await runGit(opts.cwd, ["branch", "-d", cleanupBranch]);
+        return (await readGitInfo(opts.cwd)).dirty !== true;
+    }
+    const ctx = {
+        baseBranch,
+        baseCommit,
+        taskBranch: cleanupBranch,
+        startedAt: new Date().toISOString(),
+    };
+    const merged = await mergeTaskBranch({
+        cwd: opts.cwd,
+        taskId,
+        taskTitle: opts.taskTitle,
+        gitCtx: ctx,
+        mode: "direct",
+    });
+    if (!merged.ok) {
+        log.warn("Cleanup merge did not finish — resolve Git state manually.");
+        return false;
+    }
+    const after = await readGitInfo(opts.cwd);
+    if (after.dirty === true) {
+        log.warn("Tree is still dirty after cleanup merge.");
+        return false;
+    }
+    log.ok("Working tree clean after post-MVP cleanup.");
+    return true;
+}
+function renderSuggestionMarkdown(s, priorDoneSummary) {
+    const priorBlock = priorDoneSummary !== null
+        ? `## Previous iteration (from \`${LAST_DONE_SUMMARY_REL}\`)\n\n${priorDoneSummary.trim()}\n\n---\n\n`
+        : "";
+    return `# Next iteration (suggested)
+
+${priorBlock}## Title
+
+${s.title}
+
+## One-line idea
+
+${s.oneLineIdea}
+
+## Goal
+
+${s.goal}
+
+## Suggested scope
+
+${s.scope.map((x) => `- ${x}`).join("\n")}
+
+## Rationale
+
+${s.rationale}
+
+---
+
+Run planning again when ready:
+
+\`\`\`bash
+vibeops plan --idea "${s.oneLineIdea.replace(/"/g, '\\"')}"
+\`\`\`
+`;
+}
+async function suggestNextTask(opts) {
+    const git = await readGitInfo(opts.cwd);
+    if (git.dirty === true) {
+        log.info(dim("Next-task suggestion skipped until the working tree is clean."));
+        return;
+    }
+    const briefPath = join(opts.cwd, BRIEF_REL);
+    const brief = (await readTextOrNull(briefPath)) ??
+        "(no project brief — run vibeops plan or add .vibeops/brief/project-brief.md)";
+    const priorDone = await readLastDoneSummary(opts.cwd);
+    const result = readSection(await readText(opts.taskFile), "Result");
+    const provider = await resolveAvailableLlmProvider(opts.cwd);
+    if (provider === null) {
+        log.info(dim(`Next-task suggestion skipped (no LLM). Connect Codex OAuth, Cursor Agent, or OPENAI_API_KEY.`));
+        return;
+    }
+    log.blank();
+    log.step(bold("Next iteration (LLM suggestion)"));
+    const providerLabel = provider === "codex-oauth"
+        ? "Codex OAuth"
+        : provider === "cursor-agent"
+            ? "Cursor Agent CLI"
+            : "OpenAI API";
+    log.info(dim(`  using ${providerLabel}`));
+    if (opts.dryRun === true) {
+        log.info(dim(`  dry-run: would write ${NEXT_TASK_SUGGESTION_REL}`));
+        return;
+    }
+    try {
+        const { text: raw } = await llmCompleteJson([
+            {
+                role: "system",
+                content: "You suggest the next small product iteration after an MVP shipped. Reply with JSON only: title, oneLineIdea, goal, scope (string array, 3-6 items), rationale.",
+            },
+            {
+                role: "user",
+                content: [
+                    `Project brief:\n${brief.slice(0, 8000)}`,
+                    priorDone
+                        ? `\nLast done summary (${LAST_DONE_SUMMARY_REL}):\n${priorDone.slice(0, 12000)}`
+                        : "",
+                    `\nMVP Result (TASK file):\n${result.slice(0, 6000)}`,
+                    "\nSuggest the next TASK (post-MVP), not a full replan.",
+                ].join("\n"),
+            },
+        ], { cwd: opts.cwd, provider });
+        const parsed = JSON.parse(raw);
+        const suggestion = {
+            title: String(parsed.title ?? "Next iteration"),
+            oneLineIdea: String(parsed.oneLineIdea ?? parsed.title ?? "Next feature slice"),
+            goal: String(parsed.goal ?? ""),
+            scope: Array.isArray(parsed.scope)
+                ? parsed.scope.map((x) => String(x))
+                : ["(define scope in vibeops plan)"],
+            rationale: String(parsed.rationale ?? ""),
+        };
+        const outPath = join(opts.cwd, NEXT_TASK_SUGGESTION_REL);
+        await writeText(outPath, renderSuggestionMarkdown(suggestion, priorDone));
+        log.ok(`Wrote ${cyan(NEXT_TASK_SUGGESTION_REL)}`);
+        log.info(`  ${dim("title")}  ${suggestion.title}`);
+        log.info(`  ${dim("idea")}   ${suggestion.oneLineIdea}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Next-task suggestion failed (${msg}).`);
+    }
+}
+/** Notion sync, dirty-tree cleanup, and optional next-task LLM suggestion after `vibeops done`. */
+export async function runDoneFollowUp(opts) {
+    await syncNotionAfterDone(opts);
+    const clean = await cleanupDirtyTree(opts);
+    if (clean) {
+        await suggestNextTask(opts);
+    }
+    log.blank();
+    log.info(bold("Next"));
+    log.info(`  · ${cyan("vibeops status")}`);
+    if (await pathExists(join(opts.cwd, LAST_DONE_SUMMARY_REL))) {
+        log.info(`  · ${cyan(LAST_DONE_SUMMARY_REL)} — what shipped last time`);
+    }
+    if (await pathExists(join(opts.cwd, NEXT_TASK_SUGGESTION_REL))) {
+        log.info(`  · ${cyan(NEXT_TASK_SUGGESTION_REL)} — suggested follow-up`);
+    }
+    log.info(`  · ${cyan("vibeops plan --idea \"…\"")} — start the next iteration when ready`);
+}

package/dist/lib/git.js

@@ -1,6 +1,9 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { dim, log } from "./logger.js";
 const exec = promisify(execFile);
+/** Avoid `maxBuffer` errors on large `git commit` / `git add` output. */
+const DEFAULT_GIT_MAX_BUFFER = 64 * 1024 * 1024;
 async function tryGit(cwd, args) {
     try {
         const { stdout } = await exec("git", args, { cwd });
@@ -10,8 +13,11 @@ async function tryGit(cwd, args) {
         return null;
     }
 }
-export async function runGit(cwd, args) {
-    const { stdout, stderr } = await exec("git", args, { cwd });
+export async function runGit(cwd, args, options = {}) {
+    const { stdout, stderr } = await exec("git", args, {
+        cwd,
+        maxBuffer: options.maxBuffer ?? DEFAULT_GIT_MAX_BUFFER,
+    });
     return { stdout, stderr };
 }
 export async function isGitRepository(cwd) {
@@ -83,14 +89,90 @@ export async function gitCreateBranch(cwd, name, startPoint) {
         args.push(startPoint);
     await runGit(cwd, args);
 }
+/**
+ * When only governance / VibeOps paths are dirty, stash them so `git switch` can proceed.
+ * Callers that switch branches should restore with {@link restoreGovernanceStashAfterSwitch}.
+ */
+export async function stashGovernanceIfBlocking(cwd) {
+    const git = await readGitInfo(cwd);
+    if (git.dirty !== true)
+        return false;
+    const gov = await gitGovernanceOnlyDirty(cwd);
+    if (!gov.onlyGovernance || gov.allPaths.length === 0)
+        return false;
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const tracked = [];
+    const untracked = [];
+    for (const e of entries) {
+        if (!isGovernanceDocumentationPath(e.path))
+            continue;
+        if (e.untracked)
+            untracked.push(e.path);
+        else
+            tracked.push(e.path);
+    }
+    let didStash = false;
+    if (tracked.length > 0) {
+        await runGit(cwd, [
+            "stash",
+            "push",
+            "-m",
+            "vibeops: governance before branch switch",
+            "--",
+            ...tracked,
+        ]);
+        didStash = true;
+    }
+    if (untracked.length > 0) {
+        try {
+            await runGit(cwd, [
+                "stash",
+                "push",
+                "-u",
+                "-m",
+                "vibeops: governance untracked before branch switch",
+                "--",
+                ...untracked,
+            ]);
+            didStash = true;
+        }
+        catch {
+            // Untracked generated files (e.g. cursor-implement-*.md) may not stash; switch can still proceed.
+        }
+    }
+    return didStash;
+}
+/** Re-apply governance paths stashed for a branch switch (e.g. new `docs/tasks/*.md`). */
+export async function restoreGovernanceStashAfterSwitch(cwd, didStash) {
+    if (!didStash)
+        return;
+    try {
+        await runGit(cwd, ["stash", "pop"]);
+        log.info(dim("Restored stashed governance paths on the task branch."));
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Could not restore stashed governance files (${msg}). Run ${dim("git stash pop")} manually.`);
+    }
+}
 export async function gitCheckout(cwd, ref) {
-    await runGit(cwd, ["checkout", ref]);
+    const stashed = await stashGovernanceIfBlocking(cwd);
+    if (stashed) {
+        log.info(dim("Stashed governance-only changes (.vibeops/, docs/) before branch switch."));
+    }
+    await runGit(cwd, ["switch", ref]);
+    await restoreGovernanceStashAfterSwitch(cwd, stashed);
 }
 export async function gitCheckoutNewBranch(cwd, name, startPoint) {
-    const args = ["checkout", "-b", name];
+    const stashed = await stashGovernanceIfBlocking(cwd);
+    if (stashed) {
+        log.info(dim("Stashed governance-only changes (.vibeops/, docs/) before branch switch."));
+    }
+    const args = ["switch", "-c", name];
     if (typeof startPoint === "string" && startPoint.length > 0)
         args.push(startPoint);
     await runGit(cwd, args);
+    await restoreGovernanceStashAfterSwitch(cwd, stashed);
 }
 export async function gitDeleteBranch(cwd, name, opts = {}) {
     const flag = opts.force === true ? "-D" : "-d";
@@ -167,12 +249,12 @@ function parsePorcelain(lines) {
     }
     return out;
 }
-/** Paths under these prefixes may stay uncommitted across `task done` / doc updates. */
+/** Paths under these prefixes may stay uncommitted across `start` / `done` / doc updates. */
 const GOVERNANCE_DOC_REL_PREFIXES = [
     "docs/tasks/",
     "docs/project/",
     "docs/logs/",
-    ".vibeops/state/",
+    ".vibeops/",
 ];
 function normalizeRepoRelPath(p) {
     return p.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -185,9 +267,109 @@ export function isGovernanceDocumentationPath(repoRelativePath) {
     }
     return false;
 }
+/** Build artifacts / deps — never auto-committed by `vibeops done` cleanup. */
+const AUTO_COMMIT_EXCLUDED_PREFIXES = [
+    "node_modules/",
+    ".next/",
+    ".pnpm-store/",
+    "dist/",
+    "build/",
+    ".turbo/",
+    "coverage/",
+    ".vercel/",
+    ".output/",
+    ".cache/",
+];
+const AUTO_COMMIT_EXCLUDED_EXACT = new Set([
+    "node_modules",
+    ".next",
+    "dist",
+    "build",
+]);
+export function isAutoCommitExcludedPath(repoRelativePath) {
+    const n = normalizeRepoRelPath(repoRelativePath);
+    if (AUTO_COMMIT_EXCLUDED_EXACT.has(n))
+        return true;
+    for (const prefix of AUTO_COMMIT_EXCLUDED_PREFIXES) {
+        if (n.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+export async function gitMergeInProgress(cwd) {
+    return (await tryGit(cwd, ["rev-parse", "-q", "--verify", "MERGE_HEAD"])) !== null;
+}
+/** Conflict paths from an in-progress merge (`git diff --diff-filter=U`). */
+export async function listUnmergedRelPaths(cwd) {
+    const res = await tryGit(cwd, ["diff", "--name-only", "--diff-filter=U"]);
+    if (res === null)
+        return [];
+    return res.stdout
+        .split("\n")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+/**
+ * During a merge, take the incoming branch version for governance / VibeOps paths
+ * (typical after `vibeops done` merge conflicts on `.vibeops/generated/*`).
+ */
+export async function tryResolveGovernanceUnmerged(cwd) {
+    const unmerged = await listUnmergedRelPaths(cwd);
+    const resolved = [];
+    for (const p of unmerged) {
+        if (!isGovernanceDocumentationPath(p))
+            continue;
+        try {
+            await runGit(cwd, ["checkout", "--theirs", "--", p]);
+            await runGit(cwd, ["add", "--", p]);
+            resolved.push(p);
+        }
+        catch {
+            // skip paths that cannot be auto-resolved
+        }
+    }
+    return resolved;
+}
+export async function listWorkingTreeRelPaths(cwd) {
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const all = new Set();
+    for (const e of entries) {
+        all.add(e.path);
+        if (typeof e.origPath === "string" && e.origPath.length > 0) {
+            all.add(e.origPath);
+        }
+    }
+    return [...all];
+}
+export function partitionPathsForAutoCommit(paths, opts = {}) {
+    const unmergedSet = new Set(opts.unmerged ?? []);
+    const committable = [];
+    const excluded = [];
+    const unmerged = [];
+    for (const p of paths) {
+        if (unmergedSet.has(p)) {
+            unmerged.push(p);
+            continue;
+        }
+        if (isAutoCommitExcludedPath(p))
+            excluded.push(p);
+        else
+            committable.push(p);
+    }
+    return { committable, excluded, unmerged };
+}
+export async function gitAddPaths(cwd, paths) {
+    if (paths.length === 0)
+        return;
+    const chunkSize = 80;
+    for (let i = 0; i < paths.length; i += chunkSize) {
+        const slice = paths.slice(i, i + chunkSize);
+        await runGit(cwd, ["add", "--", ...slice]);
+    }
+}
 /**
  * When the index/worktree is dirty, classify whether every changed path is
- * limited to governance docs (TASK files, project docs, logs, task state JSON).
+ * limited to governance docs and VibeOps metadata (`.vibeops/**`, docs/tasks, etc.).
  * Used by `vibeops task start` so `task done --finalize` on main does not
  * block the next TASK unless application code is also dirty.
  */

package/dist/lib/guide-state.js

@@ -0,0 +1,69 @@
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { pathExists, readTextOrNull, writeText } from "./filesystem.js";
+export const GUIDE_STATE_SCHEMA_VERSION = 1;
+export function guideStatePath(vibeopsDir) {
+    return join(vibeopsDir, "state", "guide.json");
+}
+export async function readGuideState(vibeopsDir) {
+    const path = guideStatePath(vibeopsDir);
+    const raw = await readTextOrNull(path);
+    if (raw === null || raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== GUIDE_STATE_SCHEMA_VERSION)
+            return null;
+        if (typeof parsed.stepId !== "string")
+            return null;
+        return {
+            schemaVersion: GUIDE_STATE_SCHEMA_VERSION,
+            taskId: typeof parsed.taskId === "string" ? parsed.taskId : null,
+            stepId: parsed.stepId,
+            history: Array.isArray(parsed.history)
+                ? parsed.history.filter((x) => typeof x === "string")
+                : [],
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeGuideState(vibeopsDir, state) {
+    const dir = join(vibeopsDir, "state");
+    if (!(await pathExists(dir))) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeText(guideStatePath(vibeopsDir), `${JSON.stringify(state, null, 2)}\n`);
+}
+export function pushGuideHistory(prev, taskId, stepId) {
+    const history = [...(prev?.history ?? [])];
+    if (prev?.stepId && prev.stepId !== stepId) {
+        history.push(prev.stepId);
+    }
+    return {
+        schemaVersion: GUIDE_STATE_SCHEMA_VERSION,
+        taskId,
+        stepId,
+        history,
+        updatedAt: new Date().toISOString(),
+    };
+}
+export function popGuideHistory(state) {
+    if (state.history.length === 0) {
+        return { next: null, stepId: null };
+    }
+    const history = [...state.history];
+    const stepId = history.pop();
+    return {
+        stepId,
+        next: {
+            schemaVersion: GUIDE_STATE_SCHEMA_VERSION,
+            taskId: state.taskId,
+            stepId,
+            history,
+            updatedAt: new Date().toISOString(),
+        },
+    };
+}

package/dist/lib/llm-complete.js

@@ -0,0 +1,62 @@
+import { probeCodexOAuthFile } from "./plan-codex-auth.js";
+import { codexOAuthTextCompletion } from "./plan-codex-responses.js";
+import { cursorAgentPrint, extractAgentAssistantText } from "./plan-llm-cursor-agent.js";
+import { probeCursorAgentCli, probeOpenAiApiKey } from "./plan-llm-detect.js";
+import { extractJsonObject, openAiChatCompletionJson, openAiChatCompletionText, } from "./plan-llm-openai.js";
+/** Non-interactive: Codex OAuth → Cursor Agent → OpenAI API key (same sources as `vibeops plan`). */
+export async function resolveAvailableLlmProvider(cwd) {
+    const codex = await probeCodexOAuthFile();
+    if (codex.ok)
+        return "codex-oauth";
+    const cursor = await probeCursorAgentCli(cwd);
+    if (cursor.ok)
+        return "cursor-agent";
+    const openai = await probeOpenAiApiKey();
+    if (openai.ok)
+        return "openai";
+    return null;
+}
+function formatMessagesForCursor(messages) {
+    return messages
+        .map((m) => `### ${m.role}\n\n${m.content}`)
+        .join("\n\n---\n\n");
+}
+export async function llmCompleteText(messages, opts) {
+    const provider = opts.provider ?? (await resolveAvailableLlmProvider(opts.cwd));
+    if (provider === null) {
+        throw new Error("No LLM provider available. Use Codex OAuth (~/.codex/auth.json), Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
+    }
+    if (provider === "openai") {
+        const text = await openAiChatCompletionText({ messages, model: opts.model });
+        return { text, provider };
+    }
+    if (provider === "codex-oauth") {
+        const text = await codexOAuthTextCompletion(messages, { model: opts.model });
+        return { text, provider };
+    }
+    const raw = await cursorAgentPrint({
+        cwd: opts.cwd,
+        prompt: formatMessagesForCursor(messages),
+        model: opts.model,
+    });
+    return { text: extractAgentAssistantText(raw), provider: "cursor-agent" };
+}
+export async function llmCompleteJson(messages, opts) {
+    const provider = opts.provider ?? (await resolveAvailableLlmProvider(opts.cwd));
+    if (provider === null) {
+        throw new Error("No LLM provider available. Use Codex OAuth (~/.codex/auth.json), Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
+    }
+    if (provider === "openai") {
+        const text = await openAiChatCompletionJson({ messages, model: opts.model });
+        return { text, provider };
+    }
+    const jsonMessages = [
+        ...messages,
+        {
+            role: "user",
+            content: "Reply with a single JSON object only. No markdown code fences or extra prose.",
+        },
+    ];
+    const { text: raw } = await llmCompleteText(jsonMessages, { ...opts, provider });
+    return { text: extractJsonObject(raw), provider };
+}