@goodtek/vibeops 0.4.0 → 0.7.22

package/dist/lib/task-add-cursor.js

@@ -0,0 +1,81 @@
+import { join } from "node:path";
+import { cursorAgentPrint, extractAgentAssistantText } from "./plan-llm-cursor-agent.js";
+import { parsePlannerFenceFiles, writePlannerFiles } from "./plan-apply-planner.js";
+import { probeCursorAgentCli } from "./plan-llm-detect.js";
+import { REQUIRED_TASK_SECTIONS } from "./task-generator.js";
+import { bold, log } from "./logger.js";
+const SINGLE_TASK_SYSTEM = `You are the VibeOps Planner Agent. Create exactly ONE TASK markdown file.
+
+Rules:
+- Output normal markdown with exactly one fenced code block.
+- First line inside the block MUST be: <!-- file: docs/tasks/TASK-NNN-slug.md --> (use the path given in the user message).
+- Fill every section listed in the template. Status must be "planned". Git Context and Result sections use placeholders only.
+- Do not create application code. Do not edit files outside docs/tasks/.
+- Acceptance Criteria must be numbered and testable.`;
+export async function generateTaskFileViaCursor(input) {
+    const relPath = `docs/tasks/${input.taskId}-${input.slug}.md`;
+    const phase = input.phase?.trim() || "MVP 1";
+    if (input.dryRun === true) {
+        return { ok: true, writtenPath: relPath };
+    }
+    const probe = await probeCursorAgentCli(input.cwd);
+    if (!probe.ok) {
+        return {
+            ok: false,
+            reason: probe.reason ?? "Cursor Agent CLI is not ready. Run `agent login` or use quick skeleton mode.",
+        };
+    }
+    const userPrompt = `${SINGLE_TASK_SYSTEM}
+
+Create this file:
+
+<!-- file: ${relPath} -->
+
+Template sections (all required):
+${REQUIRED_TASK_SECTIONS.map((s) => `- ${s}`).join("\n")}
+
+TASK id: ${input.taskId}
+Title: ${input.title}
+MVP Phase: ${phase}
+
+User description:
+${input.idea}
+
+Write the complete TASK markdown body now.`;
+    log.step(bold(`Cursor Agent is writing ${relPath}…`));
+    try {
+        const raw = await cursorAgentPrint({
+            cwd: input.cwd,
+            prompt: userPrompt,
+            model: input.model,
+        });
+        const text = extractAgentAssistantText(raw);
+        const parsed = parsePlannerFenceFiles(text);
+        const match = parsed.find((f) => f.relativePath === relPath) ??
+            parsed.find((f) => f.relativePath.endsWith(`${input.taskId}-${input.slug}.md`)) ??
+            parsed[0];
+        if (!match) {
+            return {
+                ok: false,
+                reason: "Cursor output did not include a valid <!-- file: docs/tasks/... --> block.",
+            };
+        }
+        if (match.relativePath !== relPath) {
+            log.warn(`Model used path ${match.relativePath}; writing to planned ${relPath}.`);
+        }
+        const written = await writePlannerFiles(input.cwd, [
+            { relativePath: relPath, content: match.content },
+        ]);
+        if (written.length === 0) {
+            return { ok: false, reason: "Failed to write TASK file." };
+        }
+        return { ok: true, writtenPath: relPath };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { ok: false, reason: msg };
+    }
+}
+export function plannedTaskRelPath(taskId, slug) {
+    return join("docs", "tasks", `${taskId}-${slug}.md`);
+}

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

