@goodtek/vibeops 2.3.0 → 2.4.1

package/dist/lib/task-new-cycle.js

@@ -0,0 +1,186 @@
+import { resolve } from "node:path";
+import { readText } from "./filesystem.js";
+import { listWorkingTreeRelPaths } from "./git.js";
+import { bold, cyan, dim, green, log, yellow } from "./logger.js";
+import { projectPaths } from "./paths.js";
+import { prNumberFromUrl } from "./pr-create.js";
+import { relPath } from "./task-context.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } from "./task-git-commit.js";
+import { finishTaskWithPullRequest } from "./task-push-pr.js";
+import { applyTaskShipMemory, llmCompleteTaskReship, writeTaskResultSections, } from "./task-ship-llm.js";
+import { assertMergeRequestNotOpen, ensureTaskBranchForReship, integrateIntegrationIntoTaskBranch, loadGitConfigForReship, prepareGitContextForReship, refreshGitContextBaseCommit, resolveReshipTarget, } from "./task-reship.js";
+import { hasNonEmptySection, parseTaskFilename, readGitContext } from "./task.js";
+import { prRefLabel } from "./task-ship-state.js";
+async function commitReshipMetadata(opts) {
+    if (opts.dryRun) {
+        log.info(dim("  would commit new-cycle metadata (Status stays Shipped)"));
+        return;
+    }
+    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "new PR cycle metadata"), false);
+    if (!committed) {
+        log.info(dim("No new-cycle metadata commit (Git Context already on disk)."));
+    }
+}
+/**
+ * Start a NEW PR cycle for an already-Shipped TASK whose previous PR was merged
+ * (the former `task reship` behavior). Carries uncommitted work onto the task
+ * branch, integrates the integration branch, and opens a fresh MR/PR.
+ */
+export async function runPostMergeNewCycle(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 ship ${taskId} — new PR cycle`));
+    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.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 + metadata, then push once and open a NEW 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.info(`Nothing to do — ${taskId} is merged with no new changes. Create a new TASK for new work (${cyan("vibeops task add")}).`);
+        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,
+    });
+    if (!prResult.ok) {
+        log.error("New PR cycle failed — fix push/MR, then rerun `vibeops task ship --new-cycle`.");
+        process.exitCode = 1;
+        return;
+    }
+    log.blank();
+    const ref = prRefLabel(prNumberFromUrl(prResult.mergeRequestUrl));
+    if (prResult.mergeRequestUrl) {
+        log.ok(`Started new PR cycle → PR ${ref}`);
+        log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+    }
+    else {
+        log.ok("Started new PR cycle (branch pushed; create the MR/PR manually).");
+    }
+    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+}

package/dist/lib/task-pr-llm.js

@@ -1,8 +1,17 @@
 import { llmCompleteJson } from "./llm-complete.js";
+import { taskScopedCommitMessage } from "./task-git-commit.js";
 const SYSTEM = `You write pull/merge request titles and bodies for a software task.
 Output valid JSON only: { "title": string, "body": string }.
-Title: under 72 chars, include task id.
+Title: Conventional Commits format — type(task-nnn): lowercase subject (under 72 chars total).
+Use task id as scope in lowercase (e.g. feat(task-013): ship public status page).
+Allowed types: feat, fix, docs, chore, perf, ci, refactor, test, build, style, revert.
 Body: markdown with Summary, Changes, Test plan sections. Facts only from the input.`;
+/** Normalize PR titles to Conventional Commits with the TASK id as scope. */
+export function normalizeTaskPrTitle(taskId, rawTitle) {
+    const trimmed = rawTitle.trim().replace(/\s+/g, " ");
+    const withoutTaskPrefix = trimmed.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim();
+    return taskScopedCommitMessage(taskId, withoutTaskPrefix || trimmed).slice(0, 72);
+}
 export async function generateTaskPrWithLlm(input, cwd, preference) {
     const user = [
         `Task: ${input.taskId}`,
@@ -27,14 +36,17 @@ export async function generateTaskPrWithLlm(input, cwd, preference) {
         const prBody = typeof parsed.body === "string" ? parsed.body.trim() : "";
         if (!prTitle || !prBody)
             return null;
-        return { prTitle, prBody };
+        return {
+            prTitle: normalizeTaskPrTitle(input.taskId, prTitle),
+            prBody,
+        };
     }
     catch {
         return null;
     }
 }
 export function fallbackTaskPr(input) {
-    const prTitle = `${input.taskId}: ${input.title}`.slice(0, 72);
+    const prTitle = normalizeTaskPrTitle(input.taskId, input.title);
     const prBody = [
         "## Summary",
         input.title,

package/dist/lib/task-ship-state.js

@@ -0,0 +1,39 @@
+import { prNumberFromUrl } from "./pr-create.js";
+import { resolveTaskMergeRequestLifecycle } from "./task-effective-status.js";
+/**
+ * Single entry point for `ship` to learn the current PR/MR state of a TASK.
+ * Wraps {@link resolveTaskMergeRequestLifecycle} and extracts the PR number.
+ */
+export async function detectShipPrState(cwd, taskFile) {
+    const lifecycle = await resolveTaskMergeRequestLifecycle(cwd, taskFile);
+    const state = lifecycle.state === "open"
+        ? "open"
+        : lifecycle.state === "merged"
+            ? "merged"
+            : lifecycle.state === "closed"
+                ? "closed"
+                : "none";
+    return {
+        state,
+        url: lifecycle.url,
+        number: prNumberFromUrl(lifecycle.url),
+    };
+}
+/**
+ * Map (PR state, TASK status) → the `ship` action. Pure so it is unit-testable.
+ * - open PR            → update the existing PR (state 2)
+ * - merged PR          → start a new PR cycle (state 3, guarded)
+ * - no/closed PR + In Progress → first submit (state 1)
+ * - no/closed PR + Shipped     → status/PR mismatch (resync hint)
+ */
+export function resolveShipAction(prState, taskStatus) {
+    if (prState === "open")
+        return "update-open";
+    if (prState === "merged")
+        return "new-cycle";
+    return taskStatus === "shipped" ? "mismatch" : "first";
+}
+/** Format the PR reference for output (`#42` or `the PR`). */
+export function prRefLabel(prNumber) {
+    return prNumber !== null ? `#${prNumber}` : "the PR";
+}

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
-  "packageManager": "pnpm@9.15.9",
   "author": "VibeOps contributors",
   "license": "MIT",
   "repository": {
@@ -30,16 +29,6 @@
   "engines": {
     "node": ">=20"
   },
-  "scripts": {
-    "dev": "tsx src/cli.ts",
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "start": "node dist/cli.js",
-    "smoke": "pnpm typecheck && pnpm build && node scripts/smoke.mjs",
-    "clean": "rm -rf dist",
-    "prepack": "pnpm clean && pnpm build",
-    "publish:dry": "pnpm publish --dry-run --no-git-checks"
-  },
   "keywords": [
     "cursor",
     "ai",
@@ -58,5 +47,15 @@
     "@types/node": "^20.14.0",
     "tsx": "^4.19.0",
     "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/cli.js",
+    "test": "pnpm build && node --test \"tests/*.test.mjs\"",
+    "smoke": "pnpm typecheck && pnpm build && node --test \"tests/*.test.mjs\" && node scripts/smoke.mjs",
+    "clean": "rm -rf dist",
+    "publish:dry": "pnpm publish --dry-run --no-git-checks"
   }
-}
+}

