@goodtek/vibeops 2.4.4 → 2.5.1

package/dist/commands/task-add.js

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { pathExists, writeText } from "../lib/filesystem.js";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { ensureIntegrationSynced, printIntegrationSyncDiagnosis, } from "../lib/git-integration-sync.js";
 import { askInput } from "../lib/inquirer-helpers.js";
 import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
@@ -8,7 +9,7 @@ import { slugify } from "../lib/slug.js";
 import { fallbackTaskDraft, llmScaffoldTask } from "../lib/task-add-llm.js";
 import { allocateNextTaskNumber, formatTaskId, uniqueTaskPath, } from "../lib/task-scaffold.js";
 import { findBlockingTask, relPath } from "../lib/task-context.js";
-import { startTaskBranch } from "../lib/task-start.js";
+import { isIncompleteTaskStart, startTaskBranch } from "../lib/task-start.js";
 import { loadActionableTasks, readGitContext } from "../lib/task.js";
 async function loadGitConfigOrNull(root, dryRun) {
     try {
@@ -25,6 +26,31 @@ async function loadGitConfigOrNull(root, dryRun) {
         throw e;
     }
 }
+async function finishWithBranch(root, taskId, filePath, gitCfg, opts) {
+    const relFile = relPath(root, filePath);
+    log.blank();
+    log.step("Starting task branch…");
+    const started = await startTaskBranch({
+        cwd: root,
+        taskFile: filePath,
+        integrationBranch: gitCfg.integrationBranch,
+        remote: gitCfg.remote,
+        allowDirty: true,
+        dryRun: opts.dryRun,
+        skipIntegrationPull: opts.skipIntegrationPull,
+    });
+    if (!started) {
+        process.exitCode = 1;
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    log.blank();
+    log.info(bold("Next in Cursor"));
+    log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
+    log.info(`  Agent: same file — implement`);
+    log.info(`  Ship: ${cyan(`vibeops task ship ${taskId}`)}`);
+}
 export async function taskAddCommand(opts = {}) {
     const root = resolve(opts.cwd ?? process.cwd());
     const dryRun = opts.dryRun === true;
@@ -36,7 +62,34 @@ export async function taskAddCommand(opts = {}) {
         return;
     const paths = projectPaths(root);
     const blocking = await findBlockingTask(paths, root);
-    if (blocking !== null) {
+    // Resume: In Progress file exists but task branch / Git Context was never finished.
+    if (blocking !== null && gitCfg !== null) {
+        const incomplete = await isIncompleteTaskStart(root, blocking.filePath);
+        if (incomplete) {
+            log.warn(`${yellow("Incomplete")} — ${bold(blocking.id)} exists but the task branch was not created.`);
+            log.info(`  ${dim("file")}   ${relPath(root, blocking.filePath)}`);
+            log.info(dim("Resuming branch setup (will not create a new TASK)…"));
+            if (!dryRun) {
+                const synced = await ensureIntegrationSynced({
+                    cwd: root,
+                    remote: gitCfg.remote,
+                    integrationBranch: gitCfg.integrationBranch,
+                    fetch: true,
+                });
+                if (!synced.ok) {
+                    printIntegrationSyncDiagnosis(synced.diagnosis);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (synced.pulled)
+                    log.info(dim(synced.diagnosis.summary));
+            }
+            await finishWithBranch(root, blocking.id, blocking.filePath, gitCfg, {
+                dryRun,
+                skipIntegrationPull: true,
+            });
+            return;
+        }
         const ctx = await readGitContext(blocking.filePath);
         log.warn(`${yellow("Blocked")} — ${bold(blocking.id)} is still open (${blocking.title || "no title"}).`);
         if (ctx) {
@@ -49,6 +102,34 @@ export async function taskAddCommand(opts = {}) {
         process.exitCode = 1;
         return;
     }
+    // Preflight: sync integration BEFORE writing a new TASK file (avoids half-created TASKs).
+    if (!dryRun && gitCfg !== null) {
+        log.step("Checking integration branch…");
+        const synced = await ensureIntegrationSynced({
+            cwd: root,
+            remote: gitCfg.remote,
+            integrationBranch: gitCfg.integrationBranch,
+            fetch: true,
+        });
+        if (!synced.ok) {
+            printIntegrationSyncDiagnosis(synced.diagnosis);
+            log.blank();
+            log.info(dim("No TASK file was created. Fix the integration branch, then rerun task add."));
+            process.exitCode = 1;
+            return;
+        }
+        if (synced.pulled) {
+            log.ok(synced.diagnosis.summary);
+        }
+        else if (synced.diagnosis.kind === "no_remote_branch" ||
+            synced.diagnosis.kind === "no_remote") {
+            log.info(dim(synced.diagnosis.summary));
+        }
+        else {
+            log.info(dim(`Integration ${gitCfg.integrationBranch} is ready.`));
+        }
+        log.blank();
+    }
     const ideaDefault = "New work slice";
     const idea = await askInput({
         message: "What are you doing now? (short)",
@@ -106,22 +187,8 @@ export async function taskAddCommand(opts = {}) {
     }
     await writeText(filePath, markdown);
     log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
-    log.blank();
-    log.step("Starting task branch…");
-    const started = await startTaskBranch({
-        cwd: root,
-        taskFile: filePath,
-        integrationBranch: gitCfg.integrationBranch,
-        remote: gitCfg.remote,
-        allowDirty: true,
+    await finishWithBranch(root, taskId, filePath, gitCfg, {
+        dryRun: false,
+        skipIntegrationPull: true,
     });
-    if (!started) {
-        process.exitCode = 1;
-        return;
-    }
-    log.blank();
-    log.info(bold("Next in Cursor"));
-    log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
-    log.info(`  Agent: same file — implement`);
-    log.info(`  Ship: ${cyan(`vibeops task ship ${taskId}`)}`);
 }

package/dist/commands/task-merge.js

@@ -1,5 +1,6 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { formatHostCliHint, formatHostCliMissingMessage } from "../lib/git-host-cli.js";
 import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
 import { gitRemoteUrl } from "../lib/git.js";
 import { bold, cyan, dim, log } from "../lib/logger.js";
@@ -55,7 +56,7 @@ export async function taskMergeCommand(taskRef, options = {}) {
         ? null
         : await resolveOpenTaskMergeRequest(cwd, target.taskFile);
     if (!dryRun && resolvedMr === null) {
-        log.error(`No open MR/PR for ${ctx.taskBranch} → ${ctx.baseBranch}. Run task ship or task reship first.`);
+        log.error(`No open MR/PR for ${ctx.taskBranch} → ${ctx.baseBranch}. Run task ship first.`);
         process.exitCode = 1;
         return;
     }
@@ -96,8 +97,11 @@ export async function taskMergeCommand(taskRef, options = {}) {
     if (state === "open") {
         const cliOk = await probeMergeRequestCli(host);
         if (!cliOk) {
-            const tool = host === "gitlab" ? "glab" : "gh";
-            log.error(`${tool} CLI not found — merge in the host UI, then task sync.`);
+            log.error(formatHostCliMissingMessage(host, `merge the ${label}`));
+            for (const line of formatHostCliHint(host)) {
+                log.info(dim(`  ${line}`));
+            }
+            log.info(dim("Or merge in the host UI, then task sync."));
             process.exitCode = 1;
             return;
         }

package/dist/commands/task-release.js

@@ -1,5 +1,6 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { formatHostCliHint, formatHostCliMissingMessage } from "../lib/git-host-cli.js";
 import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
 import { gitRemoteUrl } from "../lib/git.js";
 import { bold, dim, log } from "../lib/logger.js";
@@ -57,8 +58,10 @@ export async function taskReleaseCommand(options = {}) {
     }
     const cliOk = await probeMergeRequestCli(host);
     if (!cliOk) {
-        const tool = host === "gitlab" ? "glab" : "gh";
-        log.error(`${tool} CLI not found — create the release ${label} manually.`);
+        log.error(formatHostCliMissingMessage(host, `create the release ${label}`));
+        for (const line of formatHostCliHint(host)) {
+            log.info(dim(`  ${line}`));
+        }
         process.exitCode = 1;
         return;
     }

package/dist/lib/git-host-cli.js

@@ -0,0 +1,115 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Run a CLI with inherited stdio (e.g. `gh auth login`). */
+export function runInteractiveCli(bin, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, [...args], { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+export function hostCliTool(host) {
+    return host === "gitlab" ? "glab" : "gh";
+}
+export async function commandExists(bin) {
+    try {
+        await execFileAsync(bin, ["--version"], { maxBuffer: 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGhAuth() {
+    try {
+        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGlabAuth() {
+    try {
+        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeHostCliAuth(host) {
+    const tool = hostCliTool(host);
+    if (!(await commandExists(tool)))
+        return "missing";
+    const ok = host === "gitlab" ? await probeGlabAuth() : await probeGhAuth();
+    return ok ? "ok" : "unauthenticated";
+}
+/** Install / login lines shared by init and ship/merge. */
+export function formatHostCliHint(host) {
+    if (host === "gitlab") {
+        return [
+            `Install glab: https://gitlab.com/gitlab-org/cli#installation`,
+            `  brew install glab`,
+            `Then: glab auth login`,
+        ];
+    }
+    return [
+        `Install gh: https://cli.github.com/`,
+        `  brew install gh`,
+        `Then: gh auth login`,
+    ];
+}
+export function formatHostCliMissingMessage(host, purpose) {
+    const tool = hostCliTool(host);
+    return `${tool} CLI is required to ${purpose}.`;
+}
+export async function probeBrew() {
+    return commandExists("brew");
+}
+export async function brewInstall(pkg) {
+    await execFileAsync("brew", ["install", pkg], {
+        maxBuffer: 16 * 1024 * 1024,
+    });
+}
+/** Parse `owner/repo`, HTTPS, or SSH GitHub/GitLab URLs. */
+export function parseOwnerRepo(input) {
+    const raw = input.trim();
+    if (raw.length === 0)
+        return null;
+    const slug = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
+    const fromSlug = slug.exec(raw);
+    if (fromSlug && !raw.includes(":") && !raw.includes("@")) {
+        return { owner: fromSlug[1], repo: fromSlug[2] };
+    }
+    const https = /^https?:\/\/(?:www\.)?(?:github\.com|gitlab\.com)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i.exec(raw);
+    if (https) {
+        return { owner: https[1], repo: https[2].replace(/\.git$/i, "") };
+    }
+    const ssh = /^(?:git@|ssh:\/\/git@)(?:github\.com|gitlab\.com)[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(raw);
+    if (ssh) {
+        return { owner: ssh[1], repo: ssh[2].replace(/\.git$/i, "") };
+    }
+    return null;
+}
+export function remoteUrlForHost(host, owner, repo) {
+    if (host === "gitlab") {
+        return `https://gitlab.com/${owner}/${repo}.git`;
+    }
+    return `https://github.com/${owner}/${repo}.git`;
+}
+export async function repoExistsOnHost(host, owner, repo) {
+    const slug = `${owner}/${repo}`;
+    try {
+        if (host === "gitlab") {
+            await execFileAsync("glab", ["repo", "view", slug], { maxBuffer: 1024 * 1024 });
+            return true;
+        }
+        await execFileAsync("gh", ["repo", "view", slug], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/git-integration-sync.js

@@ -0,0 +1,214 @@
+import { gitFetchRemote, gitLeftRightCount, gitPullFastForwardOnly, gitRemoteBranchExists, gitRemoteUrl, gitRevParse, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { cyan, dim, log } from "./logger.js";
+function remoteRef(remote, branch) {
+    return `${remote}/${branch}`;
+}
+/**
+ * Classify why `git pull --ff-only` would fail for the integration branch.
+ * Call after fetch when possible so `origin/branch` is current.
+ */
+export async function diagnoseIntegrationSync(cwd, remote, integrationBranch) {
+    if ((await gitRemoteUrl(cwd, remote)) === null) {
+        return {
+            ok: true,
+            kind: "no_remote",
+            summary: `No git remote "${remote}" — using local ${integrationBranch} only.`,
+            fixes: [],
+        };
+    }
+    if (!(await gitRemoteBranchExists(cwd, remote, integrationBranch))) {
+        return {
+            ok: true,
+            kind: "no_remote_branch",
+            summary: `No ${remote}/${integrationBranch} yet — local branch is fine for first push.`,
+            fixes: [],
+        };
+    }
+    const git = await readGitInfo(cwd);
+    if (git.dirty === true) {
+        return {
+            ok: false,
+            kind: "dirty",
+            summary: `Working tree is dirty — cannot fast-forward ${integrationBranch}.`,
+            fixes: [
+                "git status",
+                "git stash push -u -m \"vibeops: before sync\"",
+                `git checkout ${integrationBranch}`,
+                `git pull --ff-only ${remote} ${integrationBranch}`,
+                "git stash pop   # if you stashed",
+                "vibeops task add",
+            ],
+        };
+    }
+    const localSha = await gitRevParse(cwd, integrationBranch);
+    const remoteSha = await gitRevParse(cwd, remoteRef(remote, integrationBranch));
+    if (localSha === null || remoteSha === null) {
+        return {
+            ok: false,
+            kind: "pull_failed",
+            summary: `Could not resolve ${integrationBranch} or ${remote}/${integrationBranch}.`,
+            fixes: [
+                `git fetch ${remote}`,
+                `git checkout ${integrationBranch}`,
+                `git pull --ff-only ${remote} ${integrationBranch}`,
+            ],
+        };
+    }
+    if (localSha === remoteSha) {
+        return {
+            ok: true,
+            kind: "ok",
+            summary: `${integrationBranch} matches ${remote}/${integrationBranch}.`,
+            fixes: [],
+        };
+    }
+    const counts = await gitLeftRightCount(cwd, integrationBranch, remoteRef(remote, integrationBranch));
+    const ahead = counts?.left ?? 0;
+    const behind = counts?.right ?? 0;
+    if (ahead > 0 && behind > 0) {
+        return {
+            ok: false,
+            kind: "diverged",
+            summary: `Local ${integrationBranch} and ${remote}/${integrationBranch} have diverged (local +${ahead}, remote +${behind}).`,
+            fixes: [
+                `git fetch ${remote}`,
+                `git checkout ${integrationBranch}`,
+                `# Prefer remote (discards local-only commits on ${integrationBranch}):`,
+                `git reset --hard ${remote}/${integrationBranch}`,
+                `# Or keep local commits: git pull --rebase ${remote} ${integrationBranch}`,
+                "vibeops task add",
+            ],
+            ahead,
+            behind,
+        };
+    }
+    if (ahead > 0 && behind === 0) {
+        return {
+            ok: false,
+            kind: "ahead",
+            summary: `Local ${integrationBranch} is ${ahead} commit(s) ahead of ${remote}/${integrationBranch} — fast-forward pull cannot apply.`,
+            fixes: [
+                `git checkout ${integrationBranch}`,
+                `# Push local commits, or reset to remote if they should not exist:`,
+                `git push -u ${remote} ${integrationBranch}`,
+                `# or: git reset --hard ${remote}/${integrationBranch}`,
+                "vibeops task add",
+            ],
+            ahead,
+            behind,
+        };
+    }
+    // behind only — ff-only should work
+    return {
+        ok: true,
+        kind: "ok",
+        summary: `${integrationBranch} is ${behind} commit(s) behind ${remote}/${integrationBranch} (ff-only OK).`,
+        fixes: [],
+        ahead,
+        behind,
+    };
+}
+export function printIntegrationSyncDiagnosis(d) {
+    if (d.ok) {
+        if (d.kind !== "ok" && d.kind !== "no_remote_branch")
+            log.info(dim(d.summary));
+        return;
+    }
+    log.error(d.summary);
+    if (d.fixes.length > 0) {
+        log.blank();
+        log.info(dim("Fix (run in this repo):"));
+        for (const line of d.fixes) {
+            if (line.startsWith("#"))
+                log.info(dim(`  ${line}`));
+            else
+                log.info(`  ${cyan(line)}`);
+        }
+    }
+}
+/**
+ * Fetch + ensure local integration can be used as the base for a new task branch.
+ * Switches to the integration branch, then `--ff-only` pull when needed. Never force-resets.
+ */
+export async function ensureIntegrationSynced(opts) {
+    const { cwd, remote, integrationBranch } = opts;
+    const doFetch = opts.fetch !== false;
+    if (opts.dryRun === true) {
+        const d = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        return { ok: d.ok || d.kind === "no_remote_branch", diagnosis: d, pulled: false };
+    }
+    if ((await gitRemoteUrl(cwd, remote)) === null) {
+        const d = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        return { ok: true, diagnosis: d, pulled: false };
+    }
+    if (doFetch) {
+        try {
+            await gitFetchRemote(cwd, remote);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(dim(`git fetch failed (${msg}) — diagnosing with local refs.`));
+        }
+    }
+    const git = await readGitInfo(cwd);
+    if (git.branch !== integrationBranch) {
+        const switched = await gitSwitchToBranch(cwd, integrationBranch, remote);
+        if (!switched) {
+            return {
+                ok: false,
+                diagnosis: {
+                    ok: false,
+                    kind: "pull_failed",
+                    summary: `Could not switch to integration branch "${integrationBranch}".`,
+                    fixes: [
+                        "git status",
+                        `git checkout ${integrationBranch}`,
+                        `# If checkout fails due to local changes: git stash -u`,
+                        `git pull --ff-only ${remote} ${integrationBranch}`,
+                        "vibeops task add",
+                    ],
+                },
+                pulled: false,
+            };
+        }
+    }
+    let diagnosis = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+    if (!diagnosis.ok) {
+        return { ok: false, diagnosis, pulled: false };
+    }
+    if (diagnosis.kind === "no_remote_branch") {
+        return { ok: true, diagnosis, pulled: false };
+    }
+    const localSha = await gitRevParse(cwd, integrationBranch);
+    const remoteSha = await gitRevParse(cwd, remoteRef(remote, integrationBranch));
+    if (localSha !== null && remoteSha !== null && localSha === remoteSha) {
+        return { ok: true, diagnosis, pulled: false };
+    }
+    try {
+        await gitPullFastForwardOnly(cwd, remote, integrationBranch);
+        diagnosis = {
+            ok: true,
+            kind: "ok",
+            summary: `Pulled latest ${remote}/${integrationBranch} (--ff-only).`,
+            fixes: [],
+        };
+        return { ok: true, diagnosis, pulled: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        diagnosis = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        if (diagnosis.ok) {
+            diagnosis = {
+                ok: false,
+                kind: "pull_failed",
+                summary: `git pull --ff-only failed: ${msg}`,
+                fixes: [
+                    `git checkout ${integrationBranch}`,
+                    `git pull --ff-only ${remote} ${integrationBranch}`,
+                    "vibeops task add",
+                ],
+            };
+        }
+        return { ok: false, diagnosis, pulled: false };
+    }
+}