@goodtek/vibeops 2.4.4 → 2.5.1

package/dist/lib/git-remote.js

@@ -1,32 +1,14 @@
+import { basename } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { askInput } from "./inquirer-helpers.js";
+import { brewInstall, formatHostCliHint, formatHostCliMissingMessage, hostCliTool, parseOwnerRepo, probeBrew, probeHostCliAuth, remoteUrlForHost, repoExistsOnHost, runInteractiveCli, } from "./git-host-cli.js";
 import { detectGitHost } from "./git-host.js";
 import { gitRemoteUrl, runGit } from "./git.js";
-import { dim, log } from "./logger.js";
+import { askInput, askSelect, askYesNo } from "./inquirer-helpers.js";
+import { dim, log, yellow } from "./logger.js";
 const execFileAsync = promisify(execFile);
-async function probeGh() {
-    try {
-        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function probeGlab() {
-    try {
-        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function createGithubRepo(cwd, name) {
-    const { stdout } = await execFileAsync("gh", 
-    // gh requires an explicit visibility flag when non-interactive.
-    ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
+    const { stdout } = await execFileAsync("gh", ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
     const match = stdout.match(/https:\/\/github\.com\/[^\s]+/);
     if (match)
         return match[0].replace(/\.git$/, "") + ".git";
@@ -42,8 +24,135 @@ async function createGitlabRepo(cwd, name, defaultBranch) {
         return url;
     throw new Error("glab repo create finished but origin URL could not be read.");
 }
+async function addRemoteUrl(cwd, remote, url) {
+    const host = detectGitHost(url);
+    if (!host) {
+        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
+    }
+    await runGit(cwd, ["remote", "add", remote, url.trim()]);
+    return { remote, url: url.trim(), host };
+}
+async function resolveConnectUrl(host, input) {
+    const trimmed = input.trim();
+    const parsed = parseOwnerRepo(trimmed);
+    if (parsed) {
+        if (trimmed.startsWith("http") || trimmed.startsWith("git@") || trimmed.startsWith("ssh://")) {
+            return trimmed.endsWith(".git") ? trimmed : `${trimmed.replace(/\/$/, "")}.git`;
+        }
+        return remoteUrlForHost(host, parsed.owner, parsed.repo);
+    }
+    if (detectGitHost(trimmed)) {
+        return trimmed.endsWith(".git") ? trimmed : `${trimmed.replace(/\/$/, "")}.git`;
+    }
+    throw new Error(`Could not parse remote: ${trimmed}`);
+}
+async function repairMissingCli(host) {
+    const tool = hostCliTool(host);
+    const status = await probeHostCliAuth(host);
+    log.warn(status === "missing"
+        ? formatHostCliMissingMessage(host, "create a remote repository")
+        : `${tool} is installed but not logged in.`);
+    for (const line of formatHostCliHint(host)) {
+        log.info(dim(`  ${line}`));
+    }
+    const brewOk = status === "missing" ? await probeBrew() : false;
+    const choices = [
+        "I installed / logged in — retry",
+        ...(brewOk ? [`Run brew install ${tool}`] : []),
+        "Enter remote URL manually",
+        "Skip remote for now",
+    ];
+    // Loop so brew install / retry can re-prompt.
+    for (;;) {
+        const pick = await askSelect({
+            message: "How do you want to continue?",
+            nonInteractive: false,
+            choices,
+        });
+        if (pick === "I installed / logged in — retry") {
+            const again = await probeHostCliAuth(host);
+            if (again === "ok")
+                return "retry";
+            log.warn(again === "missing"
+                ? `${tool} still not found on PATH.`
+                : `${tool} still not authenticated. Run \`${tool} auth login\`.`);
+            continue;
+        }
+        if (pick.startsWith("Run brew install")) {
+            log.info(dim(`Running: brew install ${tool}`));
+            try {
+                await brewInstall(tool);
+                log.ok(`Installed ${tool}`);
+                log.info(dim(`Next: ${tool} auth login`));
+                const loginNow = await askYesNo({
+                    message: `Run \`${tool} auth login\` now?`,
+                    nonInteractive: false,
+                    defaultValue: true,
+                });
+                if (loginNow) {
+                    try {
+                        await runInteractiveCli(tool, ["auth", "login"]);
+                    }
+                    catch {
+                        /* user may cancel */
+                    }
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log.warn(`brew install failed: ${msg}`);
+            }
+            continue;
+        }
+        if (pick === "Enter remote URL manually")
+            return "manual";
+        return "skip";
+    }
+}
+async function connectExisting(cwd, remote, host) {
+    const input = await askInput({
+        message: "Repository URL or owner/repo",
+        nonInteractive: false,
+        required: true,
+    });
+    const url = await resolveConnectUrl(host, input);
+    const parsed = parseOwnerRepo(url) ?? parseOwnerRepo(input);
+    if (parsed && (await probeHostCliAuth(host)) === "ok") {
+        const exists = await repoExistsOnHost(host, parsed.owner, parsed.repo);
+        if (!exists) {
+            log.warn(yellow(`Could not verify ${parsed.owner}/${parsed.repo} on ${host} (missing or private). Continuing with remote add.`));
+        }
+    }
+    return addRemoteUrl(cwd, remote, url);
+}
+async function createOnHost(cwd, remote, host, defaultBranch) {
+    const folder = basename(cwd);
+    const label = host === "gitlab" ? "GitLab project path (group/project)" : "GitHub repository (owner/repo or name)";
+    const name = await askInput({
+        message: label,
+        nonInteractive: false,
+        required: true,
+        default: folder,
+    });
+    log.info(dim(`Creating ${host} repository via ${hostCliTool(host)}…`));
+    if (host === "gitlab") {
+        const url = await createGitlabRepo(cwd, name, defaultBranch);
+        // glab may name remote differently; ensure our remote name.
+        const current = await gitRemoteUrl(cwd, remote);
+        if (!current) {
+            const origin = await gitRemoteUrl(cwd, "origin");
+            if (origin && remote !== "origin") {
+                await runGit(cwd, ["remote", "rename", "origin", remote]);
+            }
+        }
+        return { remote, url, host };
+    }
+    const url = await createGithubRepo(cwd, name);
+    return { remote, url, host };
+}
 /**
- * Ensures `origin` (or named remote) exists. Interactive path can create via gh/glab or manual URL.
+ * Ensures `origin` (or named remote) exists.
+ * Interactive: ask host → create/connect; soft-gate when CLI missing.
  */
 export async function ensureOriginRemote(opts) {
     const remote = opts.remoteName ?? "origin";
@@ -59,8 +168,9 @@ export async function ensureOriginRemote(opts) {
         return { remote, url: existing, host };
     }
     if (opts.dryRun) {
-        log.info(dim(`would configure git remote ${remote}`));
-        return { remote, url: "(dry-run)", host: "github" };
+        const host = opts.preferredHost ?? "github";
+        log.info(dim(`would configure git remote ${remote} (${host})`));
+        return { remote, url: "(dry-run)", host };
     }
     if (opts.allowMissing) {
         return null;
@@ -69,40 +179,48 @@ export async function ensureOriginRemote(opts) {
         throw new Error(`Git remote "${remote}" is not configured. Add it with: git remote add ${remote} <url>`);
     }
     log.blank();
-    log.info("Remote origin is required for push and merge requests.");
-    const ghOk = await probeGh();
-    const glabOk = await probeGlab();
-    if (ghOk) {
-        const name = await askInput({
-            message: "GitHub repository name (owner/repo or name for gh to create)",
-            nonInteractive: false,
-            required: true,
-        });
-        log.info(dim("Creating GitHub repository via gh…"));
-        const url = await createGithubRepo(opts.cwd, name);
-        return { remote, url, host: "github" };
-    }
-    if (glabOk) {
-        const name = await askInput({
-            message: "GitLab project path (group/project)",
-            nonInteractive: false,
-            required: true,
-        });
-        log.info(dim("Creating GitLab project via glab…"));
-        const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
-            ? opts.defaultBranch
-            : "main";
-        const url = await createGitlabRepo(opts.cwd, name, defaultBranch);
-        return { remote, url, host: "gitlab" };
+    log.info("Remote setup — used later for pull requests / merge requests.");
+    const hostPick = await askSelect({
+        message: "Where will this project's remote live?",
+        nonInteractive: false,
+        choices: ["GitHub", "GitLab", "Skip for now (local only)"],
+        default: opts.preferredHost === "gitlab"
+            ? "GitLab"
+            : opts.preferredHost === "github"
+                ? "GitHub"
+                : undefined,
+    });
+    if (hostPick.startsWith("Skip")) {
+        log.warn("No git remote configured. task ship push/MR will fail until origin exists.");
+        log.info(dim(`  Later: git remote add ${remote} <url>`));
+        return null;
     }
-    const url = await askInput({
-        message: `Remote URL for ${remote} (https://github.com/… or https://gitlab.com/…)`,
+    const host = hostPick === "GitLab" ? "gitlab" : "github";
+    const mode = await askSelect({
+        message: "Set up the remote",
         nonInteractive: false,
-        required: true,
+        choices: ["Create a new repository", "Connect an existing repository"],
     });
-    await runGit(opts.cwd, ["remote", "add", remote, url.trim()]);
-    const host = detectGitHost(url);
-    if (!host)
-        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
-    return { remote, url: url.trim(), host };
+    if (mode.startsWith("Connect")) {
+        return connectExisting(opts.cwd, remote, host);
+    }
+    // Create path — requires authenticated CLI (soft gate).
+    for (;;) {
+        const auth = await probeHostCliAuth(host);
+        if (auth === "ok") {
+            const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
+                ? opts.defaultBranch
+                : "main";
+            return createOnHost(opts.cwd, remote, host, defaultBranch);
+        }
+        const action = await repairMissingCli(host);
+        if (action === "retry")
+            continue;
+        if (action === "manual") {
+            return connectExisting(opts.cwd, remote, host);
+        }
+        log.warn("No git remote configured. task ship push/MR will fail until origin exists.");
+        log.info(dim(`  Later: git remote add ${remote} <url>`));
+        return null;
+    }
 }

package/dist/lib/git.js

@@ -519,6 +519,31 @@ export async function gitDeleteRemoteBranch(cwd, remote, branch) {
 export async function gitPullFastForwardOnly(cwd, remote, branch) {
     await runGit(cwd, ["pull", "--ff-only", remote, branch]);
 }
+/**
+ * Commits reachable only from `left` vs only from `right` (git left-right).
+ * Example: `develop...origin/develop` → { left: local-only, right: remote-only }.
+ */
+export async function gitLeftRightCount(cwd, leftRef, rightRef) {
+    try {
+        const { stdout } = await runGit(cwd, [
+            "rev-list",
+            "--left-right",
+            "--count",
+            `${leftRef}...${rightRef}`,
+        ]);
+        const parts = stdout.trim().split(/\s+/);
+        if (parts.length < 2)
+            return null;
+        const left = Number.parseInt(parts[0], 10);
+        const right = Number.parseInt(parts[1], 10);
+        if (!Number.isFinite(left) || !Number.isFinite(right))
+            return null;
+        return { left, right };
+    }
+    catch {
+        return null;
+    }
+}
 /** Merge `remote/branch` into the current HEAD (follow-up integration). */
 export async function gitMergeRemoteBranch(cwd, remote, branch) {
     await runGit(cwd, ["merge", `${remote}/${branch}`, "--no-edit"]);

package/dist/lib/task-context.js

@@ -49,7 +49,7 @@ export function computeNextHint(input) {
         if (input.hasMergeRequest && !input.mergeRequestMerged)
             return "task-merge";
         if (input.hasLocalChanges)
-            return "task-reship";
+            return "task-ship-followup";
         return "task-add";
     }
     if (!input.resultFilled || !input.testFilled) {
@@ -57,36 +57,48 @@ export function computeNextHint(input) {
     }
     return input.hasMergeRequest ? "task-merge" : "task-ship";
 }
-export function hintToText(hint, cwd, task) {
+/** Multi-line NEXT block lines (without the leading arrow prefix). */
+export function hintToLines(hint, cwd, task) {
     switch (hint) {
         case "init":
-            return "Run `vibeops init` in this directory.";
+            return ["vibeops init"];
         case "task-add":
-            return "Run `vibeops task add` to start the next slice.";
+            return ["vibeops task add"];
         case "task-ship":
-            return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
-        case "task-reship":
+            return [task ? `vibeops task ship ${task.id}` : "vibeops task ship"];
+        case "task-ship-followup":
             return task
-                ? `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.";
+                ? [
+                    `Follow up on ${task.id} (after merge: confirm or --new-cycle)`,
+                    `vibeops task ship ${task.id}`,
+                ]
+                : ["vibeops task ship --new-cycle"];
         case "task-merge":
             return task
-                ? `Merge the MR (UI or \`vibeops task merge ${task.id}\`), then optional task sync.`
-                : "Merge the MR on the host or with `vibeops task merge`.";
+                ? [`vibeops task merge ${task.id}`, "(or merge in the host UI)"]
+                : ["vibeops task merge"];
         case "task-sync":
             return task
-                ? `Run \`vibeops task sync ${task.id}\` to delete task branches, then task add.`
-                : "Run `vibeops task sync` to delete task branches after merge.";
+                ? [`vibeops task sync ${task.id}`, "then: vibeops task add"]
+                : ["vibeops task sync"];
         case "cursor-plan":
             return task
-                ? `In Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC.`
-                : "Open the TASK file in Cursor Ask.";
+                ? [
+                    `Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC`,
+                ]
+                : ["Open the TASK file in Cursor Ask"];
         case "cursor-implement":
             return task
-                ? `In Cursor Agent: @${relPath(cwd, task.filePath)} — implement, then task ship.`
-                : "Implement per the TASK file in Cursor.";
+                ? [
+                    `Cursor Agent: @${relPath(cwd, task.filePath)} — implement`,
+                    `then: vibeops task ship ${task.id}`,
+                ]
+                : ["Implement per the TASK file, then vibeops task ship"];
     }
 }
+export function hintToText(hint, cwd, task) {
+    return hintToLines(hint, cwd, task).join(" · ");
+}
 export async function listInProgressTasks(paths) {
     return (await loadActionableTasks(paths.docsTasks)).filter((t) => t.status === "in_progress");
 }

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

@@ -1,3 +1,4 @@
+import { formatHostCliHint, formatHostCliMissingMessage } from "./git-host-cli.js";
 import { readText } from "./filesystem.js";
 import { readConfig } from "./config.js";
 import { detectGitHost, mergeRequestLabel } from "./git-host.js";
@@ -94,8 +95,11 @@ export async function finishTaskWithPullRequest(opts) {
     }
     const cliOk = await probeMergeRequestCli(gitCfg.host);
     if (!cliOk) {
-        const tool = gitCfg.host === "gitlab" ? "glab" : "gh";
-        log.warn(`${tool} CLI not found — create the ${label} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`);
+        log.warn(formatHostCliMissingMessage(gitCfg.host, `create the ${label}`));
+        for (const line of formatHostCliHint(gitCfg.host)) {
+            log.info(dim(`  ${line}`));
+        }
+        log.info(dim(`Create the ${label} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`));
         return { ok: true, pushed: true };
     }
     const config = await readConfig(opts.cwd);

package/dist/lib/task-reship.js

@@ -43,7 +43,7 @@ export function reshipNotFoundMessage(taskRef) {
     if (taskRef?.trim()) {
         return `Shipped TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
     }
-    return "No Shipped TASK found. Pass `vibeops task reship TASK-NNN`.";
+    return "No Shipped TASK found. Pass `vibeops task ship TASK-NNN` (use --new-cycle after merge).";
 }
 async function switchToTaskBranch(cwd, taskBranch) {
     try {

package/dist/lib/task-start.js

@@ -1,11 +1,19 @@
 import { relative, resolve } from "node:path";
 import { branchNameForTaskFile, readGitContext, readTaskFile, updateInlineStatus, upsertGitContext, } from "./task.js";
-import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, gitRemoteUrl, readGitInfo, } from "./git.js";
+import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { ensureIntegrationSynced, printIntegrationSyncDiagnosis, } from "./git-integration-sync.js";
 import { cyan, dim, log } from "./logger.js";
 function relOrAbs(root, p) {
     const r = relative(root, p);
     return r === "" ? "." : r.startsWith("..") ? p : r;
 }
+/** True when In Progress TASK has no task branch yet (failed mid-add). */
+export async function isIncompleteTaskStart(cwd, taskFile) {
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null)
+        return true;
+    return !(await gitBranchExists(cwd, ctx.taskBranch));
+}
 /** Create or resume task branch from integration branch and mark TASK In Progress. */
 export async function startTaskBranch(opts) {
     const cwd = resolve(opts.cwd);
@@ -49,20 +57,21 @@ export async function startTaskBranch(opts) {
         }
     }
     // Ensure integration branch is up-to-date before creating a new task branch.
-    if (!branchExists) {
-        const remoteUrl = await gitRemoteUrl(cwd, remote);
-        if (remoteUrl) {
-            const hasRemoteBranch = await gitRemoteBranchExists(cwd, remote, integrationBranch);
-            if (hasRemoteBranch) {
-                try {
-                    await gitPullFastForwardOnly(cwd, remote, integrationBranch);
-                    log.info(dim(`Pulled latest ${remote}/${integrationBranch} (--ff-only).`));
-                }
-                catch {
-                    log.warn(`Could not fast-forward pull ${remote}/${integrationBranch}. Resolve manually, then rerun task add.`);
-                    return false;
-                }
-            }
+    if (!branchExists && opts.skipIntegrationPull !== true) {
+        const synced = await ensureIntegrationSynced({
+            cwd,
+            remote,
+            integrationBranch,
+            fetch: true,
+        });
+        if (!synced.ok) {
+            printIntegrationSyncDiagnosis(synced.diagnosis);
+            log.blank();
+            log.info(dim(`TASK file is already created — after fixing sync, rerun ${cyan("vibeops task add")} to resume the branch (does not create a second TASK).`));
+            return false;
+        }
+        if (synced.pulled) {
+            log.info(dim(synced.diagnosis.summary));
         }
     }
     const baseBranch = integrationBranch;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.4.4",
+  "version": "2.5.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": {
@@ -29,6 +30,19 @@
   "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",
+    "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",
+    "prepack": "pnpm clean && pnpm build",
+    "publish:dry": "pnpm publish --dry-run --no-git-checks",
+    "publish:npm": "scripts/npm-publish.sh",
+    "publish:npm:dry": "scripts/npm-publish.sh --dry-run"
+  },
   "keywords": [
     "cursor",
     "ai",
@@ -47,15 +61,5 @@
     "@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/core/AGENTS.md

@@ -40,5 +40,5 @@ vibeops llm connect   # optional — task add / ship
 
 - One **In Progress** TASK at a time; **Shipped** does not block `task add`.
 - 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`.
+- `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.
 - Agents do not run `task merge` or `task sync` unless the human asks.

package/templates/core/docs/project/06-decisions.md

@@ -5,5 +5,5 @@
 ## D-001 · VibeOps workflow
 
 - **Date:** {{CREATED_AT}}
-- **Decision:** TASK-driven development with `vibeops task add` / `task ship` / `task reship` / `merge` / `sync` and Cursor for plan/build. TASK status: **In Progress** → **Shipped** only.
+- **Decision:** TASK-driven development with `vibeops task add` / `task ship` / `merge` / `sync` and Cursor for plan/build. TASK status: **In Progress** → **Shipped** only.
 - **Why:** Git `docs/tasks` beats chat as source of truth.

package/dist/commands/task-reship.js

@@ -1,21 +0,0 @@
-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 = {}) {
-    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();
-    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,
-    });
-}