package/templates/clients/claude/CLAUDE.md

@@ -2,5 +2,5 @@
 
 - Work from `docs/tasks/TASK-NNN-*.md` only.
 - One TASK at a time.
-- Fill **Result** and **Test Result** before telling the human to run `vibeops task ship TASK-NNN` (or `task reship` for Shipped follow-up).
+- Fill **Result** and **Test Result** before telling the human to run `vibeops task ship TASK-NNN`. `ship` is state-aware: re-running before merge updates the open PR; after merge use `vibeops task ship --new-cycle`.
 - Do not merge to integration or main unless the human runs `vibeops task merge` / `task sync` / `task release`.

package/templates/clients/cursor/.cursor/rules/02-git-safety.mdc

@@ -8,4 +8,4 @@ alwaysApply: true
 - Use branch pattern `task/*` from `vibeops task add`.
 - Include TASK id in commits: `feat(task-nnn): …`.
 - No force-push to shared branches.
-- Run `vibeops task ship`, `task reship`, `task merge`, `task sync` when the human asks — do not merge locally in the IDE unless requested.
+- Run `vibeops task ship`, `task merge`, `task sync` when the human asks — do not merge locally in the IDE unless requested. (`ship` is state-aware: it updates an open PR or, with `--new-cycle`, starts a new PR cycle after merge.)

