@goodtek/vibeops 2.2.1 → 2.4.0

package/dist/commands/task-ship.js

@@ -1,13 +1,55 @@
 import { resolve } from "node:path";
 import { readText } from "../lib/filesystem.js";
+import { requireGitConfig } from "../lib/git-config.js";
+import { gitCommitsAhead, gitHeadCommit, gitPush, gitRemoteBranchExists, readGitInfo, } from "../lib/git.js";
+import { askYesNo, isInteractiveSession } from "../lib/inquirer-helpers.js";
 import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
-import { resolveTask, taskNotFoundMessage } from "../lib/resolve-task.js";
+import { prNumberFromUrl } from "../lib/pr-create.js";
+import { resolveShipTarget, taskNotFoundMessage } from "../lib/resolve-task.js";
 import { relPath } from "../lib/task-context.js";
-import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } from "../lib/task-git-commit.js";
+import { resolveShipCommitMessage } from "../lib/task-commit-msg.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, } from "../lib/task-git-commit.js";
+import { runPostMergeNewCycle } from "../lib/task-new-cycle.js";
 import { applyTaskShipMemory, fallbackResultSections, llmCompleteTaskShip, writeTaskResultSections, } from "../lib/task-ship-llm.js";
+import { detectShipPrState, prRefLabel, resolveShipAction, } from "../lib/task-ship-state.js";
 import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
 import { hasNonEmptySection, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+function describePushFailure(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("protected") ||
+        lower.includes("pre-receive") ||
+        lower.includes("gh006") ||
+        lower.includes("hook declined")) {
+        return "Push rejected by branch protection. Adjust the rule on the host (or push via the MR), then rerun.";
+    }
+    if (lower.includes("non-fast-forward") ||
+        lower.includes("fetch first") ||
+        lower.includes("rejected") ||
+        lower.includes("behind")) {
+        return "Push rejected — the remote branch has commits you don't. Pull/rebase the task branch, then rerun.";
+    }
+    return `git push failed: ${message}`;
+}
+function warnPlaceholderSections(body) {
+    const resultOk = hasNonEmptySection(body, "Result");
+    const testOk = hasNonEmptySection(body, "Test Result");
+    if (!resultOk || !testOk) {
+        log.warn("Result / Test Result still look like placeholders (docs-before-ship). Update the TASK file before merge.");
+    }
+}
+async function ensureOnTaskBranch(cwd, gitCtx, dryRun) {
+    const git = await readGitInfo(cwd);
+    if (git.branch === gitCtx.taskBranch)
+        return true;
+    const where = git.branch ?? "(detached)";
+    if (dryRun) {
+        log.warn(`Current branch is ${where}, not ${gitCtx.taskBranch}.`);
+        return true;
+    }
+    log.error(`On ${where}, not ${gitCtx.taskBranch}. Switch with \`git switch ${gitCtx.taskBranch}\` and rerun.`);
+    return false;
+}
 async function commitShipMetadata(opts) {
     if (opts.dryRun) {
         log.info(dim("  would set Status → Shipped"));
@@ -21,23 +63,10 @@ async function commitShipMetadata(opts) {
         log.warn("No file changes for ship metadata commit — check TASK Status on the remote branch.");
     }
 }
-export async function taskShipCommand(taskRef, options = {}) {
-    const cwd = resolve(options.cwd ?? process.cwd());
-    const paths = projectPaths(cwd);
-    const dryRun = options.dryRun === true;
-    const resolved = await resolveTask(paths, cwd, taskRef);
-    if (resolved === null) {
-        log.error(taskNotFoundMessage(taskRef));
-        process.exitCode = 1;
-        return;
-    }
-    const { taskId, taskFile } = resolved;
-    const meta = await readTaskFile(taskFile);
-    const body = await readText(taskFile);
-    const relFile = relPath(cwd, taskFile);
-    log.info(bold(`vibeops task ship ${taskId}`));
-    log.info(`  ${dim("file")}  ${relFile}`);
-    log.blank();
+/** State 1: first submit — push the task branch and open a new PR/MR. */
+async function runFirstShip(ctx) {
+    const { cwd, taskId, taskFile, meta, relFile, dryRun, nonInteractive, options } = ctx;
+    let body = ctx.body;
     let resultOk = hasNonEmptySection(body, "Result");
     let testOk = hasNonEmptySection(body, "Test Result");
     if (!resultOk || !testOk) {
@@ -68,9 +97,9 @@ export async function taskShipCommand(taskRef, options = {}) {
                 await writeTaskResultSections(taskFile, fb.result, fb.testResult);
             }
         }
-        const body2 = dryRun ? body : await readText(taskFile);
-        resultOk = hasNonEmptySection(body2, "Result");
-        testOk = hasNonEmptySection(body2, "Test Result");
+        body = dryRun ? body : await readText(taskFile);
+        resultOk = hasNonEmptySection(body, "Result");
+        testOk = hasNonEmptySection(body, "Test Result");
     }
     log.info(bold("Sections"));
     log.info(`  ${resultOk ? green("✓") : yellow("·")} Result`);
@@ -86,15 +115,10 @@ export async function taskShipCommand(taskRef, options = {}) {
         if (!resultOk || !testOk) {
             log.info("  · LLM fill Result / Test Result + patch docs/project/*");
         }
-        log.info("  · commit implementation + ship metadata (Status → Shipped)");
-        log.info("  · push task branch once, open MR/PR (unless --no-pr)");
+        log.info("  · commit implementation (TASK-scoped message) + ship metadata (Status → Shipped)");
+        log.info("  · push task branch once, open a new MR/PR (unless --no-pr)");
         const partsDry = parseTaskFilename(taskFile);
-        await commitShipMetadata({
-            cwd,
-            taskFile,
-            taskId: partsDry.id,
-            dryRun: true,
-        });
+        await commitShipMetadata({ cwd, taskFile, taskId: partsDry.id, dryRun: true });
         await finishTaskWithPullRequest({
             cwd,
             taskFile,
@@ -103,33 +127,223 @@ export async function taskShipCommand(taskRef, options = {}) {
         });
         return;
     }
-    const parts = parseTaskFilename(taskFile);
-    await commitDirtyWorkingTree(cwd, featCommitMessageFor(parts.id, meta.title), false);
     const gitCtx = await readGitContext(taskFile);
-    if (gitCtx !== null) {
-        await commitShipMetadata({
+    if (gitCtx !== null && !(await ensureOnTaskBranch(cwd, gitCtx, dryRun))) {
+        process.exitCode = 1;
+        return;
+    }
+    const parts = parseTaskFilename(taskFile);
+    if (options.noCommit === true) {
+        const git = await readGitInfo(cwd);
+        if (git.dirty === true) {
+            log.warn("Uncommitted changes left in place (--no-commit); committing ship metadata only.");
+        }
+    }
+    else {
+        const message = await resolveShipCommitMessage({
             cwd,
-            taskFile,
             taskId: parts.id,
-            dryRun: false,
+            title: meta.title,
+            provided: options.message,
+            nonInteractive,
         });
-        const prResult = await finishTaskWithPullRequest({
+        await commitDirtyWorkingTree(cwd, message, false);
+    }
+    if (gitCtx === null) {
+        log.info(dim("No Git Context — push/MR skipped."));
+        return;
+    }
+    await commitShipMetadata({ cwd, taskFile, taskId: parts.id, dryRun: false });
+    const prResult = await finishTaskWithPullRequest({
+        cwd,
+        taskFile,
+        skipPr: options.noPr === true,
+    });
+    if (!prResult.ok) {
+        log.error("TASK left In Progress — fix push/MR, then rerun task ship.");
+        process.exitCode = 1;
+        return;
+    }
+    log.blank();
+    if (prResult.mergeRequestUrl && prResult.mergeRequestUrl !== "(dry-run)") {
+        const ref = prRefLabel(prNumberFromUrl(prResult.mergeRequestUrl));
+        log.ok(`Created PR ${ref} → ${prResult.mergeRequestUrl}`);
+    }
+    else if (options.noPr === true) {
+        log.ok(`Pushed ${gitCtx.taskBranch} (no PR created — --no-pr).`);
+    }
+    else {
+        log.ok(`Pushed ${gitCtx.taskBranch} (create the MR/PR manually).`);
+    }
+    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+}
+/** State 2: an open PR exists — commit + push to update it (no new PR). */
+async function runUpdateOpenPr(ctx) {
+    const { cwd, taskId, taskFile, meta, body, prCtx, dryRun, nonInteractive, options } = ctx;
+    const gitCtx = await readGitContext(taskFile);
+    if (gitCtx === null) {
+        log.error("No Git Context — cannot update the open PR.");
+        process.exitCode = 1;
+        return;
+    }
+    let gitCfg;
+    try {
+        gitCfg = await requireGitConfig(cwd);
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+        return;
+    }
+    const remote = gitCfg.remote;
+    if (!(await ensureOnTaskBranch(cwd, gitCtx, dryRun))) {
+        process.exitCode = 1;
+        return;
+    }
+    warnPlaceholderSections(body);
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        if (options.noCommit === true) {
+            log.info("  · skip commit (--no-commit); push committed history only");
+        }
+        else {
+            log.info("  · commit working tree with a TASK-scoped message");
+        }
+        log.info(`  · push ${gitCtx.taskBranch} → ${remote} (no new PR)`);
+        log.info(`  · update existing PR ${prRefLabel(prCtx.number)} — CI re-runs`);
+        return;
+    }
+    if (meta.status === "in_progress") {
+        await updateInlineStatus(taskFile, "shipped");
+        log.ok("Status → Shipped");
+        await commitDirtyWorkingTree(cwd, docsCommitMessageFor(taskId, "mark shipped"), false);
+    }
+    if (options.noCommit === true) {
+        const git = await readGitInfo(cwd);
+        if (git.dirty === true) {
+            log.warn("Uncommitted changes left in place (--no-commit); pushing committed history only.");
+        }
+    }
+    else {
+        const message = await resolveShipCommitMessage({
             cwd,
-            taskFile,
-            skipPr: options.noPr === true,
+            taskId,
+            title: meta.title,
+            provided: options.message,
+            nonInteractive,
         });
-        if (!prResult.ok) {
-            log.error("TASK left In Progress — fix push/MR, then rerun task ship.");
+        await commitDirtyWorkingTree(cwd, message, false);
+    }
+    const remoteExists = await gitRemoteBranchExists(cwd, remote, gitCtx.taskBranch);
+    const ahead = remoteExists
+        ? await gitCommitsAhead(cwd, `${remote}/${gitCtx.taskBranch}`, "HEAD")
+        : 1;
+    const git = await readGitInfo(cwd);
+    const stillDirty = git.dirty === true;
+    if (ahead === 0 && !stillDirty) {
+        log.blank();
+        log.info(`Nothing to ship (working tree clean, PR ${prRefLabel(prCtx.number)} up to date).`);
+        return;
+    }
+    try {
+        await gitPush(cwd, remote, gitCtx.taskBranch, false);
+        log.ok(`Pushed ${gitCtx.taskBranch} → ${remote}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(describePushFailure(msg));
+        process.exitCode = 1;
+        return;
+    }
+    const sha = (await gitHeadCommit(cwd, true)) ?? "HEAD";
+    log.blank();
+    log.ok(`Updated existing PR ${prRefLabel(prCtx.number)} (pushed ${sha}) — CI re-running`);
+    if (prCtx.url)
+        log.info(`  ${dim("MR/PR")}     ${prCtx.url}`);
+}
+/** State 3: the previous PR is merged — start a new PR cycle (guarded). */
+async function runNewCycleFromShip(ctx) {
+    const { taskId, prCtx, dryRun, nonInteractive, options } = ctx;
+    if (!dryRun && options.newCycle !== true && options.allowOpenMr !== true) {
+        if (nonInteractive) {
+            log.error(`PR ${prRefLabel(prCtx.number)} is merged. Starting a NEW PR cycle requires --new-cycle in non-interactive mode.`);
             process.exitCode = 1;
             return;
         }
-        if (prResult.mergeRequestUrl) {
-            log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+        const ok = await askYesNo({
+            message: "This starts a NEW PR cycle after merge. Continue?",
+            nonInteractive: false,
+            defaultValue: false,
+        });
+        if (!ok) {
+            log.info(`Aborted. Use ${cyan("vibeops task add")} for unrelated work, or rerun with ${cyan("--new-cycle")}.`);
+            return;
         }
     }
-    else {
-        log.info(dim("No Git Context — push/MR skipped."));
+    await runPostMergeNewCycle(taskId, {
+        dryRun,
+        cwd: options.cwd,
+        noPr: options.noPr,
+        noIntegrate: options.noIntegrate,
+        recreateBranch: options.recreateBranch,
+        skipLlm: options.skipLlm,
+        allowOpenMr: options.allowOpenMr,
+    });
+}
+/** State/PR mismatch: Status is Shipped but no open/merged PR was found. */
+function runMismatchHint(ctx) {
+    log.warn(`${ctx.taskId} is Shipped but no open or merged PR was found for its branch.`);
+    log.info("The PR was likely merged and the branch synced/deleted.");
+    log.info(`Next: start new work with ${cyan("vibeops task add")}, or run ${cyan("vibeops status")} to re-check.`);
+}
+export async function taskShipCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const dryRun = options.dryRun === true;
+    const nonInteractive = options.nonInteractive === true || !isInteractiveSession();
+    const resolved = await resolveShipTarget(paths, cwd, taskRef);
+    if (resolved === null) {
+        log.error(taskNotFoundMessage(taskRef));
+        process.exitCode = 1;
+        return;
+    }
+    const { taskId, taskFile } = resolved;
+    const meta = await readTaskFile(taskFile);
+    const body = await readText(taskFile);
+    const relFile = relPath(cwd, taskFile);
+    const prCtx = await detectShipPrState(cwd, taskFile);
+    const action = resolveShipAction(prCtx.state, meta.status);
+    log.info(bold(`vibeops task ship ${taskId}`));
+    log.info(`  ${dim("file")}  ${relFile}`);
+    if (prCtx.state !== "none") {
+        log.info(`  ${dim("PR")}    ${prRefLabel(prCtx.number)} (${prCtx.state})`);
     }
     log.blank();
-    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+    const ctx = {
+        cwd,
+        taskId,
+        taskFile,
+        meta,
+        body,
+        relFile,
+        prCtx,
+        dryRun,
+        nonInteractive,
+        options,
+    };
+    switch (action) {
+        case "update-open":
+            await runUpdateOpenPr(ctx);
+            return;
+        case "new-cycle":
+            await runNewCycleFromShip(ctx);
+            return;
+        case "mismatch":
+            runMismatchHint(ctx);
+            return;
+        case "first":
+        default:
+            await runFirstShip(ctx);
+            return;
+    }
 }

package/dist/lib/filesystem.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, relative } from "node:path";
 export async function pathExists(path) {
     try {
@@ -45,6 +45,9 @@ export async function writeText(path, contents) {
     await ensureDir(dirname(path));
     await writeFile(path, contents, "utf-8");
 }
+export async function deleteFile(path) {
+    await rm(path, { force: true });
+}
 export async function walk(root) {
     const out = [];
     async function visit(dir) {

package/dist/lib/inquirer-helpers.js

@@ -1,5 +1,9 @@
 import { checkbox, confirm, input, select } from "@inquirer/prompts";
 export const OTHER_LABEL = "Other";
+/** True when both stdin and stdout are TTYs (safe to show interactive prompts). */
+export function isInteractiveSession() {
+    return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+}
 function isOther(value) {
     return value === OTHER_LABEL;
 }

package/dist/lib/pr-create.js

@@ -157,8 +157,13 @@ export async function findMergeRequestByBranches(opts) {
         return null;
     }
 }
-function prRefFromUrl(url) {
+/** Extract the numeric PR/MR id from a host URL (e.g. `#42`), or `null`. */
+export function prNumberFromUrl(url) {
+    if (typeof url !== "string")
+        return null;
     const trimmed = url.trim();
+    if (trimmed.length === 0)
+        return null;
     const pullMatch = /\/pull\/(\d+)/i.exec(trimmed);
     if (pullMatch)
         return pullMatch[1];
@@ -167,7 +172,10 @@ function prRefFromUrl(url) {
         return mrMatch[1];
     if (/^\d+$/.test(trimmed))
         return trimmed;
-    return trimmed;
+    return null;
+}
+function prRefFromUrl(url) {
+    return prNumberFromUrl(url) ?? url.trim();
 }
 export async function getMergeRequestState(cwd, host, url) {
     const ref = prRefFromUrl(url);
@@ -197,6 +205,25 @@ export async function getMergeRequestState(cwd, host, url) {
         return "unknown";
     }
 }
+export async function closeMergeRequest(opts) {
+    const ref = prRefFromUrl(opts.url);
+    const label = mergeRequestLabel(opts.host);
+    if (opts.dryRun === true) {
+        log.info(`would close ${label} ${ref}`);
+        return;
+    }
+    if (opts.host === "gitlab") {
+        await execFileAsync("glab", ["mr", "close", ref], {
+            cwd: opts.cwd,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return;
+    }
+    await execFileAsync("gh", ["pr", "close", ref], {
+        cwd: opts.cwd,
+        maxBuffer: 4 * 1024 * 1024,
+    });
+}
 export async function mergeMergeRequest(opts) {
     const ref = prRefFromUrl(opts.url);
     const method = opts.method ?? "squash";

package/dist/lib/resolve-task.js

@@ -1,4 +1,4 @@
-import { findTaskFile, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
+import { findTaskFile, loadActionableTasks, pickActiveTask, pickInProgressTask, pickLatestShippedTask, } from "./task.js";
 export function normalizeTaskRef(ref) {
     const t = ref.trim();
     if (/^task-/i.test(t) && !/^TASK-/i.test(t)) {
@@ -26,6 +26,36 @@ export async function resolveTask(paths, cwd, taskRef) {
     }
     return null;
 }
+/**
+ * Resolve the TASK that `ship` should act on. Unlike {@link resolveTask}, this
+ * also matches an already-Shipped TASK so state-aware ship (update open PR /
+ * new PR cycle) can re-run on it.
+ * Order: explicit ref → In Progress → active `task/*` branch → latest Shipped.
+ */
+export async function resolveShipTarget(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    if (trimmed !== undefined && trimmed.length > 0) {
+        const taskId = normalizeTaskRef(trimmed);
+        const taskFile = await findTaskFile(paths.docsTasks, taskId);
+        if (taskFile === null)
+            return null;
+        return { taskId, taskFile };
+    }
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null) {
+        return { taskId: inProgress.id, taskFile: inProgress.filePath };
+    }
+    const onBranch = await pickActiveTask(paths.docsTasks, cwd);
+    if (onBranch !== null) {
+        return { taskId: onBranch.id, taskFile: onBranch.filePath };
+    }
+    const shipped = pickLatestShippedTask(tasks);
+    if (shipped !== null) {
+        return { taskId: shipped.id, taskFile: shipped.filePath };
+    }
+    return null;
+}
 export function taskNotFoundMessage(taskRef) {
     if (taskRef?.trim()) {
         return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;

package/dist/lib/task-commit-msg.js

@@ -0,0 +1,80 @@
+import { readConfig } from "./config.js";
+import { gitDiffNameOnly, listWorkingTreeRelPaths } from "./git.js";
+import { anyLlmProviderAvailable, llmCompleteText } from "./llm-complete.js";
+import { getLlmPreferenceFromConfig } from "./llm-preference.js";
+import { askInput, isInteractiveSession } from "./inquirer-helpers.js";
+import { dim, log } from "./logger.js";
+import { featCommitMessageFor, taskScopedCommitMessage } from "./task-git-commit.js";
+async function changedPathsForMessage(cwd) {
+    const working = await listWorkingTreeRelPaths(cwd);
+    if (working.length > 0)
+        return working;
+    return gitDiffNameOnly(cwd);
+}
+/** Ask the LLM for a one-line conventional-commit subject from the changed files. */
+export async function generateCommitSubjectWithLlm(cwd, taskId, title) {
+    const files = await changedPathsForMessage(cwd);
+    const fileList = files.slice(0, 40).join("\n") || "(no file changes detected)";
+    const messages = [
+        {
+            role: "system",
+            content: "Write a single Conventional Commit subject line (under 72 chars) for the change. " +
+                "Reply with ONLY the subject line — no scope, no body, no quotes, no code fences. " +
+                "Pick the type from feat, fix, docs, refactor, test, chore.",
+        },
+        {
+            role: "user",
+            content: [
+                `TASK: ${taskId} — ${title}`,
+                "",
+                "Changed files:",
+                fileList,
+            ].join("\n"),
+        },
+    ];
+    try {
+        const config = await readConfig(cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text } = await llmCompleteText(messages, { cwd, preference });
+        const line = text
+            .split("\n")
+            .map((l) => l.trim())
+            .find((l) => l.length > 0);
+        if (line === undefined)
+            return null;
+        return line.replace(/^["'`]+|["'`]+$/g, "").trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the commit subject for a ship, always TASK-id-scoped:
+ * 1. explicit `--message`, 2. LLM from diff (when a provider is connected),
+ * 3. interactive prompt, 4. TASK-title fallback.
+ */
+export async function resolveShipCommitMessage(opts) {
+    const provided = opts.provided?.trim();
+    if (provided !== undefined && provided.length > 0) {
+        return taskScopedCommitMessage(opts.taskId, provided);
+    }
+    if (await anyLlmProviderAvailable(opts.cwd)) {
+        const subject = await generateCommitSubjectWithLlm(opts.cwd, opts.taskId, opts.title);
+        if (subject !== null && subject.length > 0) {
+            const msg = taskScopedCommitMessage(opts.taskId, subject);
+            log.info(dim(`  commit message (LLM): ${msg}`));
+            return msg;
+        }
+    }
+    if (!opts.nonInteractive && isInteractiveSession()) {
+        const typed = await askInput({
+            message: `Commit message for ${opts.taskId}`,
+            nonInteractive: false,
+            default: opts.title,
+        });
+        if (typed.trim().length > 0) {
+            return taskScopedCommitMessage(opts.taskId, typed);
+        }
+    }
+    return featCommitMessageFor(opts.taskId, opts.title);
+}