@goodtek/vibeops 2.2.1 → 2.4.0

package/CHANGELOG.md

@@ -4,6 +4,36 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.4.0 - 2026-06-12
+
+### Changed
+
+- **`vibeops task ship` is now state-aware.** It detects the TASK's PR/MR state and branches:
+  1. **No PR** → push + open a new PR (first submit, Status → Shipped).
+  2. **Open PR (unmerged)** → commit + push the **same** branch to update the existing PR (no new PR); CI re-runs. This replaces the manual `git add/commit/push` loop.
+  3. **Merged PR** → start a **new** PR cycle (former `reship`), guarded by an interactive confirm (`This starts a NEW PR cycle after merge. Continue? (y/N)`) or `--new-cycle` in non-interactive mode.
+- Every path prints a one-line summary: `Created PR #<n> → <url>`, `Updated existing PR #<n> (pushed <sha>) — CI re-running`, `Started new PR cycle → PR #<n>`, or `Nothing to ship (working tree clean, PR #<n> up to date)`.
+- Commit messages are auto-scoped with the TASK id (`feat(task-001): …`). `ship` refuses when HEAD is not the TASK branch.
+- PR/MR state resolution is unified in a single source (`resolveTaskMergeRequestLifecycle`).
+
+### Added
+
+- **`vibeops task ship`** flags: `-m/--message <msg>` (TASK id auto-prefixed; LLM-drafted or prompted when omitted), `--new-cycle` (alias `--reship`), `--no-commit` (push committed history only), `--non-interactive`.
+
+### Deprecated
+
+- **`vibeops task reship`** is now a thin alias for `vibeops task ship --new-cycle` and prints a deprecation notice.
+
+## 2.3.0 - 2026-06-09
+
+### Added
+
+- **`vibeops task del [TASK-NNN]`** — cancel a TASK before merge: delete `docs/tasks/*.md`, close open MR/PR (unless `--no-close-mr`), delete local/remote `task/*` branch. Refuses when the MR is **merged** into integration.
+
+### Flags
+
+- `--dry-run`, `--force` (dirty working tree), `--no-remote-delete`, `--no-close-mr`, `--cwd`
+
 ## 2.2.1 - 2026-06-09
 
 ### Fixed

package/README.md

@@ -13,8 +13,9 @@ VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on
 |---------|---------|
 | `vibeops init` | Core docs + agent packs (cursor / claude / codex) |
 | `vibeops task add` | New `TASK-NNN` file + task branch |
-| `vibeops task ship` | LLM summary, commit, push, open MR/PR (Status → **Shipped**) |
-| `vibeops task reship` | Shipped follow-up: move uncommitted work to task branch, commit, new MR/PR (Status stays Shipped) |
+| `vibeops task del` | Cancel TASK before merge (md + branch + close open MR) |
+| `vibeops task ship` | State-aware submit: open a new PR · update the open PR · start a new PR cycle after merge (Status → **Shipped**) |
+| `vibeops task reship` | **Deprecated** alias for `task ship --new-cycle` |
 | `vibeops task merge` | Merge TASK MR/PR into integration branch (default: squash) |
 | `vibeops task sync` | After merge: ff-only integration pull, delete task branches (no TASK md edits) |
 | `vibeops task release` | Release PR: integration → production (GitFlow) |
@@ -55,13 +56,24 @@ vibeops task add
 vibeops task ship
 vibeops task merge
 vibeops pull
