@goodtek/vibeops 0.7.22 → 1.0.0

package/dist/lib/task-merge.js

@@ -1,14 +1,9 @@
-import { ghAuthStatus, runGh } from "./github-cli.js";
-import { gitBranchExists, gitCheckout, gitCommitsAhead, gitDeleteBranch, gitGovernanceOnlyDirty, gitRemoteUrl, readGitInfo, runGit, } from "./git.js";
+import { gitBranchExists, gitCheckout, gitDeleteBranch, gitGovernanceOnlyDirty, gitRemoteUrl, readGitInfo, runGit, } from "./git.js";
 import { bold, cyan, dim, log } from "./logger.js";
 function mergeCommitMessage(taskId, taskTitle, taskBranch) {
-    const slug = taskTitle.replace(/^TASK-\d+\s*[·:\-]\s*/i, "").trim() || taskId;
+    const slug = taskTitle.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
     return `merge(${taskId.toLowerCase()}): ${slug} (${taskBranch})`;
 }
-function prTitle(taskId, taskTitle) {
-    const slug = taskTitle.replace(/^TASK-\d+\s*[·:\-]\s*/i, "").trim() || taskId;
-    return `feat(${taskId.toLowerCase()}): ${slug}`;
-}
 async function gitPush(cwd, remote, ref, setUpstream) {
     const args = ["push"];
     if (setUpstream)
@@ -16,170 +11,64 @@ async function gitPush(cwd, remote, ref, setUpstream) {
     args.push(remote, ref);
     await runGit(cwd, args);
 }
-async function findOpenPrNumber(baseBranch, headBranch) {
-    const res = await runGh([
-        "pr",
-        "list",
-        "--head",
-        headBranch,
-        "--base",
-        baseBranch,
-        "--state",
-        "open",
-        "--json",
-        "number,url",
-        "--limit",
-        "1",
-    ]);
-    if (!res.ok)
-        return null;
-    try {
-        const rows = JSON.parse(res.stdout);
-        const row = rows[0];
-        if (row && typeof row.number === "number") {
-            return { number: row.number, url: row.url };
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
 export async function mergeTaskBranch(opts) {
-    const mode = opts.mode ?? "direct";
     const remote = opts.remote ?? "origin";
     const { cwd, gitCtx, taskId, taskTitle } = opts;
     const { baseBranch, taskBranch } = gitCtx;
     if (baseBranch === taskBranch) {
         log.error("Task branch matches base branch; nothing to merge.");
-        return { ok: false, mode };
+        return { ok: false };
     }
     const git = await readGitInfo(cwd);
     if (!git.isRepo) {
         log.error("Not a git repository.");
-        return { ok: false, mode };
-    }
-    const remoteUrl = await gitRemoteUrl(cwd, remote);
-    if (!remoteUrl) {
-        log.error(`No git remote "${remote}". Run ${cyan("vibeops github init")} or add the remote first.`);
-        return { ok: false, mode };
+        return { ok: false };
     }
     const branchExists = await gitBranchExists(cwd, taskBranch);
     if (!branchExists) {
         log.error(`Local task branch not found: ${taskBranch}`);
-        return { ok: false, mode };
+        return { ok: false };
     }
-    const ahead = await gitCommitsAhead(cwd, baseBranch, taskBranch);
-    if (ahead === 0) {
-        log.warn(`No commits on ${taskBranch} ahead of ${baseBranch}. Merge may be a no-op.`);
+    const remoteUrl = await gitRemoteUrl(cwd, remote);
+    const hasRemote = remoteUrl !== null;
+    if (opts.dryRun) {
+        log.info(bold("dry-run — would merge:"));
+        log.info(`  · checkout ${baseBranch}`);
+        log.info(`  · merge --no-ff ${taskBranch}`);
+        if (hasRemote)
+            log.info(`  · push ${remote} (optional)`);
+        log.info(`  · delete local ${taskBranch}`);
+        return { ok: true };
     }
-    const planLines = [
-        `push ${remote} ${taskBranch}`,
-        mode === "direct"
-            ? `checkout ${baseBranch} · pull · merge --no-ff ${taskBranch} · push ${remote} ${baseBranch}`
-            : `gh pr create (if needed) · gh pr merge --merge --delete-branch`,
-        `delete local branch ${taskBranch}`,
-        mode === "direct" ? `delete remote branch ${remote}/${taskBranch}` : "(remote branch removed by gh if supported)",
-    ];
-    if (opts.dryRun === true) {
-        log.info(bold("dry-run — would perform:"));
-        for (const line of planLines) {
-            log.info(`  · ${line}`);
+    if (git.dirty === true && opts.allowDirty !== true) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            log.error("Working tree is dirty. Commit or use --allow-dirty.");
+            return { ok: false };
         }
-        return { ok: true, mode };
+        log.warn("Dirty tree is governance-only — proceeding.");
     }
-    log.step(bold(`Merging ${cyan(taskBranch)} → ${cyan(baseBranch)} (${mode})`));
+    log.step(bold(`Merging ${cyan(taskBranch)} → ${cyan(baseBranch)}`));
     try {
-        log.step(`Pushing ${taskBranch} to ${remote}…`);
-        await gitPush(cwd, remote, taskBranch, true);
-        log.ok(`pushed ${taskBranch}`);
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        log.error(`git push failed: ${msg}`);
-        return { ok: false, mode };
-    }
-    if (mode === "pr") {
-        const auth = await ghAuthStatus();
-        if (!auth.authenticated) {
-            log.error(`gh is not authenticated. Run ${cyan("gh auth login")} or use direct merge (default).`);
-            return { ok: false, mode };
-        }
-        let pr = await findOpenPrNumber(baseBranch, taskBranch);
-        if (!pr) {
-            log.step("Opening pull request…");
-            const create = await runGh([
-                "pr",
-                "create",
-                "--base",
-                baseBranch,
-                "--head",
-                taskBranch,
-                "--title",
-                prTitle(taskId, taskTitle),
-                "--body",
-                `Automated via vibeops next for ${taskId}.`,
-            ]);
-            if (!create.ok) {
-                log.error(`gh pr create failed: ${create.stderr.trim() || create.stdout.trim()}`);
-                return { ok: false, mode };
+        if (hasRemote) {
+            try {
+                await gitPush(cwd, remote, taskBranch, true);
+                await runGit(cwd, ["fetch", remote]);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log.warn(`Push skipped (${msg}). Continuing with local merge.`);
             }
-            const url = create.stdout.trim();
-            log.ok(`PR created${url.length > 0 ? `: ${url}` : ""}`);
-            pr = await findOpenPrNumber(baseBranch, taskBranch);
-        }
-        else {
-            log.ok(`Using existing PR #${pr.number}`);
-        }
-        if (!pr) {
-            log.error("Could not find PR number after create.");
-            return { ok: false, mode };
-        }
-        log.step(`Merging PR #${pr.number}…`);
-        const merged = await runGh([
-            "pr",
-            "merge",
-            String(pr.number),
-            "--merge",
-            "--delete-branch",
-        ]);
-        if (!merged.ok) {
-            log.error(`gh pr merge failed: ${merged.stderr.trim() || merged.stdout.trim()}`);
-            return { ok: false, mode };
-        }
-        log.ok(`PR #${pr.number} merged`);
-        try {
-            await gitCheckout(cwd, baseBranch);
-            await runGit(cwd, ["pull", remote, baseBranch]);
-        }
-        catch {
-            log.warn(`Run manually: git switch ${baseBranch} && git pull ${remote} ${baseBranch}`);
         }
-        if (await gitBranchExists(cwd, taskBranch)) {
+        await gitCheckout(cwd, baseBranch);
+        if (hasRemote) {
             try {
-                await gitDeleteBranch(cwd, taskBranch, { force: true });
-                log.ok(`deleted local branch ${taskBranch}`);
+                await runGit(cwd, ["pull", remote, baseBranch]);
             }
             catch {
-                log.warn(`Could not delete local branch ${taskBranch}.`);
+                log.warn(dim(`Could not pull ${remote}/${baseBranch} — merging locally.`));
             }
         }
-        return { ok: true, mode, prUrl: pr.url };
-    }
-    // direct merge
-    if (git.dirty === true && opts.allowDirty !== true) {
-        const gov = await gitGovernanceOnlyDirty(cwd);
-        if (!gov.onlyGovernance) {
-            log.error("Working tree is dirty. Commit or stash before merging, or rerun with --allow-dirty.");
-            return { ok: false, mode };
-        }
-        log.warn("Dirty tree has only governance docs — proceeding.");
-    }
-    try {
-        await runGit(cwd, ["fetch", remote]);
-        await gitCheckout(cwd, baseBranch);
-        await runGit(cwd, ["pull", remote, baseBranch]);
-        log.step(`Merging ${taskBranch} into ${baseBranch}…`);
         await runGit(cwd, [
             "merge",
             "--no-ff",
@@ -187,34 +76,40 @@ export async function mergeTaskBranch(opts) {
             "-m",
             mergeCommitMessage(taskId, taskTitle, taskBranch),
         ]);
-        await gitPush(cwd, remote, baseBranch, false);
-        log.ok(`merged and pushed ${baseBranch}`);
+        if (hasRemote) {
+            try {
+                await gitPush(cwd, remote, baseBranch, false);
+            }
+            catch {
+                log.warn(dim(`Merge commit created locally; push ${remote} ${baseBranch} manually.`));
+            }
+        }
+        log.ok(`Merged into ${baseBranch}`);
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        log.error(`merge failed: ${msg}`);
-        log.info(dim(`  Resolve conflicts on ${baseBranch}, then commit and push manually.`));
-        return { ok: false, mode };
+        log.error(`Merge failed: ${msg}`);
+        return { ok: false };
     }
     try {
         await gitDeleteBranch(cwd, taskBranch, { force: false });
-        log.ok(`deleted local branch ${taskBranch}`);
+        log.ok(`Deleted local branch ${taskBranch}`);
     }
     catch {
         try {
             await gitDeleteBranch(cwd, taskBranch, { force: true });
-            log.ok(`deleted local branch ${taskBranch} (force)`);
         }
         catch {
             log.warn(`Could not delete local branch ${taskBranch}.`);
         }
     }
-    try {
-        await runGit(cwd, ["push", remote, "--delete", taskBranch]);
-        log.ok(`deleted remote branch ${remote}/${taskBranch}`);
-    }
-    catch {
-        log.warn(dim(`Remote branch may already be gone. To remove: git push ${remote} --delete ${taskBranch}`));
+    if (hasRemote) {
+        try {
+            await runGit(cwd, ["push", remote, "--delete", taskBranch]);
+        }
+        catch {
+            log.warn(dim(`Remote branch ${remote}/${taskBranch} may already be gone.`));
+        }
     }
-    return { ok: true, mode };
+    return { ok: true };
 }

package/dist/lib/task-scaffold.js

@@ -1,5 +1,16 @@
 import { basename, join } from "node:path";
 import { statusDisplay } from "./task.js";
+export const V3_TASK_SECTIONS = [
+    "Status",
+    "Goal",
+    "Scope",
+    "Out of Scope",
+    "Acceptance Criteria",
+    "Test Plan",
+    "Git Context",
+    "Result",
+    "Test Result",
+];
 export function allocateNextTaskNumber(tasks) {
     let max = 0;
     for (const t of tasks) {
@@ -12,67 +23,37 @@ export function allocateNextTaskNumber(tasks) {
 export function formatTaskId(number) {
     return `TASK-${String(number).padStart(3, "0")}`;
 }
-export function buildWorkNowTaskMarkdown(draft) {
-    const spawnedNote = draft.spawnedFrom
-        ? `\n\nWork-now slice while **${draft.spawnedFrom}** is still open — not a pre-planned backlog item scheduled after later TASK numbers.`
-        : "";
+export function buildMinimalTaskMarkdown(draft) {
     return `# ${draft.id}: ${draft.title}
 
 ## Status
 
 ${statusDisplay("planned")}
 
-## MVP Phase
-
-${draft.mvpPhase}
-
 ## Goal
 
 ${draft.idea.trim()}
 
-## Background
-
-${draft.idea.trim()}${spawnedNote}
-
 ## Scope
 
 - Deliver the goal above in a single focused pass.
 
 ## Out of Scope
 
-- Unrelated backlog items and broad refactors not required for this slice.
+- Unrelated refactors and features outside this slice.
 
 ## Acceptance Criteria
 
-1. Goal and Scope are met and verifiable from the repo or commands in Test Plan.
-2. Result and Test Result sections are filled before \`vibeops done\`.
-
-## Files to Inspect First
-
-- (add paths before implementation)
-
-## Expected Files to Change
-
-- (list as you implement)
-
-## Risks
-
-- Scope creep from the parent TASK — keep this slice narrow.
+1. Goal and Scope are met and verifiable via Test Plan.
+2. Result and Test Result are filled before \`vibeops task done\`.
 
 ## Test Plan
 
-- \`vibeops task check ${draft.id}\`
-- Project-specific checks for the change
-
-## Rollback Plan
-
-- \`vibeops rollback ${draft.id}\` (advisory) or revert the task branch commits.
+- Project-specific checks for this change
 
-## Implementation Plan
+## Git Context
 
-1. Confirm Scope with the open parent TASK (if any).
-2. Implement on \`vibeops start ${draft.id}\`.
-3. Fill Result and Test Result, then \`vibeops done ${draft.id}\`.
+(populated by \`vibeops task add\`)
 
 ## Result
 
@@ -98,13 +79,28 @@ export function uniqueTaskPath(tasksDir, taskId, baseSlug, existingPaths) {
     }
     return { slug, filePath: join(tasksDir, name) };
 }
-export function titleFromIdea(idea, explicitTitle) {
-    const t = explicitTitle?.trim();
-    if (t && t.length > 0)
-        return t;
+export function titleFromIdea(idea) {
     const oneLine = idea.replace(/\s+/g, " ").trim();
     if (oneLine.length <= 80)
         return oneLine;
-    const cut = oneLine.slice(0, 77).trimEnd();
-    return `${cut}...`;
+    return `${oneLine.slice(0, 77).trimEnd()}...`;
+}
+export function ensureV3Sections(markdown) {
+    let body = markdown;
+    for (const section of V3_TASK_SECTIONS) {
+        const re = new RegExp(`^##\\s+${section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "im");
+        if (!re.test(body)) {
+            body = `${body.trimEnd()}\n\n## ${section}\n\n(not yet)\n`;
+        }
+    }
+    return body;
+}
+export function normalizeTaskHeader(markdown, taskId, title) {
+    const lines = markdown.split("\n");
+    const header = `# ${taskId}: ${title}`;
+    if (lines.length > 0 && /^#\s+/.test(lines[0])) {
+        lines[0] = header;
+        return lines.join("\n");
+    }
+    return `${header}\n\n${markdown}`;
 }

package/dist/lib/task-start.js

@@ -0,0 +1,72 @@
+import { relative, resolve } from "node:path";
+import { branchNameForTaskFile, readGitContext, readTaskFile, updateInlineStatus, upsertGitContext, } from "./task.js";
+import { detectDefaultBranch, gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, readGitInfo, } from "./git.js";
+import { cyan, dim, log } from "./logger.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+/** Create or resume task branch and mark TASK In Progress (used by `task add`). */
+export async function startTaskBranch(opts) {
+    const cwd = resolve(opts.cwd);
+    const taskFile = opts.taskFile;
+    const meta = await readTaskFile(taskFile);
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        if (opts.dryRun) {
+            log.info(dim("dry-run — would require a git repository"));
+            return true;
+        }
+        log.error("Not a git repository. Run `vibeops init --git` first.");
+        return false;
+    }
+    if (git.dirty === true && opts.allowDirty !== true) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            log.error("Git working tree is dirty. Commit or stash, or rerun with --allow-dirty.");
+            return false;
+        }
+        log.warn("Only governance paths are dirty — proceeding.");
+    }
+    const baseBranch = git.branch ?? (await detectDefaultBranch(cwd)) ?? "main";
+    const baseCommit = (await gitHeadCommit(cwd)) ?? "";
+    if (baseCommit.length === 0) {
+        log.error("No commits on HEAD yet. Create an initial commit first.");
+        return false;
+    }
+    const taskBranch = branchNameForTaskFile(taskFile);
+    const ctx = {
+        baseBranch,
+        baseCommit,
+        taskBranch,
+        startedAt: new Date().toISOString(),
+    };
+    const existingCtx = await readGitContext(taskFile);
+    const branchExists = await gitBranchExists(cwd, taskBranch);
+    log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
+    log.info(`  ${dim("base")}         ${baseBranch} @ ${baseCommit.slice(0, 7)}`);
+    if (opts.dryRun) {
+        log.info(dim(branchExists
+            ? `dry-run — would git switch ${taskBranch}`
+            : `dry-run — would git switch -c ${taskBranch}`));
+        return true;
+    }
+    if (branchExists) {
+        await gitCheckout(cwd, taskBranch);
+        if (meta.status === "planned") {
+            await updateInlineStatus(taskFile, "in_progress");
+        }
+        if (existingCtx === null) {
+            await upsertGitContext(taskFile, ctx);
+        }
+        log.ok(`Resumed ${taskBranch}`);
+    }
+    else {
+        await gitCheckoutNewBranch(cwd, taskBranch, baseBranch);
+        await updateInlineStatus(taskFile, "in_progress");
+        await upsertGitContext(taskFile, ctx);
+        log.ok(`Branch ${taskBranch} ready`);
+    }
+    log.info(`  ${dim("file")}         ${relOrAbs(cwd, taskFile)}`);
+    return true;
+}