@goodtek/vibeops 2.1.3 → 2.2.0

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.2.0 - 2026-06-09
+
+### Added
+
+- **`vibeops pull`** — one command: `git fetch`, switch to integration branch (e.g. `develop`), fast-forward pull.
+
+### Changed
+
+- **`vibeops task reship`**: no longer blocks on a dirty working tree — uncommitted edits (including on `develop`) are carried onto the task branch. When the task branch is missing locally and on the remote (e.g. after `task sync`), it is **created automatically** from the integration branch. Removed `--allow-dirty` (behavior is now default).
+
 ## 2.1.3 - 2026-06-08
 
 ### Changed

package/README.md

@@ -14,10 +14,11 @@ 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 TASK follow-up: integrate develop, new MR/PR (Status stays 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) |
 | `vibeops task sync` | After merge: ff-only integration pull, delete task branches (no TASK md edits) |
 | `vibeops task release` | Release PR: integration → production (GitFlow) |
+| `vibeops pull` | Fetch remote + update integration branch (e.g. develop) |
 | `vibeops status` | Briefing: TASK, Git, LLM, clients |
 | `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
 
@@ -53,6 +54,7 @@ vibeops task add
 
 vibeops task ship
 vibeops task merge
+vibeops pull
 # Follow-up on same TASK (after merge):
 vibeops task reship TASK-NNN
 vibeops task merge
@@ -96,10 +98,11 @@ 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`, `--allow-dirty`
+- **`task reship`**: `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`
 - **`task sync`**: `--dry-run`, `--no-remote-delete`, `--force`
 - **`task release`**: `--dry-run`, `--no-merge`, `--merge`, `--rebase`
+- **`pull`**: `--dry-run`
 - **`status`**: `--json`
 
 ## Git
