@goodtek/vibeops 0.3.0 → 0.7.22

package/dist/commands/rollback.js

@@ -0,0 +1,126 @@
+import { relative, resolve } from "node:path";
+import { gitBranchExists, gitCheckout, gitDeleteBranch, gitResetHard, readGitInfo, } from "../lib/git.js";
+import { commandTaskNotFoundMessage, resolveCommandTask, } from "../lib/resolve-command-task.js";
+import { bold, cyan, dim, log, red, yellow } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { readGitContext, readTaskFile, statusDisplay } from "../lib/task.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+function shellQuote(s) {
+    return /^[A-Za-z0-9._/\-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function strategyCommands(strategy, ctx) {
+    switch (strategy) {
+        case "branch-delete":
+            return [
+                `git switch ${shellQuote(ctx.baseBranch)}`,
+                `git branch -D ${shellQuote(ctx.taskBranch)}`,
+            ];
+        case "reset-base":
+            return [
+                `git switch ${shellQuote(ctx.taskBranch)}`,
+                `git reset --hard ${shellQuote(ctx.baseCommit)}`,
+            ];
+        case "revert-merge":
+            return [
+                `git switch ${shellQuote(ctx.baseBranch)}`,
+                `git log --oneline --merges ${shellQuote(ctx.baseBranch)} | head -5`,
+                `git revert -m 1 <merge-sha>`,
+            ];
+    }
+}
+function strategyRisk(strategy) {
+    switch (strategy) {
+        case "branch-delete":
+            return "Deletes the task branch and any unmerged work on it.";
+        case "reset-base":
+            return "Hard-resets the task branch to the base commit.";
+        case "revert-merge":
+            return "Manual revert on main after a merge was pushed.";
+    }
+}
+const STRATEGIES = ["branch-delete", "reset-base", "revert-merge"];
+export async function rollbackCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const resolved = await resolveCommandTask(paths, cwd, taskRef);
+    if (resolved === null) {
+        log.error(commandTaskNotFoundMessage(taskRef));
+        process.exitCode = 1;
+        return;
+    }
+    const { taskFile } = resolved;
+    const meta = await readTaskFile(taskFile);
+    const ctx = await readGitContext(taskFile);
+    const git = await readGitInfo(cwd);
+    log.info(bold(`vibeops rollback ${meta.id}`));
+    log.info(`  ${dim("file")}    ${relOrAbs(cwd, taskFile)}`);
+    log.info(`  ${dim("status")}  ${statusDisplay(meta.status)}`);
+    log.blank();
+    if (ctx === null) {
+        log.warn(`No Git Context in TASK file. Run ${cyan("vibeops start")} first.`);
+        if (options.dryRun !== true) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    log.info(bold("Git Context"));
+    log.info(`  base  ${ctx.baseBranch} @ ${ctx.baseCommit}`);
+    log.info(`  task  ${cyan(ctx.taskBranch)}`);
+    log.blank();
+    for (const s of STRATEGIES) {
+        const destructive = s === "reset-base";
+        log.info(`  ${bold(s)}  ${destructive ? red("destructive") : yellow("safe")}`);
+        log.info(`    ${dim(strategyRisk(s))}`);
+        for (const cmd of strategyCommands(s, ctx)) {
+            log.info(`      ${dim("$")} ${cmd}`);
+        }
+        log.blank();
+    }
+    if (options.confirm !== true && options.confirmDestructive !== true) {
+        log.info(`Guidance only. Use ${cyan("--confirm")} or ${cyan("--confirm-destructive")} to run.`);
+        return;
+    }
+    const strategy = options.strategy ?? "branch-delete";
+    if (!STRATEGIES.includes(strategy)) {
+        log.error(`Unknown strategy: ${strategy}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (strategy === "revert-merge") {
+        log.info(`${yellow("!")} revert-merge is manual only — run the commands above.`);
+        return;
+    }
+    if (strategy === "reset-base" && options.confirmDestructive !== true) {
+        log.error("reset-base requires --confirm-destructive.");
+        process.exitCode = 1;
+        return;
+    }
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        process.exitCode = 1;
+        return;
+    }
+    if (options.dryRun === true) {
+        log.info(bold(`dry-run (${strategy}):`));
+        for (const cmd of strategyCommands(strategy, ctx)) {
+            log.info(`  ${dim("$")} ${cmd}`);
+        }
+        return;
+    }
+    if (strategy === "branch-delete") {
+        if (git.branch === ctx.taskBranch)
+            await gitCheckout(cwd, ctx.baseBranch);
+        if (!options.keepBranch && (await gitBranchExists(cwd, ctx.taskBranch))) {
+            await gitDeleteBranch(cwd, ctx.taskBranch, { force: true });
+            log.ok(`Deleted ${ctx.taskBranch}`);
+        }
+        return;
+    }
+    if (git.branch !== ctx.taskBranch)
+        await gitCheckout(cwd, ctx.taskBranch);
+    await gitResetHard(cwd, ctx.baseCommit);
+    log.ok(`Reset ${ctx.taskBranch} → ${ctx.baseCommit}`);
+}

package/dist/commands/start.js

@@ -0,0 +1,129 @@
+import { join, relative, resolve } from "node:path";
+import { branchNameForTaskFile, isMvpTaskId, readGitContext, readTaskFile, upsertGitContext, updateInlineStatus, } from "../lib/task.js";
+import { detectDefaultBranch, gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, readGitInfo, } from "../lib/git.js";
+import { MVP_BUILD_PROMPT_REL } from "../lib/mvp-constants.js";
+import { taskBuildPromptRel } from "../lib/task-add-build-prompt.js";
+import { pathExists } from "../lib/filesystem.js";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { commandTaskNotFoundMessage, resolveCommandTask, } from "../lib/resolve-command-task.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+export async function startCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const resolved = await resolveCommandTask(paths, cwd, taskRef);
+    if (resolved === null) {
+        log.error(commandTaskNotFoundMessage(taskRef));
+        process.exitCode = 1;
+        return;
+    }
+    const { taskId, taskFile, source } = resolved;
+    if (source === "backlog-active") {
+        log.info(dim(`No TASK-mvp — continuing backlog with ${cyan(taskId)}.`));
+    }
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        if (options.dryRun === true) {
+            log.info(bold("dry-run — would:"));
+            log.info(`  · require a git repo under ${cwd}`);
+            log.info(`  · git checkout -b task/mvp-*`);
+            log.info(`  · Status → In Progress + Git Context`);
+            return;
+        }
+        log.error(`Not a git repository: ${cwd}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (git.dirty === true && options.allowDirty !== true) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            log.error("Git working tree is dirty. Commit or stash, or use --allow-dirty.");
+            if (gov.nonGovernancePaths.length > 0) {
+                for (const p of gov.nonGovernancePaths.slice(0, 16)) {
+                    log.info(`  ${dim("·")} ${p}`);
+                }
+                if (gov.nonGovernancePaths.length > 16) {
+                    log.info(`  ${dim("·")} … and ${gov.nonGovernancePaths.length - 16} more`);
+                }
+            }
+            log.blank();
+            log.info(dim("Options:"));
+            log.info(`  ${dim("1.")} Commit on ${git.branch ?? "HEAD"}: git add … && git commit`);
+            log.info(`  ${dim("2.")} Stash: git stash push -u -m "wip"`);
+            log.info(`  ${dim("3.")} Carry WIP into task branch: ${cyan(`vibeops start ${taskId} --allow-dirty`)}`);
+            log.info(dim("  If this is TASK-009 scaffold on main, run vibeops done TASK-009 or commit it before TASK-010."));
+            process.exitCode = 1;
+            return;
+        }
+        log.warn("Only governance / VibeOps paths are dirty — proceeding.");
+    }
+    const baseBranch = git.branch ?? (await detectDefaultBranch(cwd)) ?? "main";
+    const baseCommit = (await gitHeadCommit(cwd)) ?? "";
+    if (baseCommit.length === 0) {
+        log.error("No commits on HEAD yet.");
+        process.exitCode = 1;
+        return;
+    }
+    const taskBranch = branchNameForTaskFile(taskFile);
+    const startedAt = new Date().toISOString();
+    const ctx = { baseBranch, baseCommit, taskBranch, startedAt };
+    const meta = await readTaskFile(taskFile);
+    const existingCtx = await readGitContext(taskFile);
+    const branchExists = await gitBranchExists(cwd, taskBranch);
+    log.info(bold(`vibeops start`));
+    log.info(`  ${dim("task")}         ${taskId}`);
+    log.info(`  ${dim("file")}         ${relOrAbs(cwd, taskFile)}`);
+    if (branchExists && existingCtx) {
+        log.info(`  ${dim("base branch")}  ${existingCtx.baseBranch} @ ${existingCtx.baseCommit.slice(0, 7)}`);
+    }
+    else {
+        log.info(`  ${dim("base branch")}  ${baseBranch} @ ${baseCommit.slice(0, 7)}`);
+    }
+    log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
+    log.blank();
+    if (options.dryRun === true) {
+        log.info(bold("dry-run — would:"));
+        log.info(branchExists
+            ? `  · git switch ${taskBranch} (branch exists)`
+            : `  · git checkout -b ${taskBranch}`);
+        log.info(`  · Status → In Progress + Git Context in TASK file`);
+        return;
+    }
+    if (branchExists) {
+        await gitCheckout(cwd, taskBranch);
+        if (meta.status === "planned") {
+            await updateInlineStatus(taskFile, "in_progress");
+        }
+        if (existingCtx === null) {
+            await upsertGitContext(taskFile, ctx);
+        }
+        if (existingCtx?.baseBranch.startsWith("chore/vibeops-post-")) {
+            log.warn(`Git Context base is ${existingCtx.baseBranch} — merge or delete that chore branch, then fix base in the TASK file if needed.`);
+        }
+        log.ok(`Resumed existing branch ${taskBranch}.`);
+    }
+    else {
+        await gitCheckoutNewBranch(cwd, taskBranch, baseBranch);
+        await updateInlineStatus(taskFile, "in_progress");
+        await upsertGitContext(taskFile, ctx);
+        log.ok(`Branch ${taskBranch} ready.`);
+    }
+    log.blank();
+    log.info(bold("Build in Cursor"));
+    if (isMvpTaskId(taskId)) {
+        log.info(`  Drag ${cyan(relOrAbs(cwd, MVP_BUILD_PROMPT_REL))} into a new chat.`);
+    }
+    else {
+        const taskBuildRel = taskBuildPromptRel(taskId);
+        if (await pathExists(join(cwd, taskBuildRel))) {
+            log.info(`  Drag ${cyan(relOrAbs(cwd, taskBuildRel))} into a new chat.`);
+        }
+        else {
+            log.info(`  Open ${cyan(relOrAbs(cwd, taskFile))} and implement per Acceptance Criteria.`);
+        }
+    }
+    log.info(`  When done: fill Result / Test Result, then ${cyan(`vibeops done ${taskId}`)}.`);
+}

package/dist/commands/task-add.js

@@ -0,0 +1,200 @@
+import { mkdir } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { doneCommand } from "./done.js";
+import { startCommand } from "./start.js";
+import { pathExists, writeText } from "../lib/filesystem.js";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+import { askInput, askSelect, yesNoSelect } from "../lib/inquirer-helpers.js";
+import { projectPaths } from "../lib/paths.js";
+import { readConfig } from "../lib/config.js";
+import { slugify } from "../lib/slug.js";
+import { defaultBuildPromptForTask, gatherTaskPlanViaLlm, llmGenerateQuickTask, } from "../lib/task-add-llm.js";
+import { taskBuildPromptAbs, taskBuildPromptRel, } from "../lib/task-add-build-prompt.js";
+import { allocateNextTaskNumber, buildWorkNowTaskMarkdown, formatTaskId, titleFromIdea, uniqueTaskPath, } from "../lib/task-scaffold.js";
+import { readGitInfo } from "../lib/git.js";
+import { loadActionableTasks, pickInProgressTask, pickLatestDoneTask, } from "../lib/task.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+async function maybeCloseInProgressTask(root, inProgress, nonInteractive) {
+    if (nonInteractive)
+        return true;
+    log.info(`Current TASK ${bold(inProgress.id)} is ${cyan("In Progress")}: ${dim(inProgress.title)}`);
+    log.blank();
+    const closeFirst = await yesNoSelect({
+        message: "Close this TASK first (commit, merge, clean tree) before starting a new one?",
+        defaultValue: true,
+    });
+    if (!closeFirst) {
+        log.warn(`Keeping ${inProgress.id} open — finish it or run ${cyan("vibeops done")} before switching branches.`);
+        return true;
+    }
+    log.blank();
+    log.step(`Closing ${inProgress.id} via vibeops done…`);
+    await doneCommand(inProgress.id, { cwd: root, allowDirty: true });
+    if (process.exitCode !== undefined && process.exitCode !== 0) {
+        log.error("Could not close the current TASK — fix blockers above, then run task add again.");
+        return false;
+    }
+    log.blank();
+    return true;
+}
+async function pickAddMode(nonInteractive) {
+    if (nonInteractive)
+        return "just";
+    const choice = await askSelect({
+        message: "How do you want to create the new TASK?",
+        nonInteractive: false,
+        choices: ["Just create task", "Create plan using LLM"],
+        default: "Just create task",
+    });
+    return choice.startsWith("Create plan") ? "plan" : "just";
+}
+export async function taskAddCommand(opts = {}) {
+    const root = resolve(opts.cwd ?? process.cwd());
+    const dryRun = opts.dryRun === true;
+    const nonInteractive = opts.nonInteractive === true || dryRun || process.stdin.isTTY !== true;
+    log.info(bold("vibeops task add"));
+    log.blank();
+    let tasks = await loadActionableTasks(projectPaths(root).docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null) {
+        const ok = await maybeCloseInProgressTask(root, inProgress, nonInteractive);
+        if (!ok)
+            return;
+        tasks = await loadActionableTasks(projectPaths(root).docsTasks);
+    }
+    const mode = await pickAddMode(nonInteractive);
+    const latestDone = pickLatestDoneTask(tasks);
+    const nextNum = allocateNextTaskNumber(tasks);
+    const taskId = formatTaskId(nextNum);
+    const ideaDefault = opts.idea?.trim() ||
+        (latestDone ? `Follow-up after ${latestDone.id}` : "New work slice");
+    const idea = await askInput({
+        message: mode === "plan"
+            ? "What do you want to build? (starting point for planning)"
+            : "What are you doing now? (short)",
+        nonInteractive,
+        default: ideaDefault,
+        required: true,
+    });
+    const paths = projectPaths(root);
+    const config = await readConfig(root);
+    const projectName = config?.name ?? "project";
+    let title = titleFromIdea(idea);
+    let slug = slugify(title);
+    let markdown = "";
+    let buildPromptMarkdown = null;
+    let llmNote = null;
+    if (mode === "plan") {
+        if (dryRun) {
+            log.info(`[dry-run] Would run LLM planning for ${bold(taskId)}`);
+            log.info(dim(`  idea: ${idea}`));
+            return;
+        }
+        if (nonInteractive) {
+            log.error("Create plan using LLM requires an interactive terminal (omit --non-interactive).");
+            process.exitCode = 1;
+            return;
+        }
+        log.step("LLM task planning (interactive questions)…");
+        const planned = await gatherTaskPlanViaLlm({
+            cwd: root,
+            taskId,
+            projectName,
+            seedIdea: idea,
+        });
+        if (planned === null) {
+            log.error("No LLM provider available for planning.");
+            process.exitCode = 1;
+            return;
+        }
+        markdown = planned.markdown;
+        buildPromptMarkdown = planned.buildPromptMarkdown;
+        llmNote = `planned via ${planned.provider}`;
+        const header = /^#\s+TASK-\d+:\s*(.+)$/m.exec(markdown);
+        if (header?.[1])
+            title = header[1].trim();
+        slug = slugify(title);
+    }
+    else {
+        let quick = null;
+        if (!nonInteractive || opts.idea) {
+            quick = await llmGenerateQuickTask({
+                cwd: root,
+                taskId,
+                idea,
+                latestDone,
+            });
+        }
+        if (quick !== null) {
+            title = quick.title;
+            slug = quick.slug;
+            markdown = quick.markdown;
+            llmNote = `quick scaffold via ${quick.provider}`;
+        }
+        else {
+            const parent = inProgress ?? latestDone;
+            markdown = buildWorkNowTaskMarkdown({
+                id: taskId,
+                title,
+                idea,
+                mvpPhase: parent?.mvpPhase?.trim() || "Work-now slice",
+                spawnedFrom: parent?.id,
+            });
+            if (!nonInteractive) {
+                log.warn("LLM unavailable — using minimal TASK template.");
+            }
+        }
+    }
+    const { filePath } = uniqueTaskPath(paths.docsTasks, taskId, slug, tasks.map((t) => t.filePath));
+    const relFile = relOrAbs(root, filePath);
+    const taskRelative = relFile.replace(/\\/g, "/");
+    const buildRel = taskBuildPromptRel(taskId);
+    const buildAbs = taskBuildPromptAbs(root, taskId);
+    if (buildPromptMarkdown === null) {
+        buildPromptMarkdown = defaultBuildPromptForTask(projectName, taskId, taskRelative);
+    }
+    if (dryRun) {
+        log.info(`[dry-run] Would create ${bold(taskId)} → ${cyan(relFile)}`);
+        if (mode === "plan") {
+            log.info(`[dry-run] Would write ${cyan(buildRel)}`);
+        }
+        log.blank();
+        return;
+    }
+    if (await pathExists(filePath)) {
+        throw new Error(`TASK file already exists: ${relFile}`);
+    }
+    await writeText(filePath, markdown);
+    await mkdir(join(root, ".vibeops", "generated"), { recursive: true });
+    await writeText(buildAbs, buildPromptMarkdown);
+    log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
+    if (mode === "plan") {
+        log.ok(`Cursor build doc → ${cyan(buildRel)}`);
+    }
+    if (llmNote)
+        log.skip(llmNote);
+    const git = await readGitInfo(root);
+    if (!git.isRepo) {
+        log.warn("Not a git repository — TASK file saved. Run vibeops init --git, then start.");
+        return;
+    }
+    log.blank();
+    log.step(`Starting ${taskId} (branch + In Progress)…`);
+    await startCommand(taskId, { cwd: root, allowDirty: true });
+    if (process.exitCode !== undefined && process.exitCode !== 0) {
+        log.warn(`TASK file exists but start failed — run ${cyan(`vibeops start ${taskId}`)} when Git is ready.`);
+        return;
+    }
+    log.blank();
+    if (mode === "plan") {
+        log.info(bold("Build in Cursor"));
+        log.info(`  Drag ${cyan(buildRel)} into a new chat and implement.`);
+    }
+    else {
+        log.info(bold("Work in Cursor"));
+        log.info(`  Edit ${cyan(relFile)} freely, then ${cyan(`vibeops done ${taskId}`)} when finished.`);
+    }
+}

