@goodtek/vibeops 0.7.22 → 1.1.1

package/dist/commands/status.js

@@ -1,12 +1,185 @@
 import { resolve } from "node:path";
-import { collectStatus } from "../status/collector.js";
-import { printHuman, toJson } from "../status/format.js";
-import { log } from "../lib/logger.js";
-export async function statusCommand(options = {}) {
-    const cwd = resolve(options.cwd ?? process.cwd());
-    const report = await collectStatus(cwd);
-    if (options.json) {
-        log.raw(toJson(report));
+import { readConfig, getClientsFromConfig } from "../lib/config.js";
+import { formatGitPolicySummary } from "../lib/git-policy.js";
+import { readText } from "../lib/filesystem.js";
+import { readGitInfo } from "../lib/git.js";
+import { buildLlmStatusReport } from "../lib/llm-status.js";
+import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { VERSION } from "../version.js";
+import { computeNextHint, hintToText, listInProgressTasks, pickFocusTask, relPath, taskBranchExistsFor, } from "../lib/task-context.js";
+import { countTasks, hasNonEmptySection, isOnTaskBranch, loadActionableTasks, readGitContext, statusDisplay } from "../lib/task.js";
+import { summarizeGoal } from "../lib/task-summary.js";
+async function buildReport(cwd) {
+    const paths = projectPaths(cwd);
+    const config = await readConfig(cwd);
+    const git = await readGitInfo(cwd);
+    const isVibeopsProject = config !== null;
+    let counts = null;
+    let inProgress = [];
+    let focus = null;
+    if (isVibeopsProject) {
+        const tasks = await loadActionableTasks(paths.docsTasks);
+        counts = countTasks(tasks);
+        inProgress = await listInProgressTasks(paths);
+        focus = await pickFocusTask(paths, cwd);
+    }
+    let focusBlock = null;
+    let resultFilled = false;
+    let testFilled = false;
+    let onTaskBranch = null;
+    let taskBranch = null;
+    let branchExists = null;
+    let goalExcerpt = "";
+    let mergeRequestUrl = null;
+    if (focus !== null) {
+        const body = await readText(focus.filePath);
+        goalExcerpt = summarizeGoal(body);
+        resultFilled = hasNonEmptySection(body, "Result");
+        testFilled = hasNonEmptySection(body, "Test Result");
+        const ctx = await readGitContext(focus.filePath);
+        taskBranch = ctx?.taskBranch ?? null;
+        mergeRequestUrl = ctx?.mergeRequestUrl ?? null;
+        onTaskBranch = isOnTaskBranch(git.branch, ctx);
+        branchExists = await taskBranchExistsFor(cwd, focus);
+        focusBlock = {
+            id: focus.id,
+            title: focus.title,
+            status: statusDisplay(focus.status),
+            file: relPath(cwd, focus.filePath),
+            goalExcerpt,
+            resultFilled,
+            testResultFilled: testFilled,
+            onTaskBranch,
+            taskBranch,
+            taskBranchExists: branchExists,
+            mergeRequestUrl,
+        };
+    }
+    const hint = computeNextHint({
+        isVibeopsProject,
+        focus,
+        resultFilled,
+        testFilled,
+        onTaskBranch,
+    });
+    const llm = isVibeopsProject ? await buildLlmStatusReport(cwd) : null;
+    return {
+        vibeopsVersion: VERSION,
+        isVibeopsProject,
+        projectName: config?.name ?? null,
+        clients: getClientsFromConfig(config),
+        git: {
+            isRepo: git.isRepo,
+            branch: git.branch,
+            dirty: git.dirty,
+            policy: config?.git ? formatGitPolicySummary(config.git) : null,
+        },
+        counts,
+        inProgress: inProgress.map((t) => ({
+            id: t.id,
+            title: t.title,
+            file: relPath(cwd, t.filePath),
+        })),
+        focus: focusBlock,
+        nextHint: hintToText(hint, cwd, focus),
+        llm,
+    };
+}
+function printHuman(report) {
+    log.blank();
+    log.info(bold("─".repeat(56)));
+    log.info(bold("  VibeOps · status"));
+    log.info(bold("─".repeat(56)));
+    log.info(`  ${dim("CLI")}       v${report.vibeopsVersion}`);
+    if (!report.isVibeopsProject) {
+        log.info(`  ${dim("Project")}  ${yellow("not initialized")} — run vibeops init`);
+        log.info(bold("─".repeat(56)));
+        log.blank();
+        return;
+    }
+    log.info(`  ${dim("Project")}  ${report.projectName ?? "(unnamed)"}`);
+    if (report.clients.length > 0) {
+        log.info(`  ${dim("Clients")}  ${report.clients.join(", ")}`);
+    }
+    if (report.counts) {
+        const c = report.counts;
+        log.info(`  ${dim("Tasks")}    ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.done} done`);
+    }
+    if (report.inProgress.length > 1) {
+        log.blank();
+        log.info(bold("  In progress"));
+        for (const t of report.inProgress) {
+            log.info(`    ${cyan(t.id)} — ${t.title}`);
+        }
+    }
+    log.blank();
+    if (report.focus) {
+        const f = report.focus;
+        log.info(`  ${dim("Focus")}    ${cyan(f.id)} — ${f.title || dim("(no title)")}`);
+        log.info(`  ${dim("Status")}  ${f.status}`);
+        log.info(`  ${dim("File")}     ${f.file}`);
+        if (f.goalExcerpt)
+            log.info(`  ${dim("Goal")}     ${f.goalExcerpt}`);
+        log.info(`  ${dim("Result")}  ${f.resultFilled ? green("filled") : yellow("empty")} · Test Result ${f.testResultFilled ? green("filled") : yellow("empty")}`);
+    }
+    else {
+        log.info(`  ${dim("Focus")}    ${dim("(none)")}`);
+    }
+    log.blank();
+    log.info(bold("  Git"));
+    if (!report.git.isRepo) {
+        log.info(`    ${yellow("not a git repository")}`);
+    }
+    else {
+        log.info(`    ${dim("HEAD")}     ${report.git.branch ?? "(detached)"}`);
+        if (report.git.dirty === true)
+            log.info(`    ${dim("Tree")}    ${yellow("dirty")}`);
+        else if (report.git.dirty === false)
+            log.info(`    ${dim("Tree")}    ${green("clean")}`);
+        if (report.git.policy) {
+            log.info(`    ${dim("Policy")}   ${report.git.policy}`);
+        }
+        if (report.focus?.taskBranch) {
+            const on = report.focus.onTaskBranch === true
+                ? green("yes")
+                : report.focus.onTaskBranch === false
+                    ? yellow("no")
+                    : dim("—");
+            log.info(`    ${dim("Task br.")}  ${report.focus.taskBranch} · on branch: ${on}`);
+        }
+        if (report.focus?.mergeRequestUrl) {
+            log.info(`    ${dim("MR/PR")}    ${report.focus.mergeRequestUrl}`);
+        }
+    }
+    if (report.llm) {
+        log.blank();
+        log.info(bold("  LLM"));
+        log.info(`    ${dim("Preferred")}  ${report.llm.preference}`);
+        const active = report.llm.active !== null
+            ? green(`${report.llm.active} (ok)`)
+            : report.llm.anyAvailable
+                ? yellow("(preference not available)")
+                : yellow("none");
+        log.info(`    ${dim("Active")}     ${active}`);
+        for (const p of report.llm.providers) {
+            const summary = p.summary.length > 56 ? `${p.summary.slice(0, 53)}…` : p.summary;
+            log.info(`    ${dim(p.id.padEnd(14))} ${p.ok ? green("ok") : dim("—")}  ${dim(summary)}`);
+        }
+        if (!report.llm.anyAvailable) {
+            log.info(`    ${dim("Setup")}     ${cyan("vibeops llm connect")}`);
+        }
+    }
+    log.blank();
+    log.info(`${dim("Next")}     ${report.nextHint}`);
+    log.info(bold("─".repeat(56)));
+    log.blank();
+}
+export async function statusCommand(opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    const report = await buildReport(cwd);
+    if (opts.json) {
+        log.raw(JSON.stringify(report, null, 2));
     }
     else {
         printHuman(report);

package/dist/commands/task-add.js

@@ -1,55 +1,29 @@
-import { mkdir } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
-import { doneCommand } from "./done.js";
-import { startCommand } from "./start.js";
+import { resolve } from "node:path";
 import { pathExists, writeText } from "../lib/filesystem.js";
-import { bold, cyan, dim, log } from "../lib/logger.js";
-import { askInput, askSelect, yesNoSelect } from "../lib/inquirer-helpers.js";
+import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { askInput } from "../lib/inquirer-helpers.js";
+import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
-import { readConfig } from "../lib/config.js";
 import { slugify } from "../lib/slug.js";
-import { defaultBuildPromptForTask, gatherTaskPlanViaLlm, llmGenerateQuickTask, } from "../lib/task-add-llm.js";
-import { taskBuildPromptAbs, taskBuildPromptRel, } from "../lib/task-add-build-prompt.js";
-import { allocateNextTaskNumber, buildWorkNowTaskMarkdown, formatTaskId, titleFromIdea, uniqueTaskPath, } from "../lib/task-scaffold.js";
-import { readGitInfo } from "../lib/git.js";
-import { loadActionableTasks, pickInProgressTask, pickLatestDoneTask, } from "../lib/task.js";
-function relOrAbs(root, p) {
-    const r = relative(root, p);
-    return r === "" ? "." : r.startsWith("..") ? p : r;
-}
-async function maybeCloseInProgressTask(root, inProgress, nonInteractive) {
-    if (nonInteractive)
-        return true;
-    log.info(`Current TASK ${bold(inProgress.id)} is ${cyan("In Progress")}: ${dim(inProgress.title)}`);
-    log.blank();
-    const closeFirst = await yesNoSelect({
-        message: "Close this TASK first (commit, merge, clean tree) before starting a new one?",
-        defaultValue: true,
-    });
-    if (!closeFirst) {
-        log.warn(`Keeping ${inProgress.id} open — finish it or run ${cyan("vibeops done")} before switching branches.`);
-        return true;
+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 { loadActionableTasks, readGitContext } from "../lib/task.js";
+async function loadGitConfigOrNull(root, dryRun) {
+    try {
+        return await requireGitConfig(root);
     }
-    log.blank();
-    log.step(`Closing ${inProgress.id} via vibeops done…`);
-    await doneCommand(inProgress.id, { cwd: root, allowDirty: true });
-    if (process.exitCode !== undefined && process.exitCode !== 0) {
-        log.error("Could not close the current TASK — fix blockers above, then run task add again.");
-        return false;
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            if (dryRun)
+                return null;
+            log.error(e.message);
+            process.exitCode = 1;
+            return null;
+        }
+        throw e;
     }
-    log.blank();
-    return true;
-}
-async function pickAddMode(nonInteractive) {
-    if (nonInteractive)
-        return "just";
-    const choice = await askSelect({
-        message: "How do you want to create the new TASK?",
-        nonInteractive: false,
-        choices: ["Just create task", "Create plan using LLM"],
-        default: "Just create task",
-    });
-    return choice.startsWith("Create plan") ? "plan" : "just";
 }
 export async function taskAddCommand(opts = {}) {
     const root = resolve(opts.cwd ?? process.cwd());
@@ -57,144 +31,97 @@ export async function taskAddCommand(opts = {}) {
     const nonInteractive = opts.nonInteractive === true || dryRun || process.stdin.isTTY !== true;
     log.info(bold("vibeops task add"));
     log.blank();
-    let tasks = await loadActionableTasks(projectPaths(root).docsTasks);
-    const inProgress = pickInProgressTask(tasks);
-    if (inProgress !== null) {
-        const ok = await maybeCloseInProgressTask(root, inProgress, nonInteractive);
-        if (!ok)
-            return;
-        tasks = await loadActionableTasks(projectPaths(root).docsTasks);
+    const gitCfg = await loadGitConfigOrNull(root, dryRun);
+    if (!dryRun && gitCfg === null)
+        return;
+    const paths = projectPaths(root);
+    const blocking = await findBlockingTask(paths, root);
+    if (blocking !== null) {
+        const ctx = await readGitContext(blocking.filePath);
+        log.warn(`${yellow("Blocked")} — ${bold(blocking.id)} is still open (${blocking.title || "no title"}).`);
+        if (ctx) {
+            log.info(`  ${dim("branch")}  ${ctx.taskBranch}`);
+        }
+        log.info(`  ${dim("file")}   ${relPath(root, blocking.filePath)}`);
+        log.blank();
+        log.info(`Finish it first: ${cyan(`vibeops task done ${blocking.id}`)}`);
+        log.info(`Then run ${cyan("vibeops task add")} again.`);
+        process.exitCode = 1;
+        return;
     }
-    const mode = await pickAddMode(nonInteractive);
-    const latestDone = pickLatestDoneTask(tasks);
-    const nextNum = allocateNextTaskNumber(tasks);
-    const taskId = formatTaskId(nextNum);
-    const ideaDefault = opts.idea?.trim() ||
-        (latestDone ? `Follow-up after ${latestDone.id}` : "New work slice");
+    const ideaDefault = "New work slice";
     const idea = await askInput({
-        message: mode === "plan"
-            ? "What do you want to build? (starting point for planning)"
-            : "What are you doing now? (short)",
+        message: "What are you doing now? (short)",
         nonInteractive,
-        default: ideaDefault,
+        default: opts.idea?.trim() || ideaDefault,
         required: true,
     });
-    const paths = projectPaths(root);
-    const config = await readConfig(root);
-    const projectName = config?.name ?? "project";
-    let title = titleFromIdea(idea);
-    let slug = slugify(title);
-    let markdown = "";
-    let buildPromptMarkdown = null;
-    let llmNote = null;
-    if (mode === "plan") {
-        if (dryRun) {
-            log.info(`[dry-run] Would run LLM planning for ${bold(taskId)}`);
-            log.info(dim(`  idea: ${idea}`));
-            return;
-        }
-        if (nonInteractive) {
-            log.error("Create plan using LLM requires an interactive terminal (omit --non-interactive).");
-            process.exitCode = 1;
-            return;
-        }
-        log.step("LLM task planning (interactive questions)…");
-        const planned = await gatherTaskPlanViaLlm({
-            cwd: root,
-            taskId,
-            projectName,
-            seedIdea: idea,
-        });
-        if (planned === null) {
-            log.error("No LLM provider available for planning.");
-            process.exitCode = 1;
-            return;
-        }
-        markdown = planned.markdown;
-        buildPromptMarkdown = planned.buildPromptMarkdown;
-        llmNote = `planned via ${planned.provider}`;
-        const header = /^#\s+TASK-\d+:\s*(.+)$/m.exec(markdown);
-        if (header?.[1])
-            title = header[1].trim();
-        slug = slugify(title);
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const taskId = formatTaskId(allocateNextTaskNumber(tasks));
+    let title;
+    let slug;
+    let markdown;
+    if (dryRun || nonInteractive) {
+        const fb = fallbackTaskDraft(taskId, idea);
+        title = fb.title;
+        slug = fb.slug;
+        markdown = fb.markdown;
     }
     else {
-        let quick = null;
-        if (!nonInteractive || opts.idea) {
-            quick = await llmGenerateQuickTask({
-                cwd: root,
-                taskId,
-                idea,
-                latestDone,
-            });
-        }
-        if (quick !== null) {
-            title = quick.title;
-            slug = quick.slug;
-            markdown = quick.markdown;
-            llmNote = `quick scaffold via ${quick.provider}`;
+        const llm = await llmScaffoldTask({ cwd: root, taskId, idea });
+        if (llm !== null) {
+            title = llm.title;
+            slug = llm.slug;
+            markdown = llm.markdown;
+            log.skip(`Scaffold via ${llm.provider}`);
         }
         else {
-            const parent = inProgress ?? latestDone;
-            markdown = buildWorkNowTaskMarkdown({
-                id: taskId,
-                title,
-                idea,
-                mvpPhase: parent?.mvpPhase?.trim() || "Work-now slice",
-                spawnedFrom: parent?.id,
-            });
-            if (!nonInteractive) {
-                log.warn("LLM unavailable — using minimal TASK template.");
-            }
+            log.warn("LLM unavailable — using minimal TASK template.");
+            log.info(dim(`  Run ${cyan("vibeops llm connect")} to set up Codex, Cursor Agent CLI, or OpenAI.`));
+            const fb = fallbackTaskDraft(taskId, idea);
+            title = fb.title;
+            slug = fb.slug;
+            markdown = fb.markdown;
         }
     }
-    const { filePath } = uniqueTaskPath(paths.docsTasks, taskId, slug, tasks.map((t) => t.filePath));
-    const relFile = relOrAbs(root, filePath);
-    const taskRelative = relFile.replace(/\\/g, "/");
-    const buildRel = taskBuildPromptRel(taskId);
-    const buildAbs = taskBuildPromptAbs(root, taskId);
-    if (buildPromptMarkdown === null) {
-        buildPromptMarkdown = defaultBuildPromptForTask(projectName, taskId, taskRelative);
-    }
+    const { filePath } = uniqueTaskPath(paths.docsTasks, taskId, slugify(slug || title), tasks.map((t) => t.filePath));
+    const relFile = relPath(root, filePath);
+    const integration = gitCfg?.integrationBranch ?? "integration";
     if (dryRun) {
         log.info(`[dry-run] Would create ${bold(taskId)} → ${cyan(relFile)}`);
-        if (mode === "plan") {
-            log.info(`[dry-run] Would write ${cyan(buildRel)}`);
+        log.info(dim(`  branch task/${slugify(slug || title).replace(/^(\d+)-/, "$1-")} from ${integration}`));
+        if (gitCfg) {
+            await startTaskBranch({
+                cwd: root,
+                taskFile: filePath,
+                integrationBranch: gitCfg.integrationBranch,
+                remote: gitCfg.remote,
+                dryRun: true,
+            });
         }
-        log.blank();
         return;
     }
     if (await pathExists(filePath)) {
         throw new Error(`TASK file already exists: ${relFile}`);
     }
     await writeText(filePath, markdown);
-    await mkdir(join(root, ".vibeops", "generated"), { recursive: true });
-    await writeText(buildAbs, buildPromptMarkdown);
     log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
-    if (mode === "plan") {
-        log.ok(`Cursor build doc → ${cyan(buildRel)}`);
-    }
-    if (llmNote)
-        log.skip(llmNote);
-    const git = await readGitInfo(root);
-    if (!git.isRepo) {
-        log.warn("Not a git repository — TASK file saved. Run vibeops init --git, then start.");
-        return;
-    }
     log.blank();
-    log.step(`Starting ${taskId} (branch + In Progress)…`);
-    await startCommand(taskId, { cwd: root, allowDirty: true });
-    if (process.exitCode !== undefined && process.exitCode !== 0) {
-        log.warn(`TASK file exists but start failed — run ${cyan(`vibeops start ${taskId}`)} when Git is ready.`);
+    log.step("Starting task branch…");
+    const started = await startTaskBranch({
+        cwd: root,
+        taskFile: filePath,
+        integrationBranch: gitCfg.integrationBranch,
+        remote: gitCfg.remote,
+        allowDirty: true,
+    });
+    if (!started) {
+        process.exitCode = 1;
         return;
     }
     log.blank();
-    if (mode === "plan") {
-        log.info(bold("Build in Cursor"));
-        log.info(`  Drag ${cyan(buildRel)} into a new chat and implement.`);
-    }
-    else {
-        log.info(bold("Work in Cursor"));
-        log.info(`  Edit ${cyan(relFile)} freely, then ${cyan(`vibeops done ${taskId}`)} when finished.`);
-    }
+    log.info(bold("Next in Cursor"));
+    log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
+    log.info(`  Agent: same file — implement`);
+    log.info(`  Done: ${cyan(`vibeops task done ${taskId}`)}`);
 }