@@ -107,9 +110,10 @@ 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 only; integrates `develop`; opens **new** PR (archives previous MR in Git Context).
+- **`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 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).
 - **`task release`**: integration → production PR + merge (skipped on trunk policy).
 - No force-push to shared branches.
 

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Command } from "commander";
+import { pullCommand } from "./commands/pull.js";
 import { initCommand } from "./commands/init.js";
 import { llmConnectCommand, llmStatusCommand, llmUseCommand } from "./commands/llm.js";
 import { statusCommand } from "./commands/status.js";
@@ -14,7 +15,7 @@ import { VERSION } from "./version.js";
 const program = new Command();
 program
     .name("vibeops")
-    .description("VibeOps — TASK workflow (init · task add/ship/reship/merge/sync · status · llm)")
+    .description("VibeOps — TASK workflow (init · task · pull · status · llm)")
     .version(VERSION, "-v, --version", "Print the VibeOps version");
 program.hook("preAction", async (_thisCommand, actionCommand) => {
     const opts = actionCommand.opts();
@@ -88,14 +89,13 @@ task
 });
 task
     .command("reship [taskRef]")
-    .description("Follow-up on Shipped TASK: integrate develop, commit, new MR/PR")
+    .description("Follow-up on Shipped TASK: move uncommitted work to task branch, commit, new MR/PR")
     .option("--dry-run", "Plan only")
     .option("--no-pr", "Push only; skip creating MR/PR")
     .option("--no-integrate", "Skip merging integration branch into task branch")
-    .option("--recreate-branch", "Recreate task branch from integration if missing")
+    .option("--recreate-branch", "Create task branch from integration instead of reusing local/remote ref")
     .option("--skip-llm", "Do not run LLM for Result / Test Result")
     .option("--allow-open-mr", "Allow reship while the recorded MR is still open")
-    .option("--allow-dirty", "Proceed when only governance paths are dirty")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskReshipCommand(taskRef, {
@@ -105,7 +105,6 @@ task
         recreateBranch: Boolean(opts.recreateBranch),
         skipLlm: Boolean(opts.skipLlm),
         allowOpenMr: Boolean(opts.allowOpenMr),
-        allowDirty: Boolean(opts.allowDirty),
         cwd: opts.cwd,
     });
 });
@@ -156,6 +155,17 @@ task
         cwd: opts.cwd,
     });
 });
+program
+    .command("pull")
+    .description("Fetch remote and update integration branch (e.g. develop)")
+    .option("--dry-run", "Plan only")
+    .option("--cwd <path>", "Target directory")
+    .action(async (opts) => {
+    await pullCommand({
+        dryRun: Boolean(opts.dryRun),
+        cwd: opts.cwd,
+    });
+});
 program
     .command("status")
     .description("Briefing: active TASK, Git, LLM, next hint")

package/dist/commands/pull.js

@@ -0,0 +1,79 @@
+import { resolve } from "node:path";
+import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { gitFetchRemote, gitPullFastForwardOnly, gitRemoteBranchExists, gitRemoteUrl, gitSwitchToBranch, readGitInfo, } from "../lib/git.js";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+/**
+ * One-step remote sync: fetch, switch to integration branch, fast-forward pull.
+ */
+export async function pullCommand(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    let gitCfg;
+    try {
+        gitCfg = await requireGitConfig(cwd);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    const { remote, integrationBranch } = gitCfg;
+    log.info(bold("vibeops pull"));
+    log.info(`  ${dim("remote")}       ${remote}`);
+    log.info(`  ${dim("integration")}  ${cyan(integrationBranch)}`);
+    log.blank();
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        process.exitCode = 1;
+        return;
+    }
+    const needsSwitch = git.branch !== integrationBranch;
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        log.info(`  · git fetch ${remote} --prune`);
+        if (needsSwitch) {
+            log.info(`  · git switch ${integrationBranch}`);
+        }
+        log.info(`  · git pull --ff-only ${remote} ${integrationBranch}`);
+        return;
+    }
+    if ((await gitRemoteUrl(cwd, remote)) === null) {
+        log.error(`No remote "${remote}". Add a remote or re-run vibeops init.`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        await gitFetchRemote(cwd, remote);
+        log.ok(`Fetched ${remote}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`git fetch failed (${msg}). Continuing with local refs.`);
+    }
+    if (needsSwitch) {
+        const switched = await gitSwitchToBranch(cwd, integrationBranch, remote);
+        if (!switched) {
+            log.error(`Branch "${integrationBranch}" not found locally or on ${remote}. Push integration first or check the remote URL.`);
+            process.exitCode = 1;
+            return;
+        }
+        log.ok(`On ${integrationBranch}`);
+    }
+    if (!(await gitRemoteBranchExists(cwd, remote, integrationBranch))) {
+        log.warn(`No ${remote}/${integrationBranch} on the remote yet — fetch only.`);
+        return;
+    }
+    try {
+        await gitPullFastForwardOnly(cwd, remote, integrationBranch);
+        log.ok(`Up to date with ${remote}/${integrationBranch}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Could not fast-forward ${integrationBranch}: ${msg}. Commit or stash local changes, then rerun \`vibeops pull\`.`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/task-reship.js

@@ -56,7 +56,6 @@ export async function taskReshipCommand(taskRef, options = {}) {
         remote,
         recreateBranch: options.recreateBranch === true,
         dryRun,
-        allowDirty: options.allowDirty === true,
     });
     if (!branchOk) {
         process.exitCode = 1;
@@ -126,7 +125,7 @@ export async function taskReshipCommand(taskRef, options = {}) {
     }
     const dirtyBefore = await listWorkingTreeRelPaths(cwd);
     if (dirtyBefore.length === 0) {
-        log.error("No changes to reship. Edit files on the task branch, then rerun.");
+        log.error("No changes to reship. Edit files (e.g. on develop), then rerun.");
         process.exitCode = 1;
         return;
     }

package/dist/lib/task-context.js

@@ -48,7 +48,7 @@ export function computeNextHint(input) {
             return "task-sync";
         if (input.hasMergeRequest && !input.mergeRequestMerged)
             return "task-merge";
-        if (input.hasLocalChanges && input.onTaskBranch === true)
+        if (input.hasLocalChanges)
             return "task-reship";
         return "task-add";
     }
@@ -67,7 +67,7 @@ export function hintToText(hint, cwd, task) {
             return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
         case "task-reship":
             return task
-                ? `Follow-up on ${task.id}? Edit on task branch, then \`vibeops task reship ${task.id}\`.`
+                ? `Follow-up on ${task.id}? Edit files (develop is fine), then \`vibeops task reship ${task.id}\`.`
                 : "Run `vibeops task reship TASK-NNN` for a Shipped follow-up.";
         case "task-merge":
             return task

package/dist/lib/task-reship.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "./git-config.js";
-import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitFetchRemote, gitGovernanceOnlyDirty, gitHeadCommit, gitMergeRemoteBranch, gitMergeInProgress, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, listUnmergedRelPaths, readGitInfo, } from "./git.js";
+import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitDeleteBranch, gitFetchRemote, gitHeadCommit, gitMergeRemoteBranch, gitMergeInProgress, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, listUnmergedRelPaths, readGitInfo, } from "./git.js";
 import { dim, log } from "./logger.js";
 import { findMergeRequestByBranches } from "./pr-create.js";
 import { normalizeTaskRef } from "./resolve-task.js";
@@ -45,52 +45,44 @@ export function reshipNotFoundMessage(taskRef) {
     }
     return "No Shipped TASK found. Pass `vibeops task reship TASK-NNN`.";
 }