@@ -0,0 +1,268 @@
+import { join, relative } from "node:path";
+import { readTextOrNull } from "./filesystem.js";
+import { llmCompleteJson } from "./llm-complete.js";
+import { bold, dim, log } from "./logger.js";
+import { askInput, askSelect, yesNoSelect } from "./inquirer-helpers.js";
+import { pickPlanLlmProvider } from "./plan-llm-session.js";
+import { extractJsonObject } from "./plan-llm-openai.js";
+import { projectPaths } from "./paths.js";
+import { slugify } from "./slug.js";
+import { buildTaskBuildPrompt } from "./task-add-build-prompt.js";
+import { statusDisplay } from "./task.js";
+const MAX_PLAN_TURNS = 36;
+const REQUIRED_SECTIONS = [
+    "Status",
+    "MVP Phase",
+    "Goal",
+    "Background",
+    "Scope",
+    "Out of Scope",
+    "Acceptance Criteria",
+    "Files to Inspect First",
+    "Expected Files to Change",
+    "Risks",
+    "Test Plan",
+    "Rollback Plan",
+    "Implementation Plan",
+    "Result",
+    "Test Result",
+];
+function parseTaskPlanTurn(jsonText) {
+    const raw = JSON.parse(jsonText);
+    const turn = raw.turn;
+    if (turn === "done") {
+        const taskMarkdown = typeof raw.taskMarkdown === "string" ? raw.taskMarkdown.trim() : "";
+        const buildPromptMarkdown = typeof raw.buildPromptMarkdown === "string" ? raw.buildPromptMarkdown.trim() : "";
+        if (taskMarkdown.length === 0) {
+            throw new Error('Invalid JSON: "done" needs non-empty "taskMarkdown".');
+        }
+        if (buildPromptMarkdown.length === 0) {
+            throw new Error('Invalid JSON: "done" needs non-empty "buildPromptMarkdown".');
+        }
+        return { turn: "done", taskMarkdown, buildPromptMarkdown };
+    }
+    if (turn === "question") {
+        const message = typeof raw.message === "string" ? raw.message.trim() : "";
+        if (message.length === 0)
+            throw new Error('Invalid JSON: "question" needs "message".');
+        const kindRaw = typeof raw.inputKind === "string" ? raw.inputKind : "text";
+        const inputKind = kindRaw === "select" || kindRaw === "confirm" ? kindRaw : "text";
+        const options = Array.isArray(raw.options)
+            ? raw.options.filter((x) => typeof x === "string")
+            : undefined;
+        return { turn: "question", message, inputKind, options };
+    }
+    throw new Error('LLM JSON must use turn "question" or "done".');
+}
+async function readSnippet(absPath, maxChars) {
+    const text = await readTextOrNull(absPath);
+    if (text === null)
+        return null;
+    const t = text.trim();
+    return t.length <= maxChars ? t : `${t.slice(0, maxChars)}\n…`;
+}
+export async function loadTaskAddProjectContext(cwd) {
+    const paths = projectPaths(cwd);
+    const chunks = [];
+    const candidates = [
+        join(paths.docsProject, "05-current-state.md"),
+        join(paths.docsProject, "03-current-state.md"),
+        join(paths.docsProject, "02-mvp-scope.md"),
+        join(paths.docsProject, "03-architecture.md"),
+        join(paths.docsProject, "04-tech-stack.md"),
+        join(paths.docsProject, "06-decisions.md"),
+    ];
+    for (const p of candidates) {
+        const snip = await readSnippet(p, 3500);
+        if (snip) {
+            chunks.push(`### ${relative(cwd, p)}\n\n${snip}`);
+        }
+    }
+    return chunks.length > 0 ? chunks.join("\n\n") : "(no docs/project context files found)";
+}
+function quickTaskSystemPrompt() {
+    return `You are a VibeOps TASK author. Respond with JSON only (no markdown fence).
+
+Schema:
+{
+  "title": "short title without TASK- id prefix",
+  "slug": "kebab-case-slug-max-60-chars-no-task-prefix",
+  "markdown": "full TASK markdown file"
+}
+
+The markdown file must:
+- Start with # TASK-NNN: title (use the exact TASK id provided)
+- Include every section: ${REQUIRED_SECTIONS.join(", ")}
+- Status body: ${statusDisplay("planned")}
+- Result and Test Result: (not yet)
+- Keep Scope and Acceptance Criteria minimal but valid — the human will edit heavily in Cursor
+- Do not invent TASK numbers other than the one given`;
+}
+function taskPlanSystemPrompt(taskId, projectName) {
+    return `You are a VibeOps TASK planner. Interview the user, then produce a complete TASK and a Cursor build prompt.
+
+Respond with JSON only (no markdown fence).
+
+Turn "question":
+{
+  "turn": "question",
+  "message": "…",
+  "inputKind": "text" | "select" | "confirm",
+  "options": ["…"]  // required for select; optional for confirm (Yes/No implied)
+}
+
+Turn "done":
+{
+  "turn": "done",
+  "taskMarkdown": "full TASK file for ${taskId}",
+  "buildPromptMarkdown": "markdown for Cursor — implement ${taskId} per the TASK"
+}
+
+taskMarkdown rules:
+- # ${taskId}: … as first line
+- All sections: ${REQUIRED_SECTIONS.join(", ")}
+- Status: ${statusDisplay("planned")}; Result / Test Result: (not yet)
+- Acceptance Criteria numbered and verifiable
+- Align with docs/project; put out-of-MVP items in Out of Scope
+
+buildPromptMarkdown rules:
+- Standalone implementer brief for Cursor (like mvp-build.md)
+- Reference the TASK path; list read-first docs; definition of done
+- Project: ${projectName}
+
+Ask enough questions to nail Scope, Acceptance Criteria, and Test Plan. Then finish with "done".`;
+}
+function parseQuickTaskJson(jsonText) {
+    const raw = JSON.parse(jsonText);
+    const title = typeof raw.title === "string" ? raw.title.trim() : "";
+    const slug = typeof raw.slug === "string" ? slugify(raw.slug, "task") : "";
+    const markdown = typeof raw.markdown === "string" ? raw.markdown.trim() : "";
+    if (title.length === 0)
+        throw new Error('LLM JSON missing "title".');
+    if (markdown.length === 0)
+        throw new Error('LLM JSON missing "markdown".');
+    return { title, slug: slug.length > 0 ? slug : slugify(title), markdown };
+}
+export function normalizeTaskMarkdownHeader(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}`;
+}
+export function ensureTaskSections(markdown) {
+    let body = markdown;
+    for (const section of REQUIRED_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;
+}
+async function collectTaskPlanAnswer(q) {
+    if (q.inputKind === "confirm") {
+        const yes = await yesNoSelect({ message: q.message, defaultValue: true });
+        return yes ? "Yes" : "No";
+    }
+    if (q.inputKind === "select" && q.options && q.options.length > 0) {
+        return await askSelect({
+            message: q.message,
+            nonInteractive: false,
+            choices: q.options,
+            default: q.options[0],
+        });
+    }
+    return await askInput({ message: q.message, nonInteractive: false, required: true });
+}
+export async function llmGenerateQuickTask(params) {
+    const provider = await pickPlanLlmProvider(params.cwd, undefined, { interactiveLogin: false });
+    if (provider === null)
+        return null;
+    const context = await loadTaskAddProjectContext(params.cwd);
+    const latest = params.latestDone !== undefined && params.latestDone !== null
+        ? `Latest done TASK: ${params.latestDone.id} — ${params.latestDone.title}`
+        : "";
+    const messages = [
+        { role: "system", content: quickTaskSystemPrompt() },
+        {
+            role: "user",
+            content: [
+                `TASK id: ${params.taskId}`,
+                `User intent: ${params.idea}`,
+                latest,
+                "",
+                "Project context:",
+                context,
+            ]
+                .filter((l) => l.length > 0)
+                .join("\n"),
+        },
+    ];
+    const { text: raw, provider: used } = await llmCompleteJson(messages, { cwd: params.cwd, provider });
+    const parsed = parseQuickTaskJson(extractJsonObject(raw));
+    const title = parsed.title.replace(/^TASK-\d+\s*[·:\-]\s*/i, "").trim() || parsed.title;
+    const markdown = ensureTaskSections(normalizeTaskMarkdownHeader(parsed.markdown, params.taskId, title));
+    return {
+        title,
+        slug: parsed.slug,
+        markdown,
+        provider: used,
+    };
+}
+export async function gatherTaskPlanViaLlm(params) {
+    const provider = await pickPlanLlmProvider(params.cwd, undefined, { interactiveLogin: true });
+    if (provider === null)
+        return null;
+    const context = await loadTaskAddProjectContext(params.cwd);
+    const messages = [
+        { role: "system", content: taskPlanSystemPrompt(params.taskId, params.projectName) },
+        {
+            role: "user",
+            content: [
+                `TASK id: ${params.taskId}`,
+                params.seedIdea ? `Initial idea: ${params.seedIdea}` : "Ask what the user wants to build.",
+                "",
+                "Project context:",
+                context,
+                "",
+                "Begin with your first question JSON.",
+            ].join("\n"),
+        },
+    ];
+    let lastQ = "";
+    for (let step = 0; step < MAX_PLAN_TURNS; step++) {
+        const { text: raw, provider: used } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            provider,
+        });
+        const parsed = parseTaskPlanTurn(extractJsonObject(raw));
+        if (parsed.turn === "done") {
+            const titleMatch = /^#\s+TASK-\d+:\s*(.+)$/m.exec(parsed.taskMarkdown);
+            const title = titleMatch?.[1]?.trim() ?? params.taskId;
+            const markdown = ensureTaskSections(normalizeTaskMarkdownHeader(parsed.taskMarkdown, params.taskId, title));
+            return {
+                markdown,
+                buildPromptMarkdown: parsed.buildPromptMarkdown,
+                provider: used,
+            };
+        }
+        log.blank();
+        log.info(dim(`Planning ${params.taskId} — question ${step + 1}`));
+        log.info(bold(parsed.message));
+        log.blank();
+        const answer = await collectTaskPlanAnswer(parsed);
+        lastQ = parsed.message;
+        messages.push({ role: "assistant", content: raw });
+        messages.push({
+            role: "user",
+            content: `Previous Q: ${lastQ}\nUser answer: ${answer}\n\nContinue with next JSON (question or done).`,
+        });
+    }
+    throw new Error(`Task planning stopped after ${MAX_PLAN_TURNS} turns — try a shorter scope or run again.`);
+}
+export function defaultBuildPromptForTask(projectName, taskId, taskRelativePath) {
+    return buildTaskBuildPrompt({ projectName, taskId, taskRelativePath });
+}

package/dist/lib/task-merge.js

@@ -0,0 +1,220 @@
+import { ghAuthStatus, runGh } from "./github-cli.js";
+import { gitBranchExists, gitCheckout, gitCommitsAhead, 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;
+    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)
+        args.push("-u");
+    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 };
+    }
+    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 };
+    }
+    const branchExists = await gitBranchExists(cwd, taskBranch);
+    if (!branchExists) {
+        log.error(`Local task branch not found: ${taskBranch}`);
+        return { ok: false, mode };
+    }
+    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 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}`);
+        }
+        return { ok: true, mode };
+    }
+    log.step(bold(`Merging ${cyan(taskBranch)} → ${cyan(baseBranch)} (${mode})`));
+    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 };
+            }
+            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)) {
+            try {
+                await gitDeleteBranch(cwd, taskBranch, { force: true });
+                log.ok(`deleted local branch ${taskBranch}`);
+            }
+            catch {
+                log.warn(`Could not delete local branch ${taskBranch}.`);
+            }
+        }
+        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",
+            taskBranch,
+            "-m",
+            mergeCommitMessage(taskId, taskTitle, taskBranch),
+        ]);
+        await gitPush(cwd, remote, baseBranch, false);
+        log.ok(`merged and pushed ${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 };
+    }
+    try {
+        await gitDeleteBranch(cwd, taskBranch, { force: false });
+        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}`));
+    }
+    return { ok: true, mode };
+}