-# Follow-up on same TASK (after merge):
-vibeops task reship TASK-NNN
+# Same TASK, before merge — edit, then just re-run ship (updates the open PR):
+vibeops task ship -m "address review"
+# Same TASK, after merge — start a new PR cycle:
+vibeops task ship --new-cycle
 vibeops task merge
 vibeops task sync
 vibeops task add
 ```
 
+`ship` detects the TASK's PR state and does the right thing:
+
+| State | `ship` does | Output |
+|-------|-------------|--------|
+| No PR yet | push + open a new PR | `Created PR #<n> → <url>` |
+| PR open (unmerged) | commit + push the **same** branch (no new PR), CI re-runs | `Updated existing PR #<n> (pushed <sha>) — CI re-running` |
+| PR merged | start a **new** PR cycle (needs confirm or `--new-cycle`) | `Started new PR cycle → PR #<n>` |
+| No change | no-op | `Nothing to ship (working tree clean, PR #<n> up to date)` |
+
 Occasionally (GitFlow release to production):
 
 ```bash
@@ -72,7 +84,7 @@ Only one TASK **In Progress** at a time (`task add` blocks otherwise). **Shipped
 
 ## LLM (optional)
 
-For **`task add`** / **`task ship`** / **`task reship`** only (not for coding in the IDE):
+For **`task add`** / **`task ship`** only (not for coding in the IDE). When `-m` is omitted, `ship` uses a connected provider to draft the commit subject:
 
 ```bash
 vibeops llm connect
@@ -97,8 +109,9 @@ pnpm install && pnpm build && pnpm smoke
 
 - **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--allow-no-remote`, `--cwd`
 - **`task add`**: `--dry-run`, `--non-interactive --idea "…"`
-- **`task ship`**: `--dry-run`, `--no-pr`
-- **`task reship`**: `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr`
+- **`task del`**: `--dry-run`, `--force`, `--no-remote-delete`, `--no-close-mr`
+- **`task ship`**: `-m/--message`, `--new-cycle` (alias `--reship`), `--no-commit`, `--dry-run`, `--no-pr`, `--non-interactive`, `--allow-open-mr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`
+- **`task reship`** (deprecated): `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr` → delegates to `task ship --new-cycle`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`
 - **`task sync`**: `--dry-run`, `--no-remote-delete`, `--force`
 - **`task release`**: `--dry-run`, `--no-merge`, `--merge`, `--rebase`
@@ -109,8 +122,8 @@ pnpm install && pnpm build && pnpm smoke
 
 - **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
 - **`task add`**: `task/<slug>` from **integration** (e.g. `develop`).
-- **`task ship`**: commit implementation + ship metadata (Status **Shipped**) → push once → MR/PR (URL on host; `task merge` resolves by branch).
-- **`task reship`**: Shipped TASK follow-up — carries uncommitted work onto the task branch (creates it from integration when missing after sync), integrates `develop`, commit → push → **new** PR.
+- **`task ship`** (state-aware): **no PR** → commit + ship metadata (Status **Shipped**) → push → open MR/PR; **open PR** → commit + push the same branch, CI re-runs, no new PR; **merged PR** → new PR cycle (carries uncommitted work onto the task branch, integrates `develop`, opens a **new** PR). Commit messages are TASK-id-scoped (`feat(task-001): …`). Refuses when HEAD is not the task branch.
+- **`task reship`** *(deprecated)*: alias for `task ship --new-cycle`.
 - **`task merge`**: merge MR/PR into integration (CLI or host UI; TASK md unchanged).
 - **`task sync`**: integration ff-only pull → delete `task/*` branches (TASK md unchanged).
 - **`pull`**: fetch + switch to integration branch + `git pull --ff-only` (one command).

package/dist/cli.js

@@ -5,6 +5,7 @@ import { initCommand } from "./commands/init.js";
 import { llmConnectCommand, llmStatusCommand, llmUseCommand } from "./commands/llm.js";
 import { statusCommand } from "./commands/status.js";
 import { taskAddCommand } from "./commands/task-add.js";
+import { taskDelCommand } from "./commands/task-del.js";
 import { taskMergeCommand } from "./commands/task-merge.js";
 import { taskReleaseCommand } from "./commands/task-release.js";
 import { taskShipCommand } from "./commands/task-ship.js";
@@ -58,7 +59,9 @@ program
         gitHost: opts.gitHost,
     });
 });
