@goodtek/vibeops 2.2.1 → 2.3.0

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 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,6 +13,7 @@ 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 del` | Cancel TASK before merge (md + branch + close open MR) |
 | `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 merge` | Merge TASK MR/PR into integration branch (default: squash) |
@@ -97,6 +98,7 @@ 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 del`**: `--dry-run`, `--force`, `--no-remote-delete`, `--no-close-mr`
 - **`task ship`**: `--dry-run`, `--no-pr`
 - **`task reship`**: `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`

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,6 +77,23 @@ 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)")

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/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/pr-create.js

@@ -197,6 +197,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/task-del.js

@@ -0,0 +1,193 @@
+import { resolve } from "node:path";
+import { deleteFile } from "./filesystem.js";
+import { GitConfigError, requireGitConfig } from "./git-config.js";
+import { mergeRequestLabel } from "./git-host.js";
+import { gitBranchExists, gitDeleteBranch, gitDeleteRemoteBranch, gitGovernanceOnlyDirty, gitRemoteBranchExists, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { dim, log } from "./logger.js";
+import { closeMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
+import { normalizeTaskRef } from "./resolve-task.js";
+import { getTaskMergeRequestLifecycle, resolveGitHostForCwd } from "./task-effective-status.js";
+import { findTaskFile, loadActionableTasks, pickInProgressTask, readGitContext, readTaskFile, } from "./task.js";
+export async function resolveDelTarget(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    let taskId;
+    let taskFile;
+    if (trimmed !== undefined && trimmed.length > 0) {
+        taskId = normalizeTaskRef(trimmed);
+        taskFile = await findTaskFile(paths.docsTasks, taskId);
+    }
+    else {
+        const inProgress = pickInProgressTask(await loadActionableTasks(paths.docsTasks));
+        if (inProgress === null) {
+            return null;
+        }
+        taskId = inProgress.id;
+        taskFile = inProgress.filePath;
+    }
+    if (taskFile === null) {
+        return null;
+    }
+    const meta = await readTaskFile(taskFile);
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null) {
+        log.error(`No Git Context on ${taskId}. Cannot delete.`);
+        return null;
+    }
+    return { taskId, taskFile, meta, taskBranch: ctx.taskBranch };
+}
+export function taskDelNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No In Progress TASK found. Pass `vibeops task del TASK-NNN`.";
+}
+export async function assertTaskDeletable(cwd, target) {
+    const lifecycle = await getTaskMergeRequestLifecycle(cwd, target.taskFile);
+    if (lifecycle === "merged") {
+        return {
+            ok: false,
+            reason: `${target.taskId} is merged into integration — task del is not allowed. ` +
+                "Revert on develop if needed, or keep the TASK file as history.",
+        };
+    }
+    return { ok: true };
+}
+export async function assertWorkingTreeForDel(cwd, allowDirty) {
+    const git = await readGitInfo(cwd);
+    if (git.dirty !== true)
+        return true;
+    const gov = await gitGovernanceOnlyDirty(cwd);
+    if (gov.onlyGovernance)
+        return true;
+    if (allowDirty) {
+        log.warn("Uncommitted changes remain in the working tree after delete.");
+        return true;
+    }
+    log.error("Working tree is dirty. Commit, stash, restore, or rerun with --force to discard uncommitted work.");
+    return false;
+}
+function isProtectedBranch(name, integration, production) {
+    return name === integration || name === production || name === "main" || name === "master";
+}
+export async function deleteTaskBranches(opts) {
+    const cwd = resolve(opts.cwd);
+    if (opts.dryRun) {
+        if (await gitBranchExists(cwd, opts.taskBranch)) {
+            log.info(dim(`  would git branch -D ${opts.taskBranch}`));
+        }
+        if (opts.noRemoteDelete !== true &&
+            (await gitRemoteBranchExists(cwd, opts.remote, opts.taskBranch))) {
+            log.info(dim(`  would git push ${opts.remote} --delete ${opts.taskBranch}`));
+        }
+        return true;
+    }
+    const git = await readGitInfo(cwd);
+    if (git.branch === opts.taskBranch) {
+        const switched = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
+        if (!switched) {
+            log.error(`Integration branch "${opts.integrationBranch}" not found.`);
+            return false;
+        }
+        log.ok(`On ${opts.integrationBranch}`);
+    }
+    if (await gitBranchExists(cwd, opts.taskBranch)) {
+        try {
+            await gitDeleteBranch(cwd, opts.taskBranch, { force: true });
+            log.ok(`Deleted local branch ${opts.taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not delete local ${opts.taskBranch}: ${msg}`);
+            return false;
+        }
+    }
+    else {
+        log.info(dim(`Local branch ${opts.taskBranch} not found — skipped.`));
+    }
+    if (opts.noRemoteDelete !== true &&
+        (await gitRemoteBranchExists(cwd, opts.remote, opts.taskBranch))) {
+        try {
+            await gitDeleteRemoteBranch(cwd, opts.remote, opts.taskBranch);
+            log.ok(`Deleted ${opts.remote}/${opts.taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`Could not delete remote ${opts.taskBranch}: ${msg}`);
+        }
+    }
+    else if (opts.noRemoteDelete === true) {
+        log.info(dim("Remote branch delete skipped (--no-remote-delete)."));
+    }
+    return true;
+}
+export async function closeOpenTaskMergeRequestIfNeeded(opts) {
+    if (opts.skipClose) {
+        log.info(dim("Open MR/PR close skipped (--no-close-mr)."));
+        return true;
+    }
+    const lifecycle = await getTaskMergeRequestLifecycle(opts.cwd, opts.taskFile);
+    if (lifecycle !== "open")
+        return true;
+    const host = await resolveGitHostForCwd(opts.cwd);
+    if (host === null) {
+        log.warn("Could not resolve Git host — close the MR/PR manually.");
+        return true;
+    }
+    const open = await findMergeRequestByBranches({
+        cwd: opts.cwd,
+        host,
+        headBranch: opts.taskBranch,
+        baseBranch: opts.baseBranch,
+        state: "open",
+    });
+    if (open === null)
+        return true;
+    const label = mergeRequestLabel(host);
+    if (!(await probeMergeRequestCli(host))) {
+        log.warn(`Open ${label}: ${open.url} — close it manually before deleting the branch.`);
+        return true;
+    }
+    try {
+        await closeMergeRequest({ cwd: opts.cwd, host, url: open.url, dryRun: opts.dryRun });
+        if (!opts.dryRun)
+            log.ok(`Closed ${label}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Could not close ${label}: ${msg}`);
+        log.info(dim(`Close manually: ${open.url}`));
+    }
+    return true;
+}
+export async function deleteTaskMarkdown(taskFile, dryRun) {
+    if (dryRun) {
+        log.info(dim(`  would delete ${taskFile}`));
+        return;
+    }
+    await deleteFile(taskFile);
+    log.ok(`Deleted TASK file`);
+}
+export async function loadGitConfigForDel(cwd) {
+    try {
+        const cfg = await requireGitConfig(cwd);
+        return {
+            remote: cfg.remote,
+            integrationBranch: cfg.integrationBranch,
+            productionBranch: cfg.productionBranch,
+        };
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            return null;
+        }
+        throw e;
+    }
+}
+export function validateTaskBranchForDel(taskBranch, integrationBranch, productionBranch) {
+    if (isProtectedBranch(taskBranch, integrationBranch, productionBranch)) {
+        log.error(`Refusing to delete protected branch: ${taskBranch}`);
+        return false;
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",