-/** Checkout or recreate the task branch without changing TASK Status. */
-export async function ensureTaskBranchForReship(opts) {
-    const cwd = resolve(opts.cwd);
-    const { taskBranch } = opts.gitCtx;
-    const git = await readGitInfo(cwd);
-    if (!git.isRepo) {
-        log.error("Not a git repository.");
-        return false;
+async function switchToTaskBranch(cwd, taskBranch) {
+    try {
+        await gitCheckout(cwd, taskBranch);
+        return true;
     }
-    if (git.dirty === true && !opts.allowDirty) {
-        const gov = await gitGovernanceOnlyDirty(cwd);
-        if (!gov.onlyGovernance) {
-            log.error("Working tree is dirty. Commit or stash, or rerun with --allow-dirty.");
-            return false;
-        }
-        log.warn("Only governance paths are dirty — proceeding.");
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Could not switch to ${taskBranch} with uncommitted changes. Commit, stash, or resolve conflicts, then rerun.`);
+        if (msg.length > 0)
+            log.info(dim(msg));
+        return false;
     }
-    const localExists = await gitBranchExists(cwd, taskBranch);
-    const remoteExists = await gitRemoteBranchExists(cwd, opts.remote, taskBranch);
-    if (opts.dryRun) {
-        if (localExists) {
-            log.info(dim(`  would git switch ${taskBranch}`));
-        }
-        else if (opts.recreateBranch) {
-            log.info(dim(`  would recreate ${taskBranch} from ${opts.integrationBranch}`));
-        }
-        else {
-            log.error(`Local branch ${taskBranch} missing. Rerun with --recreate-branch.`);
+}
+async function removeLocalTaskBranch(cwd, taskBranch, integrationBranch, remote) {
+    if (!(await gitBranchExists(cwd, taskBranch)))
+        return true;
+    const git = await readGitInfo(cwd);
+    if (git.branch === taskBranch) {
+        const ok = await gitSwitchToBranch(cwd, integrationBranch, remote);
+        if (!ok) {
+            log.error(`Integration branch "${integrationBranch}" not found.`);
             return false;
         }
-        return true;
     }
-    if (localExists) {
-        await gitCheckout(cwd, taskBranch);
-        log.ok(`On ${taskBranch}`);
-        return true;
+    try {
+        await gitDeleteBranch(cwd, taskBranch, { force: true });
+        log.info(dim(`Removed local ${taskBranch}.`));
     }
-    if (!opts.recreateBranch) {
-        if (remoteExists) {
-            log.error(`Local ${taskBranch} missing. Fetch/checkout the branch or rerun with --recreate-branch.`);
-        }
-        else {
-            log.error(`Branch ${taskBranch} not found locally or on ${opts.remote}. Use --recreate-branch.`);
-        }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Could not remove local ${taskBranch}: ${msg}`);
         return false;
     }
+    return true;
+}
+async function recreateTaskBranchFromIntegration(opts) {
+    const cwd = resolve(opts.cwd);
+    const { taskBranch } = opts.gitCtx;
     const ok = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
     if (!ok) {
         log.error(`Integration branch "${opts.integrationBranch}" not found.`);
@@ -111,15 +103,75 @@ export async function ensureTaskBranchForReship(opts) {
         log.error("Integration branch has no commits.");
         return false;
     }
-    await gitCheckoutNewBranch(cwd, taskBranch, opts.integrationBranch);
+    try {
+        await gitCheckoutNewBranch(cwd, taskBranch, opts.integrationBranch);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Could not create ${taskBranch} from ${opts.integrationBranch} with uncommitted changes.`);
+        if (msg.length > 0)
+            log.info(dim(msg));
+        return false;
+    }
     await upsertGitContext(opts.taskFile, {
         ...opts.gitCtx,
         baseBranch: opts.integrationBranch,
         baseCommit: head,
     });
-    log.ok(`Recreated ${taskBranch} from ${opts.integrationBranch}`);
+    log.ok(`Created ${taskBranch} from ${opts.integrationBranch}`);
     return true;
 }
+/** Checkout or recreate the task branch without changing TASK Status. */
+export async function ensureTaskBranchForReship(opts) {
+    const cwd = resolve(opts.cwd);
+    const { taskBranch } = opts.gitCtx;
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        return false;
+    }
+    if (git.dirty === true) {
+        log.info(dim("Uncommitted changes will be carried onto the task branch."));
+    }
+    const localExists = await gitBranchExists(cwd, taskBranch);
+    const remoteExists = await gitRemoteBranchExists(cwd, opts.remote, taskBranch);
+    const recreateFromIntegration = opts.recreateBranch === true || (!localExists && !remoteExists);
+    if (opts.dryRun) {
+        if (localExists && !opts.recreateBranch) {
+            log.info(dim(`  would git switch ${taskBranch}`));
+        }
+        else if (!recreateFromIntegration && remoteExists) {
+            log.info(dim(`  would checkout ${taskBranch} from ${opts.remote}`));
+        }
+        else {
+            if (localExists && opts.recreateBranch) {
+                log.info(dim(`  would remove local ${taskBranch}`));
+            }
+            log.info(dim(`  would create ${taskBranch} from ${opts.integrationBranch}`));
+        }
+        return true;
+    }
+    if (localExists && !opts.recreateBranch) {
+        if (!(await switchToTaskBranch(cwd, taskBranch)))
+            return false;
+        log.ok(`On ${taskBranch}`);
+        return true;
+    }
+    if (!recreateFromIntegration && remoteExists) {
+        const checkedOut = await gitSwitchToBranch(cwd, taskBranch, opts.remote);
+        if (checkedOut) {
+            log.ok(`Checked out ${taskBranch} from ${opts.remote}`);
+            return true;
+        }
+        log.warn(`Could not checkout ${opts.remote}/${taskBranch}; creating from integration.`);
+    }
+    if (localExists) {
+        const removed = await removeLocalTaskBranch(cwd, taskBranch, opts.integrationBranch, opts.remote);
+        if (!removed)
+            return false;
+    }
+    return recreateTaskBranchFromIntegration(opts);
+}
 /** Merge latest integration into the current task branch. */
 export async function integrateIntegrationIntoTaskBranch(opts) {
     const cwd = resolve(opts.cwd);

package/package.json

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