-const task = program.command("task").description("TASK lifecycle (add · ship · reship · merge · sync · release)");
+const task = program
+    .command("task")
+    .description("TASK lifecycle (add · del · ship · reship · merge · sync · release)");
 task
     .command("add")
     .description("Create next TASK-NNN, task branch, In Progress")
@@ -74,22 +77,56 @@ task
         cwd: opts.cwd,
     });
 });
+task
+    .command("del [taskRef]")
+    .description("Delete TASK before merge: remove md, close open MR/PR, delete task branch")
+    .option("--dry-run", "Plan only")
+    .option("--force", "Proceed with a dirty working tree (changes may remain)")
+    .option("--no-remote-delete", "Keep the task branch on the remote")
+    .option("--no-close-mr", "Do not close an open MR/PR")
+    .option("--cwd <path>", "Target directory")
+    .action(async (taskRef, opts) => {
+    await taskDelCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        force: Boolean(opts.force),
+        noRemoteDelete: Boolean(opts.noRemoteDelete),
+        noCloseMr: Boolean(opts.noCloseMr),
+        cwd: opts.cwd,
+    });
+});
 task
     .command("ship [taskRef]")
-    .description("Submit TASK: LLM summary, commit, push, open MR/PR (Status → Shipped)")
+    .description("State-aware submit: new PR · update open PR · new PR cycle after merge (Status → Shipped)")
     .option("--dry-run", "Plan only")
+    .option("-m, --message <msg>", "Commit message (TASK id auto-prefixed; LLM/prompt when omitted)")
+    .option("--new-cycle", "Allow a new PR cycle after merge without prompting (alias: --reship)")
+    .option("--reship", "Alias for --new-cycle")
+    .option("--no-commit", "Push already-committed changes only (skip staging/commit)")
     .option("--no-pr", "Push only; skip creating MR/PR")
+    .option("--non-interactive", "CI: never prompt")
+    .option("--no-integrate", "New PR cycle: skip merging integration into the task branch")
+    .option("--recreate-branch", "New PR cycle: recreate task branch from integration")
+    .option("--skip-llm", "New PR cycle: do not run LLM for Result / Test Result")
+    .option("--allow-open-mr", "Update the open MR/PR with new commits instead of a new cycle")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskShipCommand(taskRef, {
         dryRun: Boolean(opts.dryRun),
-        noPr: Boolean(opts.noPr),
+        message: opts.message,
+        newCycle: Boolean(opts.newCycle) || Boolean(opts.reship),
+        noCommit: opts.commit === false,
+        noPr: opts.pr === false,
+        nonInteractive: Boolean(opts.nonInteractive),
+        noIntegrate: opts.integrate === false,
+        recreateBranch: Boolean(opts.recreateBranch),
+        skipLlm: Boolean(opts.skipLlm),
+        allowOpenMr: Boolean(opts.allowOpenMr),
         cwd: opts.cwd,
     });
 });
 task
     .command("reship [taskRef]")
-    .description("Follow-up on Shipped TASK: move uncommitted work to task branch, commit, new MR/PR")
+    .description("Deprecated alias for `task ship --new-cycle` (start a new PR cycle after merge)")
     .option("--dry-run", "Plan only")
     .option("--no-pr", "Push only; skip creating MR/PR")
     .option("--no-integrate", "Skip merging integration branch into task branch")