package/dist/commands/task-status.js

@@ -0,0 +1,122 @@
+import { resolve } from "node:path";
+import { collectTaskStatusBrief, taskStatusBriefToJson, } from "../lib/task-status-brief.js";
+import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
+function sectionFilled(ok) {
+    return ok ? green("filled") : yellow("empty");
+}
+function printHuman(brief) {
+    log.blank();
+    log.info(bold("─".repeat(56)));
+    log.info(bold("  VibeOps · TASK briefing"));
+    log.info(bold("─".repeat(56)));
+    if (!brief.isVibeopsProject) {
+        log.info(`  ${dim("Project")}  ${yellow("not a VibeOps project")} (.vibeops.json missing)`);
+        if (brief.git.isRepo && brief.git.branch) {
+            log.info(`  ${dim("Git")}      ${brief.git.branch}`);
+        }
+        log.blank();
+        log.info(`  ${dim("Next")}     ${cyan("vibeops init")}`);
+        log.info(bold("─".repeat(56)));
+        log.blank();
+        return;
+    }
+    if (brief.projectName) {
+        log.info(`  ${dim("Project")}  ${brief.projectName}`);
+    }
+    if (brief.counts) {
+        const c = brief.counts;
+        log.info(`  ${dim("Backlog")}  ${c.total} tasks · ${cyan(String(c.in_progress))} in progress · ${c.planned} planned · ${c.done} done`);
+    }
+    if (brief.inProgressTasks.length > 1) {
+        log.blank();
+        log.info(bold("  In progress (multiple)"));
+        for (const t of brief.inProgressTasks) {
+            log.info(`    ${cyan(t.id)} — ${t.title || dim("(no title)")}`);
+        }
+    }
+    log.blank();
+    if (brief.activeTask) {
+        const t = brief.activeTask;
+        log.info(`  ${dim("Focus")}    ${cyan(t.id)} — ${t.title || dim("(no title)")}`);
+        log.info(`  ${dim("Status")}  ${t.status}`);
+        if (t.mvpPhase)
+            log.info(`  ${dim("Phase")}   ${t.mvpPhase}`);
+        log.info(`  ${dim("File")}     ${t.file}`);
+    }
+    else if (brief.mode === "post-mvp" && brief.referenceTask) {
+        log.info(`  ${dim("Focus")}    ${dim("MVP/backlog complete — last:")} ${cyan(brief.referenceTask.id)}`);
+    }
+    else {
+        log.info(`  ${dim("Focus")}    ${dim("(none — run vibeops plan or task add)")}`);
+    }
+    if (brief.sections) {
+        log.blank();
+        log.info(bold("  Progress"));
+        if (brief.sections.goalExcerpt.length > 0) {
+            log.info(`    ${dim("Goal")}  ${brief.sections.goalExcerpt}`);
+        }
+        log.info(`    ${dim("Result")}  ${sectionFilled(brief.sections.resultFilled)} · ${dim("Test Result")}  ${sectionFilled(brief.sections.testResultFilled)}`);
+        if (brief.sections.acceptanceCriteriaCount > 0) {
+            log.info(`    ${dim("AC")}      ${brief.sections.acceptanceCriteriaCount} acceptance criteria`);
+        }
+    }
+    log.blank();
+    log.info(bold("  Git"));
+    if (!brief.git.isRepo) {
+        log.info(`    ${yellow("not a git repository")}`);
+    }
+    else {
+        const branch = brief.git.branch ?? "(detached)";
+        log.info(`    ${dim("HEAD")}     ${branch}`);
+        if (brief.git.dirty === true)
+            log.info(`    ${dim("Tree")}    ${yellow("dirty")}`);
+        else if (brief.git.dirty === false)
+            log.info(`    ${dim("Tree")}    ${green("clean")}`);
+        if (brief.git.expectedTaskBranch) {
+            const on = brief.git.onTaskBranch === true
+                ? green("yes")
+                : brief.git.onTaskBranch === false
+                    ? yellow("no")
+                    : dim("—");
+            const exists = brief.git.taskBranchExists === true
+                ? dim("exists")
+                : brief.git.taskBranchExists === false
+                    ? dim("not created")
+                    : "";
+            log.info(`    ${dim("Task br.")}  ${brief.git.expectedTaskBranch} · on branch: ${on}${exists ? ` · ${exists}` : ""}`);
+        }
+        if (brief.git.baseBranch) {
+            log.info(`    ${dim("Base")}     ${brief.git.baseBranch}`);
+        }
+    }
+    if (brief.artifacts.length > 0) {
+        log.blank();
+        log.info(bold("  Cursor artifacts"));
+        for (const a of brief.artifacts)
+            log.info(`    ${cyan(a)}`);
+    }
+    log.blank();
+    log.info(bold(`  Step: ${brief.workflow.stepTitle}`));
+    for (const line of brief.workflow.youDo) {
+        log.info(`    ${dim("·")} ${line}`);
+    }
+    if (brief.workflow.suggestedCommand) {
+        log.blank();
+        log.info(`  ${dim("Suggested")}  ${cyan(brief.workflow.suggestedCommand)}`);
+    }
+    log.info(bold("─".repeat(56)));
+    log.blank();
+}
+export async function taskStatusCommand(opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    const brief = await collectTaskStatusBrief(cwd);
+    if (opts.json === true) {
+        log.raw(taskStatusBriefToJson(brief));
+    }
+    else {
+        printHuman(brief);
+    }
+    if (!brief.isVibeopsProject) {
+        process.exitCode = 1;
+    }
+}

