@goodtek/vibeops 0.7.22 → 1.1.1

package/dist/lib/workflow-guide.js

@@ -1,485 +0,0 @@
-import { basename, join } from "node:path";
-import { pathExists } from "./filesystem.js";
-import { readText } from "./filesystem.js";
-import { gitBranchExists, gitGovernanceOnlyDirty, readGitInfo } from "./git.js";
-import { findMvpTaskFile } from "./mvp-artifacts.js";
-import { MVP_BUILD_PROMPT_REL, NEXT_TASK_SUGGESTION_REL, } from "./mvp-constants.js";
-import { LAST_DONE_SUMMARY_REL } from "./mvp-done-summary.js";
-import { cursorImplementPromptRel } from "./cursor-task-prompt.js";
-import { branchNameForTaskFile, hasNonEmptySection, isMvpTaskId, isOnTaskBranch, loadActionableTasks, pickActiveTask, pickLatestDoneTask, readGitContext, readTaskFile, } from "./task.js";
-export async function resolveMvpTask(paths) {
-    const file = await findMvpTaskFile(paths.docsTasks);
-    if (file === null)
-        return null;
-    return readTaskFile(file);
-}
-export async function resolveGuideTask(paths, cwd) {
-    const mvpFile = await findMvpTaskFile(paths.docsTasks);
-    if (mvpFile !== null) {
-        return {
-            mode: "mvp",
-            task: await readTaskFile(mvpFile),
-            referenceTask: null,
-        };
-    }
-    const actionable = await loadActionableTasks(paths.docsTasks);
-    const next = await pickActiveTask(paths.docsTasks, cwd);
-    if (next !== null) {
-        return { mode: "backlog", task: next, referenceTask: null };
-    }
-    const referenceTask = pickLatestDoneTask(actionable);
-    if (actionable.length > 0 && actionable.every((t) => t.status === "done")) {
-        return { mode: "post-mvp", task: null, referenceTask };
-    }
-    if (referenceTask !== null || (await hasPostMvpArtifacts(cwd))) {
-        return { mode: "post-mvp", task: null, referenceTask };
-    }
-    return { mode: "greenfield", task: null, referenceTask: null };
-}
-async function hasPostMvpArtifacts(cwd) {
-    return ((await pathExists(join(cwd, LAST_DONE_SUMMARY_REL))) ||
-        (await pathExists(join(cwd, NEXT_TASK_SUGGESTION_REL))));
-}
-export async function inferGuideStep(inputs) {
-    const { cwd, paths, config } = inputs;
-    const git = await readGitInfo(cwd);
-    const resolved = await resolveGuideTask(paths, cwd);
-    if (resolved.mode === "greenfield") {
-        return {
-            cwd,
-            paths,
-            config,
-            mode: "greenfield",
-            task: null,
-            referenceTask: null,
-            gitBranch: git.branch,
-            gitDirty: git.dirty,
-            step: buildStep("no-mvp", {
-                mode: "greenfield",
-                task: null,
-                referenceTask: null,
-                body: "",
-                gitCtx: null,
-                git,
-                hasSuggestion: false,
-            }),
-        };
-    }
-    if (resolved.mode === "post-mvp") {
-        const hasSuggestion = await pathExists(join(cwd, NEXT_TASK_SUGGESTION_REL));
-        return {
-            cwd,
-            paths,
-            config,
-            mode: "post-mvp",
-            task: null,
-            referenceTask: resolved.referenceTask,
-            gitBranch: git.branch,
-            gitDirty: git.dirty,
-            step: inputs.forceStepId !== undefined
-                ? buildStep(inputs.forceStepId, {
-                    mode: "post-mvp",
-                    task: null,
-                    referenceTask: resolved.referenceTask,
-                    body: "",
-                    gitCtx: null,
-                    git,
-                    hasSuggestion,
-                })
-                : buildStep("continue-iteration", {
-                    mode: "post-mvp",
-                    task: null,
-                    referenceTask: resolved.referenceTask,
-                    body: "",
-                    gitCtx: null,
-                    git,
-                    hasSuggestion,
-                }),
-        };
-    }
-    const task = resolved.task;
-    const body = await readText(task.filePath);
-    const gitCtx = await readGitContext(task.filePath);
-    const taskBranch = branchNameForTaskFile(task.filePath);
-    const branchExists = await gitBranchExists(cwd, taskBranch);
-    const hasSuggestion = await pathExists(join(cwd, NEXT_TASK_SUGGESTION_REL));
-    const step = inputs.forceStepId !== undefined
-        ? buildStep(inputs.forceStepId, {
-            mode: resolved.mode,
-            task,
-            referenceTask: null,
-            body,
-            gitCtx,
-            git,
-            hasSuggestion,
-            taskBranch,
-            branchExists,
-        })
-        : await inferStep({
-            cwd,
-            mode: resolved.mode,
-            task,
-            body,
-            gitCtx,
-            git,
-            hasSuggestion,
-            taskBranch,
-            branchExists,
-        });
-    return {
-        cwd,
-        paths,
-        config,
-        mode: resolved.mode,
-        task,
-        referenceTask: null,
-        gitBranch: git.branch,
-        gitDirty: git.dirty,
-        step,
-    };
-}
-/** Next guide step when the current one is manual (user chose Next). */
-export function successorStepId(current, ctx) {
-    const resultOk = hasNonEmptySection(ctx.body, "Result");
-    const testOk = hasNonEmptySection(ctx.body, "Test Result");
-    switch (current) {
-        case "implement":
-            if (resultOk && testOk)
-                return "finish";
-            if (ctx.gitDirty === true)
-                return "commit";
-            return null;
-        case "commit":
-            return "finish";
-        default:
-            return null;
-    }
-}
-async function inferStep(ctx) {
-    const { mode, task, body, gitCtx, git, hasSuggestion, taskBranch, branchExists } = ctx;
-    const resultOk = hasNonEmptySection(body, "Result");
-    const testOk = hasNonEmptySection(body, "Test Result");
-    const onTaskBranch = git.branch === taskBranch;
-    if (branchExists && !onTaskBranch) {
-        return buildStep("checkout-task", {
-            mode,
-            task,
-            referenceTask: null,
-            body,
-            gitCtx,
-            git,
-            hasSuggestion,
-            taskBranch,
-            branchExists,
-        });
-    }
-    if (task.status === "done") {
-        if (mode === "mvp") {
-            return buildStep("all-done", { mode, task, referenceTask: null, body, gitCtx, git, hasSuggestion });
-        }
-        if (isOnTaskBranch(git.branch, gitCtx)) {
-            return buildStep("finish", { mode, task, referenceTask: null, body, gitCtx, git, hasSuggestion });
-        }
-        return buildStep("continue-iteration", {
-            mode: "post-mvp",
-            task,
-            referenceTask: task,
-            body,
-            gitCtx,
-            git,
-            hasSuggestion,
-        });
-    }
-    if ((!gitCtx || task.status === "planned") && !branchExists) {
-        if (git.dirty === true) {
-            const gov = await gitGovernanceOnlyDirty(ctx.cwd);
-            if (!gov.onlyGovernance) {
-                return buildStep("prepare-start", {
-                    mode,
-                    task,
-                    referenceTask: null,
-                    body,
-                    gitCtx,
-                    git,
-                    hasSuggestion,
-                    taskBranch,
-                    branchExists,
-                });
-            }
-        }
-        return buildStep("start", {
-            mode,
-            task,
-            referenceTask: null,
-            body,
-            gitCtx,
-            git,
-            hasSuggestion,
-            taskBranch,
-            branchExists,
-        });
-    }
-    if (!resultOk || !testOk) {
-        return buildStep("implement", { mode, task, referenceTask: null, body, gitCtx, git, hasSuggestion });
-    }
-    if (git.dirty === true) {
-        const gov = await gitGovernanceOnlyDirty(ctx.cwd);
-        if (!gov.onlyGovernance) {
-            return buildStep("commit", {
-                mode,
-                task,
-                referenceTask: null,
-                body,
-                gitCtx,
-                git,
-                hasSuggestion,
-                taskBranch,
-                branchExists,
-            });
-        }
-    }
-    return buildStep("finish", { mode, task, referenceTask: null, body, gitCtx, git, hasSuggestion });
-}
-function buildStep(stepId, ctx) {
-    const { task, referenceTask, gitCtx, git, hasSuggestion } = ctx;
-    const id = task?.id ?? referenceTask?.id ?? null;
-    const isMvp = id !== null && isMvpTaskId(id);
-    switch (stepId) {
-        case "no-mvp":
-            return {
-                id: "no-mvp",
-                taskId: null,
-                title: "No TASK yet",
-                youDo: ["Run planning to create TASK-mvp and the build prompt."],
-                vibeopsCommand: "vibeops plan",
-                shellHints: ['vibeops plan --idea "Your product idea"'],
-                runnable: false,
-            };
-        case "continue-iteration": {
-            const ref = referenceTask ?? task;
-            const lines = [];
-            if (ref) {
-                lines.push(`Last finished: ${ref.id}${ref.title ? ` — ${ref.title}` : ""}.`);
-            }
-            else {
-                lines.push("MVP / backlog work is complete on this project.");
-            }
-            lines.push(`Read ${LAST_DONE_SUMMARY_REL} for what shipped (if present).`);
-            if (hasSuggestion) {
-                lines.push(`Review ${NEXT_TASK_SUGGESTION_REL} from the last vibeops done.`);
-            }
-            lines.push("Plan the next slice — prior summary is injected into TASK-mvp + mvp-build.md.");
-            const shellHints = ['vibeops plan --idea "Next feature or slice"'];
-            if (hasSuggestion) {
-                shellHints.push(`cat ${NEXT_TASK_SUGGESTION_REL}`);
-            }
-            return {
-                id: "continue-iteration",
-                taskId: ref?.id ?? null,
-                title: "Continue after MVP",
-                youDo: lines,
-                vibeopsCommand: "vibeops plan",
-                shellHints,
-                runnable: false,
-            };
-        }
-        case "prepare-start":
-            return {
-                id: "prepare-start",
-                taskId: id,
-                title: `Prepare git before ${id}`,
-                youDo: [
-                    git.branch
-                        ? `On ${git.branch} with uncommitted project files (not just .vibeops/).`
-                        : "Uncommitted project files on the working tree.",
-                    "Commit or stash them before `vibeops start` creates a task branch.",
-                    "If this is TASK-009 (Next.js scaffold), finish with `vibeops done TASK-009` or commit that work first.",
-                    `Optional: vibeops start ${id} --allow-dirty (carries current changes into the new task branch).`,
-                ].filter((l) => l.length > 0),
-                vibeopsCommand: null,
-                shellHints: [
-                    "git status",
-                    'git stash push -u -m "wip before task branch"',
-                    `vibeops start ${id} --allow-dirty`,
-                ],
-                runnable: false,
-            };
-        case "start":
-            return {
-                id: "start",
-                taskId: id,
-                title: isMvp ? "Start MVP branch" : `Start ${id}`,
-                youDo: isMvp
-                    ? ["Creates task/mvp-* branch and Git Context."]
-                    : [`Creates task branch and Git Context for ${id}.`],
-                vibeopsCommand: isMvp ? "vibeops start" : `vibeops start ${id}`,
-                shellHints: [],
-                runnable: true,
-            };
-        case "checkout-task": {
-            const branch = ctx.taskBranch ?? gitCtx?.taskBranch ?? "task/…";
-            return {
-                id: "checkout-task",
-                taskId: id,
-                title: `Resume ${id} branch`,
-                youDo: [
-                    git.branch ? `Current branch: ${git.branch}` : "",
-                    `Switch: git switch ${branch} (or: vibeops start ${id})`,
-                    "Does not recreate the branch if it already exists.",
-                ].filter((l) => l.length > 0),
-                vibeopsCommand: isMvp ? "vibeops start" : `vibeops start ${id}`,
-                shellHints: [`git switch ${branch}`],
-                runnable: true,
-            };
-        }
-        case "implement": {
-            const branchNote = gitCtx && git.branch && git.branch !== gitCtx.taskBranch
-                ? `On ${git.branch} — switch: git switch ${gitCtx.taskBranch}`
-                : gitCtx
-                    ? `Branch: ${gitCtx.taskBranch}`
-                    : "";
-            const taskFile = task ? basename(task.filePath) : "TASK file";
-            const fillResult = !hasNonEmptySection(ctx.body, "Result");
-            const fillTestResult = !hasNonEmptySection(ctx.body, "Test Result");
-            const needsCursorPrompt = fillResult || fillTestResult;
-            const promptRel = task && needsCursorPrompt ? cursorImplementPromptRel(task.id) : null;
-            const implementLines = isMvp
-                ? [
-                    branchNote,
-                    `Drag ${MVP_BUILD_PROMPT_REL} into a new chat.`,
-                    ...(needsCursorPrompt && promptRel
-                        ? [
-                            `Result / Test Result empty — in Cursor: @${promptRel} (see ${promptRel}).`,
-                        ]
-                        : ["Meet Acceptance Criteria; fill Result and Test Result."]),
-                ]
-                : [
-                    branchNote,
-                    `Open docs/tasks/${taskFile} in Cursor.`,
-                    ...(needsCursorPrompt && promptRel
-                        ? [
-                            `Result / Test Result empty — in Cursor: @${promptRel} or paste the prompt from that file.`,
-                        ]
-                        : ["Meet Acceptance Criteria; fill Result and Test Result."]),
-                ];
-            return {
-                id: "implement",
-                taskId: id,
-                title: isMvp ? "Build MVP in Cursor" : `Implement ${id}`,
-                youDo: implementLines.filter((l) => l.length > 0),
-                vibeopsCommand: null,
-                shellHints: promptRel ? [`cat ${promptRel}`] : [],
-                runnable: false,
-            };
-        }
-        case "commit": {
-            const doneCmd = isMvp ? "vibeops done" : `vibeops done ${id}`;
-            return {
-                id: "commit",
-                taskId: id,
-                title: "Commit work on task branch",
-                youDo: [
-                    "Commit task files (docs/, src/) — not node_modules or .next.",
-                    `Or run ${doneCmd} to commit safe paths and merge.`,
-                ],
-                vibeopsCommand: null,
-                shellHints: [
-                    "git status",
-                    "git add docs/ src/ …",
-                    `git commit -m "feat(${id?.toLowerCase() ?? "task"}): <summary>"`,
-                    doneCmd,
-                ],
-                runnable: false,
-            };
-        }
-        case "finish": {
-            const markedDone = task?.status === "done";
-            return {
-                id: "finish",
-                taskId: id,
-                title: isMvp
-                    ? "Finish MVP (merge)"
-                    : markedDone
-                        ? `Close out ${id} (merge & sync)`
-                        : `Finish ${id}`,
-                youDo: markedDone
-                    ? [
-                        "TASK file already says Done — still on the task branch.",
-                        "Run done to commit if needed, merge to base branch, delete task branch.",
-                        "Runs Notion sync when enabled.",
-                    ]
-                    : [
-                        "Requires Result and Test Result.",
-                        isMvp
-                            ? "Marks Done, commits if needed, merges to main, deletes task branch."
-                            : "Marks Done, commits if needed, merges to main when on the task branch.",
-                        "Runs Notion sync when enabled; offers post-MVP cleanup if the tree is still dirty.",
-                    ],
-                vibeopsCommand: isMvp ? "vibeops done" : `vibeops done ${id}`,
-                shellHints: [],
-                runnable: true,
-            };
-        }
-        case "notion-sync":
-            return {
-                id: "notion-sync",
-                taskId: id,
-                title: "Sync Notion metadata",
-                youDo: ["Optional — pushes project + TASK metadata to Notion."],
-                vibeopsCommand: "vibeops notion sync",
-                shellHints: ["vibeops notion sync --dry-run"],
-                runnable: true,
-            };
-        case "all-done":
-            return {
-                id: "all-done",
-                taskId: id,
-                title: "MVP complete",
-                youDo: [
-                    `Read ${LAST_DONE_SUMMARY_REL} for what shipped.`,
-                    "Update docs/project/05-current-state.md if the project stage changed.",
-                    "Next iteration: vibeops plan (prior summary is injected into TASK + mvp-build.md).",
-                ],
-                vibeopsCommand: "vibeops plan",
-                shellHints: hasSuggestion ? [`cat ${NEXT_TASK_SUGGESTION_REL}`] : [],
-                runnable: false,
-            };
-    }
-}
-/** Higher = later in the TASK workflow (used to keep manual Next advances). */
-export function guideStepRank(stepId) {
-    switch (stepId) {
-        case "no-mvp":
-        case "continue-iteration":
-            return 0;
-        case "prepare-start":
-            return 5;
-        case "start":
-        case "checkout-task":
-            return 10;
-        case "implement":
-            return 20;
-        case "commit":
-            return 30;
-        case "finish":
-        case "notion-sync":
-            return 40;
-        case "all-done":
-            return 50;
-        default:
-            return 0;
-    }
-}
-export function followUpStepId(completed) {
-    switch (completed) {
-        case "start":
-        case "checkout-task":
-            return "implement";
-        case "commit":
-            return "implement";
-        case "finish":
-            return "all-done";
-        default:
-            return null;
-    }
-}