@@ -100,8 +137,8 @@ task
     .action(async (taskRef, opts) => {
     await taskReshipCommand(taskRef, {
         dryRun: Boolean(opts.dryRun),
-        noPr: Boolean(opts.noPr),
-        noIntegrate: Boolean(opts.noIntegrate),
+        noPr: opts.pr === false,
+        noIntegrate: opts.integrate === false,
         recreateBranch: Boolean(opts.recreateBranch),
         skipLlm: Boolean(opts.skipLlm),
         allowOpenMr: Boolean(opts.allowOpenMr),

package/dist/commands/task-del.js

@@ -0,0 +1,104 @@
+import { resolve } from "node:path";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { relPath } from "../lib/task-context.js";
+import { assertTaskDeletable, assertWorkingTreeForDel, closeOpenTaskMergeRequestIfNeeded, deleteTaskBranches, deleteTaskMarkdown, loadGitConfigForDel, resolveDelTarget, taskDelNotFoundMessage, validateTaskBranchForDel, } from "../lib/task-del.js";
+import { readGitContext, statusDisplay } from "../lib/task.js";
+export async function taskDelCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    const paths = projectPaths(cwd);
+    const target = await resolveDelTarget(paths, cwd, taskRef);
+    if (target === null) {
+        log.error(taskDelNotFoundMessage(taskRef));
+        process.exitCode = 1;
+        return;
+    }
+    const { taskId, taskFile, meta, taskBranch } = target;
+    const relFile = relPath(cwd, taskFile);
+    log.info(bold(`vibeops task del ${taskId}`));
+    log.info(`  ${dim("file")}    ${relFile}`);
+    log.info(`  ${dim("branch")}  ${taskBranch}`);
+    log.info(`  ${dim("status")}  ${statusDisplay(meta.status)}`);
+    log.blank();
+    const deletable = await assertTaskDeletable(cwd, target);
+    if (!deletable.ok) {
+        log.error(deletable.reason);
+        process.exitCode = 1;
+        return;
+    }
+    const gitCfg = dryRun
+        ? await loadGitConfigForDel(cwd).catch(() => null)
+        : await loadGitConfigForDel(cwd);
+    if (!dryRun && gitCfg === null) {
+        process.exitCode = 1;
+        return;
+    }
+    const integrationBranch = gitCfg?.integrationBranch ?? "develop";
+    const productionBranch = gitCfg?.productionBranch ?? "main";
+    const remote = gitCfg?.remote ?? "origin";
+    if (!validateTaskBranchForDel(taskBranch, integrationBranch, productionBranch)) {
+        process.exitCode = 1;
+        return;
+    }
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        const ctx = await readGitContext(taskFile);
+        if (ctx !== null) {
+            await closeOpenTaskMergeRequestIfNeeded({
+                cwd,
+                taskFile,
+                taskBranch,
+                baseBranch: ctx.baseBranch,
+                dryRun: true,
+                skipClose: options.noCloseMr === true,
+            });
+        }
+        log.info(`  · git switch ${integrationBranch} (if on ${taskBranch})`);
+        await deleteTaskBranches({
+            cwd,
+            taskBranch,
+            integrationBranch,
+            remote,
+            dryRun: true,
+            noRemoteDelete: options.noRemoteDelete === true,
+        });
+        await deleteTaskMarkdown(taskFile, true);
+        log.blank();
+        log.info(`Next: ${cyan("vibeops task add")}`);
+        return;
+    }
+    if (!(await assertWorkingTreeForDel(cwd, options.force === true))) {
+        process.exitCode = 1;
+        return;
+    }
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null) {
+        log.error("Git Context missing.");
+        process.exitCode = 1;
+        return;
+    }
+    await closeOpenTaskMergeRequestIfNeeded({
+        cwd,
+        taskFile,
+        taskBranch,
+        baseBranch: ctx.baseBranch,
+        dryRun: false,
+        skipClose: options.noCloseMr === true,
+    });
+    const branchesOk = await deleteTaskBranches({
+        cwd,
+        taskBranch,
+        integrationBranch,
+        remote,
+        dryRun: false,
+        noRemoteDelete: options.noRemoteDelete === true,
+    });
+    if (!branchesOk) {
+        process.exitCode = 1;
+        return;
+    }
+    await deleteTaskMarkdown(taskFile, false);
+    log.blank();
+    log.info(`Next: ${cyan("vibeops task add")}`);
+}

package/dist/commands/task-reship.js

@@ -1,175 +1,21 @@
-import { resolve } from "node:path";
-import { readText } from "../lib/filesystem.js";
-import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
-import { projectPaths } from "../lib/paths.js";
-import { relPath } from "../lib/task-context.js";
-import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } from "../lib/task-git-commit.js";
-import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
-import { applyTaskShipMemory, llmCompleteTaskReship, writeTaskResultSections, } from "../lib/task-ship-llm.js";
-import { assertMergeRequestNotOpen, ensureTaskBranchForReship, integrateIntegrationIntoTaskBranch, loadGitConfigForReship, prepareGitContextForReship, refreshGitContextBaseCommit, resolveReshipTarget, } from "../lib/task-reship.js";
-import { hasNonEmptySection, parseTaskFilename, readGitContext, } from "../lib/task.js";
-import { listWorkingTreeRelPaths } from "../lib/git.js";
-async function commitReshipMetadata(opts) {
-    if (opts.dryRun) {
-        log.info(dim("  would commit reship metadata (Status stays Shipped)"));
-        return;
-    }
-    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "reship metadata"), false);
-    if (!committed) {
-        log.info(dim("No reship metadata commit (Git Context already on disk)."));
-    }
-}
+import { dim, log, yellow } from "../lib/logger.js";
+import { taskShipCommand } from "./task-ship.js";
+/**
+ * @deprecated `reship` is now `vibeops task ship --new-cycle`.
+ * Kept as a thin alias for backward compatibility.
+ */
 export async function taskReshipCommand(taskRef, options = {}) {
-    const cwd = resolve(options.cwd ?? process.cwd());
-    const paths = projectPaths(cwd);
-    const dryRun = options.dryRun === true;
-    const target = await resolveReshipTarget(paths, cwd, taskRef);
-    if (target === null) {
-        process.exitCode = 1;
-        return;
-    }
-    const { taskId, taskFile, meta, gitCtx: initialCtx } = target;
-    const relFile = relPath(cwd, taskFile);
-    log.info(bold(`vibeops task reship ${taskId}`));
-    log.info(`  ${dim("file")}    ${relFile}`);
-    log.info(`  ${dim("branch")}  ${initialCtx.taskBranch}`);
-    log.info(`  ${dim("status")}  Shipped (unchanged)`);
-    log.blank();
-    const gitCfg = dryRun
-        ? await loadGitConfigForReship(cwd).catch(() => null)
-        : await loadGitConfigForReship(cwd);
-    if (!dryRun && gitCfg === null) {
-        process.exitCode = 1;
-        return;
-    }
-    const integrationBranch = gitCfg?.integrationBranch ?? "develop";
-    const remote = gitCfg?.remote ?? "origin";
-    const updateOpenMr = options.allowOpenMr === true;
-    if (!dryRun && !(await assertMergeRequestNotOpen(cwd, taskFile, updateOpenMr))) {
-        process.exitCode = 1;
-        return;
-    }
-    const branchOk = await ensureTaskBranchForReship({
-        cwd,
-        taskFile,
-        gitCtx: initialCtx,
-        integrationBranch,
-        remote,
-        recreateBranch: options.recreateBranch === true,
-        dryRun,
-    });
-    if (!branchOk) {
-        process.exitCode = 1;
-        return;
-    }
-    if (options.noIntegrate !== true) {
-        const integrated = await integrateIntegrationIntoTaskBranch({
-            cwd,
-            integrationBranch,
-            remote,
-            dryRun,
-        });
-        if (!integrated) {
-            process.exitCode = 1;
-            return;
-        }
-    }
-    else {
-        log.info(dim("Skipped integration merge (--no-integrate)."));
-    }
-    const body = await readText(taskFile);
-    let resultOk = hasNonEmptySection(body, "Result");
-    let testOk = hasNonEmptySection(body, "Test Result");
-    if (!options.skipLlm && !dryRun) {
-        log.step("LLM — follow-up Result / Test Result");
-        const patch = await llmCompleteTaskReship({
-            cwd,
-            taskId,
-            taskTitle: meta.title,
-            taskBody: body,
-            taskFileRel: relFile,
-        });
-        if (patch !== null) {
-            await writeTaskResultSections(taskFile, patch.result, patch.testResult);
-            log.ok(`Result / Test Result updated (${patch.provider})`);
-            const memory = await applyTaskShipMemory(cwd, patch);
-            for (const p of memory.updated)
-                log.ok(`Updated ${p}`);
-            for (const p of memory.skipped)
-                log.skip(`Skipped ${p}`);
-        }
-        else {
-            log.warn("LLM unavailable — ensure Result / Test Result describe this follow-up.");
-        }
-        const body2 = await readText(taskFile);
-        resultOk = hasNonEmptySection(body2, "Result");
-        testOk = hasNonEmptySection(body2, "Test Result");
-    }
-    else if (options.skipLlm) {
-        log.info(dim("LLM skipped (--skip-llm)."));
-    }
-    log.info(bold("Sections"));
-    log.info(`  ${resultOk ? green("✓") : yellow("·")} Result`);
-    log.info(`  ${testOk ? green("✓") : yellow("·")} Test Result`);
+    log.warn(`${yellow("reship is now `ship` (deprecated alias)")} — delegating to \`vibeops task ship --new-cycle\`.`);
+    log.info(dim("Run `vibeops task ship` directly; it detects first submit / open-PR update / new PR cycle."));
     log.blank();
-    if (dryRun) {
-        log.info(bold("dry-run — would also:"));
-        if (updateOpenMr) {
-            log.info("  · feat commit, push, update open MR/PR (unless --no-pr)");
-        }
-        else {
-            log.info("  · feat commit + reship metadata, then push once and open MR/PR (unless --no-pr)");
-        }
-        log.blank();
-        log.info(`Next: ${cyan("vibeops task merge")}, then optional ${cyan("task sync")}`);
-        return;
-    }
-    if (!resultOk || !testOk) {
-        log.error("Fill Result and Test Result for this follow-up, then rerun.");
-        process.exitCode = 1;
-        return;
-    }
-    const dirtyBefore = await listWorkingTreeRelPaths(cwd);
-    if (dirtyBefore.length === 0) {
-        log.error("No changes to reship. Edit files (e.g. on develop), then rerun.");
-        process.exitCode = 1;
-        return;
-    }
-    const parts = parseTaskFilename(taskFile);
-    await commitDirtyWorkingTree(cwd, featCommitMessageFor(parts.id, meta.title), false);
-    let gitCtx = await readGitContext(taskFile);
-    if (gitCtx === null) {
-        log.error("Git Context missing after commit.");
-        process.exitCode = 1;
-        return;
-    }
-    if (updateOpenMr) {
-        log.info(dim("Updating open MR/PR (--allow-open-mr)."));
-    }
-    else {
-        gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
-        gitCtx = await prepareGitContextForReship(cwd, taskFile, gitCtx);
-        await commitReshipMetadata({
-            cwd,
-            taskFile,
-            taskId: parts.id,
-            dryRun: false,
-        });
-    }
-    const prResult = await finishTaskWithPullRequest({
-        cwd,
-        taskFile,
-        skipPr: options.noPr === true,
-        forceNewMergeRequest: !updateOpenMr,
+    await taskShipCommand(taskRef, {
+        dryRun: options.dryRun,
+        cwd: options.cwd,
+        noPr: options.noPr,
+        newCycle: true,
+        noIntegrate: options.noIntegrate,
+        recreateBranch: options.recreateBranch,
+        skipLlm: options.skipLlm,
+        allowOpenMr: options.allowOpenMr,
     });
-    if (!prResult.ok) {
-        log.error("Reship failed — fix push/MR, then rerun task reship.");
-        process.exitCode = 1;
-        return;
-    }
-    if (prResult.mergeRequestUrl) {
-        log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
-    }
-    log.blank();
-    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
 }