package/dist/lib/brief.js

@@ -195,7 +195,7 @@ export async function gatherBrief(inputs) {
     const meta = {
         vibeopsVersion: VERSION,
         generatedAt: new Date().toISOString(),
-        source: inputs.legacyWizard === true ? "legacy-wizard" : inputs.nonInteractive ? "non-interactive" : "interactive",
+        source: inputs.nonInteractive ? "non-interactive" : "interactive",
         schemaVersion: PROJECT_BRIEF_SCHEMA_VERSION,
         assumptions,
     };

package/dist/lib/cursor-task-prompt.js

@@ -0,0 +1,60 @@
+import { join, relative } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { pathExists, writeText } from "./filesystem.js";
+import { hasNonEmptySection } from "./task.js";
+import { VERSION } from "../version.js";
+export function cursorImplementPromptRel(taskId) {
+    const slug = taskId.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+    return `.vibeops/generated/cursor-implement-${slug}.md`;
+}
+export function buildCursorImplementPrompt(opts) {
+    const fill = [];
+    if (opts.fillResult)
+        fill.push("**Result**");
+    if (opts.fillTestResult)
+        fill.push("**Test Result**");
+    const fillLine = fill.length > 0
+        ? `4. Update ${fill.join(" and ")} in \`${opts.taskPath}\` (replace Pending / (not yet) placeholders).`
+        : "";
+    return `# Implement ${opts.taskId}
+
+Project: \`${opts.projectName}\` (VibeOps ${opts.vibeopsVersion})
+
+Read and follow the **entire** TASK file:
+
+\`${opts.taskPath}\`
+
+Procedure:
+
+1. Work only inside **Scope** and **Acceptance Criteria** in that file.
+2. **Search** the repo for existing patterns before adding code or docs.
+3. Do the work required by this TASK (implementation, spec, or docs — per Scope / Out of Scope).
+${fillLine ? `${fillLine}\n` : ""}5. Do not touch other TASKs. No git push or merge.
+
+When finished, run \`vibeops next\` and choose Refresh, then \`vibeops done ${opts.taskId}\`.
+`;
+}
+/** Write \`.vibeops/generated/cursor-implement-*.md\` when Result/Test need filling. */
+export async function ensureCursorImplementPrompt(cwd, config, task, body) {
+    const fillResult = !hasNonEmptySection(body, "Result");
+    const fillTestResult = !hasNonEmptySection(body, "Test Result");
+    if (!fillResult && !fillTestResult)
+        return null;
+    const rel = cursorImplementPromptRel(task.id);
+    const taskPath = relative(cwd, task.filePath).replace(/\\/g, "/");
+    const projectName = config?.name ?? "project";
+    const text = buildCursorImplementPrompt({
+        projectName,
+        taskId: task.id,
+        taskPath,
+        vibeopsVersion: VERSION,
+        fillResult,
+        fillTestResult,
+    });
+    const outDir = join(cwd, ".vibeops", "generated");
+    if (!(await pathExists(outDir))) {
+        await mkdir(outDir, { recursive: true });
+    }
+    await writeText(join(cwd, rel), text);
+    return { rel, fillResult, fillTestResult };
+}