@goodtek/vibeops 0.3.0 → 0.7.22

package/dist/lib/task-scaffold.js

@@ -1,107 +1,78 @@
 import { basename, join } from "node:path";
-import { pathExists, writeText } from "./filesystem.js";
-import { formatTaskId, highestTaskNumber } from "./task.js";
-import { slugify } from "./task-generator.js";
-export async function planScaffoldEntries(inputs) {
-    const startNumber = (await highestTaskNumber(inputs.tasksDir)) + 1;
-    const baseSlug = slugify(inputs.slug ?? "planned-task", "planned-task");
-    const baseTitle = inputs.title ?? "(scaffolded TASK — fill in)";
-    const phase = inputs.phase ?? "(unassigned)";
-    const entries = [];
-    let cursor = startNumber;
-    for (let i = 0; i < inputs.count; i++) {
-        // skip numbers whose file already exists on disk so users running scaffold
-        // twice in a row don't collide with previously generated skeletons.
-        let candidatePath = "";
-        let chosen = -1;
-        while (chosen < 0) {
-            const fileName = `${formatTaskId(cursor)}-${baseSlug}.md`;
-            const abs = join(inputs.tasksDir, fileName);
-            if (!(await pathExists(abs))) {
-                chosen = cursor;
-                candidatePath = abs;
-            }
-            cursor++;
-        }
-        entries.push({
-            id: formatTaskId(chosen),
-            number: chosen,
-            slug: baseSlug,
-            title: baseTitle,
-            fileName: basename(candidatePath),
-            absPath: candidatePath,
-            phase,
-        });
+import { statusDisplay } from "./task.js";
+export function allocateNextTaskNumber(tasks) {
+    let max = 0;
+    for (const t of tasks) {
+        const m = /^TASK-(\d+)$/i.exec(t.id.trim());
+        if (m)
+            max = Math.max(max, Number.parseInt(m[1], 10));
     }
-    return { entries, startNumber };
+    return max + 1;
 }
-export function renderScaffoldMarkdown(entry) {
-    return `# ${entry.id} · ${entry.title}
-
-> This file is a skeleton produced by \`vibeops task generate --scaffold\`. \`vibeops task done\` will refuse to advance the task until every section is filled in.
+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.`
+        : "";
+    return `# ${draft.id}: ${draft.title}
 
 ## Status
 
-planned
+${statusDisplay("planned")}
 
 ## MVP Phase
 
-${entry.phase}
+${draft.mvpPhase}
 
 ## Goal
 
-(scaffold — describe in 2-4 sentences what becomes possible when this TASK ships.)
+${draft.idea.trim()}
 
 ## Background
 
-(scaffold — why now, which earlier TASKs or decisions this builds on.)
+${draft.idea.trim()}${spawnedNote}
 
 ## Scope
 
-- (scaffold — item 1)
-- (scaffold — item 2)
+- Deliver the goal above in a single focused pass.
 
 ## Out of Scope
 
-- (scaffold — items intentionally excluded)
+- Unrelated backlog items and broad refactors not required for this slice.
 
 ## Acceptance Criteria
 
-1. (scaffold — verifiable statement 1)
-2. (scaffold — verifiable statement 2)
+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
 
-- (scaffold)
+- (add paths before implementation)
 
 ## Expected Files to Change
 
-- new: (scaffold)
-- update: (scaffold)
+- (list as you implement)
 
 ## Risks
 
-- (scaffold)
+- Scope creep from the parent TASK — keep this slice narrow.
 
 ## Test Plan
 
-- (scaffold)
+- \`vibeops task check ${draft.id}\`
+- Project-specific checks for the change
 
 ## Rollback Plan
 
-- (scaffold — branch deletion or another recovery flow)
-
-## Git Context
-
-(populated by \`vibeops task start ${entry.id}\`)
-
-## Notion Page
-
-(populated by \`vibeops notion sync\`)
+- \`vibeops rollback ${draft.id}\` (advisory) or revert the task branch commits.
 
 ## Implementation Plan
 
-1. (scaffold)
+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}\`.
 
 ## Result
 
@@ -109,20 +80,31 @@ ${entry.phase}
 
 ## Test Result
 
-(not yet)
-
-## Review Notes
-
 (not yet)
 `;
 }
-export async function writeScaffoldFiles(plan) {
-    const written = [];
-    for (const entry of plan.entries) {
-        if (await pathExists(entry.absPath))
-            continue;
-        await writeText(entry.absPath, renderScaffoldMarkdown(entry));
-        written.push(entry.absPath);
+export function taskFilename(taskId, slug) {
+    return `${taskId}-${slug}.md`;
+}
+export function uniqueTaskPath(tasksDir, taskId, baseSlug, existingPaths) {
+    const names = new Set(existingPaths.map((p) => basename(p)));
+    let slug = baseSlug;
+    let name = taskFilename(taskId, slug);
+    let n = 2;
+    while (names.has(name)) {
+        slug = `${baseSlug}-${n}`;
+        name = taskFilename(taskId, slug);
+        n++;
     }
-    return written;
+    return { slug, filePath: join(tasksDir, name) };
+}
+export function titleFromIdea(idea, explicitTitle) {
+    const t = explicitTitle?.trim();
+    if (t && t.length > 0)
+        return t;
+    const oneLine = idea.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= 80)
+        return oneLine;
+    const cut = oneLine.slice(0, 77).trimEnd();
+    return `${cut}...`;
 }

package/dist/lib/task-status-brief.js

@@ -0,0 +1,132 @@
+import { join, relative } from "node:path";
+import { readConfig } from "./config.js";
+import { pathExists, readText } from "./filesystem.js";
+import { gitBranchExists, readGitInfo } from "./git.js";
+import { MVP_BUILD_PROMPT_REL } from "./mvp-constants.js";
+import { taskBuildPromptRel } from "./task-add-build-prompt.js";
+import { projectPaths } from "./paths.js";
+import { cursorImplementPromptRel } from "./cursor-task-prompt.js";
+import { summarizeGoal } from "./task-summary.js";
+import { branchNameForTaskFile, countTasks, findAcceptanceCriteria, hasNonEmptySection, isMvpTaskId, isOnTaskBranch, loadActionableTasks, readGitContext, statusDisplay, } from "./task.js";
+import { inferGuideStep, } from "./workflow-guide.js";
+function relTaskPath(cwd, filePath) {
+    const r = relative(cwd, filePath).replace(/\\/g, "/");
+    return r.startsWith("..") ? filePath : r;
+}
+function toBriefTask(cwd, meta) {
+    return {
+        id: meta.id,
+        title: meta.title,
+        status: statusDisplay(meta.status),
+        mvpPhase: meta.mvpPhase,
+        file: relTaskPath(cwd, meta.filePath),
+    };
+}
+async function collectArtifacts(cwd, task) {
+    const out = [];
+    if (task === null)
+        return out;
+    if (isMvpTaskId(task.id) && (await pathExists(join(cwd, MVP_BUILD_PROMPT_REL)))) {
+        out.push(MVP_BUILD_PROMPT_REL);
+    }
+    const buildRel = taskBuildPromptRel(task.id);
+    if (await pathExists(join(cwd, buildRel)))
+        out.push(buildRel);
+    const implRel = cursorImplementPromptRel(task.id);
+    if (await pathExists(join(cwd, implRel)))
+        out.push(implRel);
+    return out;
+}
+export async function collectTaskStatusBrief(cwd) {
+    const paths = projectPaths(cwd);
+    const config = await readConfig(cwd);
+    const isVibeopsProject = config !== null;
+    const emptyWorkflow = {
+        stepId: "no-mvp",
+        stepTitle: "No TASK yet",
+        suggestedCommand: "vibeops plan",
+        youDo: ["Run planning to create TASK-mvp and the build prompt."],
+    };
+    if (!isVibeopsProject) {
+        const git = await readGitInfo(cwd);
+        return {
+            isVibeopsProject: false,
+            projectName: null,
+            mode: "greenfield",
+            activeTask: null,
+            referenceTask: null,
+            inProgressTasks: [],
+            counts: null,
+            workflow: emptyWorkflow,
+            git: {
+                isRepo: git.isRepo,
+                branch: git.branch,
+                dirty: git.dirty,
+                onTaskBranch: null,
+                expectedTaskBranch: null,
+                taskBranchExists: null,
+                baseBranch: null,
+                startedAt: null,
+            },
+            sections: null,
+            artifacts: [],
+        };
+    }
+    const guideCtx = await inferGuideStep({ cwd, paths, config });
+    const actionable = await loadActionableTasks(paths.docsTasks);
+    const counts = countTasks(actionable);
+    const inProgress = actionable
+        .filter((t) => t.status === "in_progress")
+        .map((t) => toBriefTask(cwd, t));
+    const active = guideCtx.task;
+    const reference = guideCtx.referenceTask !== null ? toBriefTask(cwd, guideCtx.referenceTask) : null;
+    let sections = null;
+    let expectedBranch = null;
+    let branchExists = null;
+    let gitCtx = null;
+    if (active !== null) {
+        const body = await readText(active.filePath);
+        gitCtx = await readGitContext(active.filePath);
+        expectedBranch = branchNameForTaskFile(active.filePath);
+        branchExists = await gitBranchExists(cwd, expectedBranch);
+        sections = {
+            goalExcerpt: summarizeGoal(body, 280),
+            resultFilled: hasNonEmptySection(body, "Result"),
+            testResultFilled: hasNonEmptySection(body, "Test Result"),
+            acceptanceCriteriaCount: findAcceptanceCriteria(body).length,
+        };
+    }
+    const git = await readGitInfo(cwd);
+    const onTaskBranch = active !== null && gitCtx !== null ? isOnTaskBranch(git.branch, gitCtx) : null;
+    const artifacts = await collectArtifacts(cwd, active);
+    return {
+        isVibeopsProject: true,
+        projectName: config.name ?? null,
+        mode: guideCtx.mode,
+        activeTask: active !== null ? toBriefTask(cwd, active) : null,
+        referenceTask: reference,
+        inProgressTasks: inProgress,
+        counts,
+        workflow: {
+            stepId: guideCtx.step.id,
+            stepTitle: guideCtx.step.title,
+            suggestedCommand: guideCtx.step.vibeopsCommand,
+            youDo: guideCtx.step.youDo,
+        },
+        git: {
+            isRepo: git.isRepo,
+            branch: git.branch,
+            dirty: git.dirty,
+            onTaskBranch,
+            expectedTaskBranch: expectedBranch ?? gitCtx?.taskBranch ?? null,
+            taskBranchExists: branchExists,
+            baseBranch: gitCtx?.baseBranch ?? null,
+            startedAt: gitCtx?.startedAt ?? null,
+        },
+        sections,
+        artifacts,
+    };
+}
+export function taskStatusBriefToJson(brief) {
+    return JSON.stringify(brief, null, 2);
+}

package/dist/lib/task.js

@@ -2,6 +2,7 @@ import { readdir } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import matter from "gray-matter";
 import { isDirectory, readText, writeText } from "./filesystem.js";
+import { readGitInfo } from "./git.js";
 const KNOWN_STATUSES = new Set([
     "planned",
     "in_progress",
@@ -32,7 +33,11 @@ export function statusDisplay(status) {
     }
 }
 function extractIdFromFilename(file) {
-    const m = /^(TASK-\d+)/i.exec(basename(file));
+    const name = basename(file);
+    const mvp = /^TASK-mvp/i.exec(name);
+    if (mvp)
+        return "TASK-mvp";
+    const m = /^(TASK-\d+)/i.exec(name);
     return m ? m[1].toUpperCase() : basename(file, ".md");
 }
 function extractTitleFromBody(body) {
@@ -98,7 +103,7 @@ export async function scanTasks(tasksDir) {
         return [];
     const entries = await readdir(tasksDir, { withFileTypes: true });
     const files = entries
-        .filter((e) => e.isFile() && e.name.endsWith(".md") && /^TASK-\d+/i.test(e.name))
+        .filter((e) => e.isFile() && e.name.endsWith(".md") && /^TASK-(?:\d+|mvp)/i.test(e.name))
         .map((e) => join(tasksDir, e.name))
         .sort();
     const out = [];
@@ -125,59 +130,87 @@ export function countTasks(tasks) {
         counts[t.status]++;
     return counts;
 }
+export function pickInProgressTask(tasks) {
+    return tasks.find((t) => t.status === "in_progress") ?? null;
+}
 export function pickNextTask(tasks) {
-    const inProgress = tasks.find((t) => t.status === "in_progress");
+    const inProgress = pickInProgressTask(tasks);
     if (inProgress)
         return inProgress;
     const review = tasks.find((t) => t.status === "review");
     if (review)
         return review;
-    const planned = tasks.find((t) => t.status === "planned");
-    return planned ?? null;
+    const planned = tasks.filter((t) => t.status === "planned");
+    const mvp = planned.find((t) => t.id.toUpperCase() === "TASK-MVP");
+    return mvp ?? planned[0] ?? null;
+}
+const TEMPLATE_TASK_ID = "TASK-000";
+export function filterActionableTasks(tasks) {
+    return tasks.filter((t) => t.id.toUpperCase() !== TEMPLATE_TASK_ID);
+}
+export function isMvpTaskId(id) {
+    return id.toUpperCase() === "TASK-MVP";
+}
+function taskSortKey(id) {
+    if (isMvpTaskId(id))
+        return 1_000_000;
+    const m = /^TASK-(\d+)$/i.exec(id.trim());
+    return m ? Number.parseInt(m[1], 10) : 0;
+}
+/** Latest finished TASK by numeric id (TASK-mvp sorts after numbered tasks). */
+export function pickLatestDoneTask(tasks) {
+    const done = filterActionableTasks(tasks).filter((t) => t.status === "done");
+    if (done.length === 0)
+        return null;
+    return [...done].sort((a, b) => taskSortKey(b.id) - taskSortKey(a.id))[0];
+}
+export async function loadActionableTasks(tasksDir) {
+    return filterActionableTasks(await scanTasks(tasksDir));
+}
+/** True when HEAD is on the TASK's recorded task branch. */
+export function isOnTaskBranch(gitBranch, ctx) {
+    return (typeof gitBranch === "string" &&
+        ctx !== null &&
+        gitBranch === ctx.taskBranch);
+}
+/**
+ * Prefer the TASK for the current `task/*` branch so `next` does not jump to the
+ * next Planned TASK while merge / `vibeops done` is still pending.
+ */
+export async function pickActiveTask(tasksDir, cwd) {
+    const actionable = await loadActionableTasks(tasksDir);
+    const git = await readGitInfo(cwd);
+    if (git.isRepo && typeof git.branch === "string" && git.branch.startsWith("task/")) {
+        for (const t of actionable) {
+            const ctx = await readGitContext(t.filePath);
+            if (isOnTaskBranch(git.branch, ctx))
+                return t;
+        }
+    }
+    return pickNextTask(actionable);
 }
 export async function findTaskFile(tasksDir, taskId) {
     const all = await scanTasks(tasksDir);
-    const target = taskId.toUpperCase();
+    const normalized = taskId.trim();
+    const target = /^mvp$/i.test(normalized) || /^task-mvp$/i.test(normalized)
+        ? "TASK-MVP"
+        : normalized.toUpperCase();
     for (const t of all) {
         if (t.id.toUpperCase() === target)
             return t.filePath;
     }
     return null;
 }
-/**
- * Read the highest TASK number currently present in `tasksDir`.
- * Considers only filenames that match `TASK-NNN-*.md` (the `TASK-000-template.md`
- * scaffolding file is included — callers can subtract its `0` if they want to
- * skip the placeholder).
- *
- * Returns 0 if no TASK files exist or the directory is missing.
- */
-export async function highestTaskNumber(tasksDir) {
-    if (!(await isDirectory(tasksDir)))
-        return 0;
-    const entries = await readdir(tasksDir, { withFileTypes: true });
-    let max = 0;
-    for (const e of entries) {
-        if (!e.isFile() || !e.name.endsWith(".md"))
-            continue;
-        const m = /^TASK-(\d+)/i.exec(e.name);
-        if (!m)
-            continue;
-        const n = Number.parseInt(m[1], 10);
-        if (Number.isFinite(n) && n > max)
-            max = n;
-    }
-    return max;
-}
-export async function nextTaskNumber(tasksDir) {
-    return (await highestTaskNumber(tasksDir)) + 1;
-}
-export function formatTaskId(n, width = 3) {
-    return `TASK-${String(n).padStart(width, "0")}`;
-}
 const TASK_FILENAME_RE = /^TASK-(\d+)(?:-(.+))?$/i;
+const TASK_MVP_FILENAME_RE = /^TASK-mvp(?:-(.+))?$/i;
 export function parseTaskFilename(filePath) {
     const stem = basename(filePath, extname(filePath));
+    const mvp = TASK_MVP_FILENAME_RE.exec(stem);
+    if (mvp) {
+        const tail = (mvp[1] ?? "").trim().toLowerCase();
+        const slug = tail.length > 0 ? `mvp-${tail}` : "mvp";
+        return { id: "TASK-mvp", number: "mvp", slug };
+    }
     const m = TASK_FILENAME_RE.exec(stem);
     if (!m) {
         return { id: stem.toUpperCase(), number: "000", slug: stem.toLowerCase() };
@@ -235,6 +268,18 @@ export function isPlaceholderContent(content) {
         return true; // legacy Korean placeholder
     if (/^_*\(none\)_*$/i.test(trimmed))
         return true;
+    if (/^\(not yet\)$/i.test(trimmed))
+        return true;
+    if (/^\(scaffold/i.test(trimmed))
+        return true;
+    if (/^pending\.?$/i.test(trimmed))
+        return true;
+    if (/^tbd\.?$/i.test(trimmed))
+        return true;
+    if (/^todo\.?$/i.test(trimmed))
+        return true;
+    if (/^-{1,3}$/.test(trimmed))
+        return true;
     return false;
 }
 export function hasNonEmptySection(body, title) {
@@ -306,6 +351,13 @@ export async function updateInlineStatus(filePath, next) {
         await writeText(filePath, updated);
     }
 }
+export async function updateTaskSection(filePath, title, content) {
+    const raw = await readText(filePath);
+    const updated = replaceSectionContent(raw, title, content);
+    if (updated !== raw) {
+        await writeText(filePath, updated);
+    }
+}
 function renderGitContextBlock(ctx) {
     const lines = [
         `- Base Branch: \`${ctx.baseBranch}\``,