package/templates/clients/cursor/.cursor/rules/03-docs-before-ship.mdc

@@ -5,7 +5,7 @@ alwaysApply: true
 
 # Docs before task ship
 
-Before `vibeops task ship` or `vibeops task reship`:
+Before `vibeops task ship`:
 
 1. Fill **Result** and **Test Result** in the TASK file (paths, commands, outcomes — facts only).
 2. If architecture or decisions changed, note them in the TASK; `task ship` can update `docs/project/*` via LLM.

package/templates/core/AGENTS.md

@@ -8,12 +8,14 @@
 vibeops task add
 # Plan / build in your agent (@docs/tasks/TASK-NNN-*.md)
 
-vibeops task ship
+vibeops task ship           # state-aware: new PR / update open PR / new cycle
 vibeops task merge          # CLI or host UI
 vibeops task sync           # optional — branch cleanup only
 
-# Same TASK follow-up (after merge):
-vibeops task reship TASK-NNN
+# Same TASK, before merge — just re-run ship to update 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
 ```
 
@@ -26,16 +28,17 @@ Only two values in `## Status`:
 | Status | Meaning |
 |--------|---------|
 | **In Progress** | Active slice (`task add`) |
-| **Shipped** | Submitted (`task ship` or `task reship`) |
+| **Shipped** | Submitted (`task ship`) |
 
 Merge and sync do **not** change the TASK file.
 
 ```bash
-vibeops llm connect   # optional — task add / ship / reship
+vibeops llm connect   # optional — task add / ship
 ```
 
 ## Rules
 
 - One **In Progress** TASK at a time; **Shipped** does not block `task add`.
-- Fill **Result** and **Test Result** before `vibeops task ship` (or before `task reship` for follow-ups).
-- Agents do not run `task merge`, `task sync`, or `task reship` unless the human asks.
+- Fill **Result** and **Test Result** before `vibeops task ship` (warned, not blocked, when updating an open PR).
+- `ship` is state-aware: re-run it to update an open PR; after merge it needs `--new-cycle` (or a confirm) to start a new PR cycle. `task reship` still works as a deprecated alias for `task ship --new-cycle`.
+- Agents do not run `task merge` or `task sync` unless the human asks.

package/templates/skills-shared/implement-task/SKILL.md

@@ -8,6 +8,6 @@ description: Implement the current VibeOps TASK file in the repo.
 1. Read the full `docs/tasks/TASK-NNN-*.md` (Scope, Acceptance Criteria, Test Plan).
 2. Search the codebase before adding new patterns.
 3. Implement only within the TASK scope.
-4. Do not run `vibeops task ship`, `reship`, `merge`, or `sync` — the human runs the CLI lifecycle.
+4. Do not run `vibeops task ship`, `merge`, or `sync` — the human runs the CLI lifecycle.
 
-When implementation is ready, tell the human to run `vibeops task ship TASK-NNN`. For a **Shipped** follow-up after merge, use `vibeops task reship TASK-NNN`.
+When implementation is ready, tell the human to run `vibeops task ship TASK-NNN`. `ship` is state-aware: re-running it before merge updates the open PR; after merge it starts a new PR cycle with `vibeops task ship --new-cycle`.