package/dist/status/collector.js

@@ -1,103 +0,0 @@
-import { basename } from "node:path";
-import { isDirectory, isFile, pathExists } from "../lib/filesystem.js";
-import { readConfig } from "../lib/config.js";
-import { readGitInfo } from "../lib/git.js";
-import { getNotionTokenSource } from "../lib/notion-env.js";
-import { readPackageJson, } from "../lib/package-json.js";
-import { countTasks, pickActiveTask, scanTasks } from "../lib/task.js";
-import { projectPaths } from "../lib/paths.js";
-import { DEFAULT_GITHUB_CONFIG, } from "../types/config.js";
-async function presenceCheck(label, path, required, asDir) {
-    const present = asDir ? await isDirectory(path) : await isFile(path);
-    return { label, path, present, required };
-}
-function snapshotNotion(notion, token) {
-    const projects = (notion?.projectsTargetId ?? "").length > 0 ||
-        (notion?.projectsDatabaseId ?? "").length > 0;
-    const tasks = (notion?.tasksTargetId ?? "").length > 0 ||
-        (notion?.tasksDatabaseId ?? "").length > 0;
-    return {
-        enabled: notion?.enabled ?? false,
-        hasToken: token.hasToken,
-        tokenSource: token.source,
-        hasProjectsTarget: projects,
-        hasTasksTarget: tasks,
-    };
-}
-function snapshotGithub(github) {
-    const g = github ?? DEFAULT_GITHUB_CONFIG;
-    return {
-        enabled: g.enabled,
-        mode: g.enabled ? g.mode : "",
-        owner: g.owner,
-        repo: g.repo,
-        remote: g.remote,
-        url: g.url,
-    };
-}
-function pickBinName(pkg) {
-    const bin = pkg.bin;
-    if (typeof bin === "string") {
-        return basename(bin).replace(/\.[A-Za-z0-9]+$/, "");
-    }
-    if (bin !== null && typeof bin === "object") {
-        const keys = Object.keys(bin);
-        if (keys.length > 0)
-            return keys[0];
-    }
-    return "";
-}
-function snapshotPackage(pkg) {
-    if (pkg === null) {
-        return { exists: false, name: "", version: "", bin: "" };
-    }
-    const data = pkg.data;
-    const name = typeof data.name === "string" ? data.name : "";
-    const version = typeof data.version === "string"
-        ? (data.version ?? "")
-        : "";
-    return { exists: true, name, version, bin: pickBinName(data) };
-}
-export async function collectStatus(cwd) {
-    const paths = projectPaths(cwd);
-    const config = await readConfig(paths.root);
-    const checks = [
-        await presenceCheck(".vibeops.json", paths.config, true, false),
-        await presenceCheck("AGENTS.md", paths.agentsMd, true, false),
-        await presenceCheck(".cursor/rules/", paths.cursorRules, true, true),
-        await presenceCheck("docs/project/", paths.docsProject, true, true),
-        await presenceCheck("docs/tasks/", paths.docsTasks, true, true),
-        await presenceCheck("docs/logs/", paths.docsLogs, false, true),
-        await presenceCheck(".vibeops/agents/", paths.vibeopsAgents, true, true),
-        await presenceCheck(".vibeops/prompts/", paths.vibeopsPrompts, false, true),
-        await presenceCheck(".vibeops/workflows/", paths.vibeopsWorkflows, false, true),
-        await presenceCheck(".vibeops.env.example", paths.envExample, false, false),
-    ];
-    const missingRequired = checks.filter((c) => c.required && !c.present);
-    const tasks = (await pathExists(paths.docsTasks))
-        ? await scanTasks(paths.docsTasks)
-        : [];
-    const taskCounts = countTasks(tasks);
-    const nextTask = await pickActiveTask(paths.docsTasks, paths.root);
-    const git = await readGitInfo(paths.root);
-    const tokenProbe = await getNotionTokenSource(paths.root);
-    const notion = snapshotNotion(config?.notion, tokenProbe);
-    const github = snapshotGithub(config?.github);
-    const pkg = await readPackageJson(paths.root);
-    const packageSnapshot = snapshotPackage(pkg);
-    const isVibeopsProject = config !== null && missingRequired.length === 0;
-    return {
-        cwd: paths.root,
-        isVibeopsProject,
-        config,
-        checks,
-        missingRequired,
-        tasks,
-        taskCounts,
-        nextTask,
-        git,
-        notion,
-        github,
-        package: packageSnapshot,
-    };
-}