@goodtek/vibeops 0.4.0 → 1.0.0

package/dist/lib/paths.js

@@ -14,13 +14,17 @@ export function projectPaths(root) {
         envExample: join(abs, VIBEOPS_ENV_EXAMPLE_FILE),
         agentsMd: join(abs, "AGENTS.md"),
         cursorRules: join(abs, ".cursor", "rules"),
+        cursorSkills: join(abs, ".cursor", "skills"),
         docsProject: join(abs, "docs", "project"),
         docsTasks: join(abs, "docs", "tasks"),
         docsLogs: join(abs, "docs", "logs"),
         vibeopsDir: join(abs, ".vibeops"),
-        vibeopsAgents: join(abs, ".vibeops", "agents"),
-        vibeopsPrompts: join(abs, ".vibeops", "prompts"),
-        vibeopsWorkflows: join(abs, ".vibeops", "workflows"),
         gitignore: join(abs, ".gitignore"),
     };
 }
+/** Project memory files updated by `vibeops task done`. */
+export const PROJECT_MEMORY_FILES = {
+    currentState: "docs/project/05-current-state.md",
+    architecture: "docs/project/03-architecture.md",
+    decisions: "docs/project/06-decisions.md",
+};

package/dist/lib/plan-llm-openai.js

@@ -29,7 +29,6 @@ export async function openAiChatCompletionJson(params) {
     }
     return content.trim();
 }
-/** Plain assistant text (no `response_format`) — used for planner markdown apply. */
 export async function openAiChatCompletionText(params) {
     const key = process.env.OPENAI_API_KEY?.trim();
     if (!key) {
@@ -70,65 +69,3 @@ export function extractJsonObject(text) {
         return trimmed.slice(start, end + 1);
     return trimmed;
 }
-export function parsePlanLlmTurn(jsonText) {
-    const raw = JSON.parse(jsonText);
-    const turn = raw.turn;
-    if (turn === "done") {
-        const pb = raw.projectBrief;
-        if (!pb || typeof pb !== "object" || Array.isArray(pb)) {
-            throw new Error('Invalid JSON: "done" turn requires object "projectBrief".');
-        }
-        const plannerAssumptions = raw.plannerAssumptions;
-        const pa = Array.isArray(plannerAssumptions) && plannerAssumptions.every((x) => typeof x === "string")
-            ? plannerAssumptions
-            : undefined;
-        return {
-            turn: "done",
-            projectBrief: pb,
-            plannerAssumptions: pa,
-        };
-    }
-    if (turn === "confirm") {
-        const readableSummary = typeof raw.readableSummary === "string" ? raw.readableSummary.trim() : "";
-        if (readableSummary.length === 0) {
-            throw new Error('Invalid JSON: "confirm" turn needs non-empty "readableSummary" (markdown).');
-        }
-        const plannerNote = typeof raw.plannerNote === "string" ? raw.plannerNote.trim() : undefined;
-        return {
-            turn: "confirm",
-            readableSummary,
-            plannerNote: plannerNote && plannerNote.length > 0 ? plannerNote : undefined,
-        };
-    }
-    if (turn === "question") {
-        const message = typeof raw.message === "string" ? raw.message : "";
-        if (message.length === 0) {
-            throw new Error('Invalid JSON: "question" turn needs non-empty "message".');
-        }
-        const options = Array.isArray(raw.options)
-            ? raw.options.filter((x) => typeof x === "string" && x.trim().length > 0)
-            : [];
-        const rawQt = raw.questionType;
-        let questionType;
-        if (rawQt === "single" || rawQt === "multi" || rawQt === "text") {
-            questionType = rawQt;
-        }
-        else if (options.length >= 2) {
-            /** Model often omits or mistypes questionType — multi is the safer default when lists are offered. */
-            questionType = "multi";
-        }
-        else if (options.length === 1) {
-            questionType = "single";
-        }
-        else {
-            questionType = "text";
-        }
-        return {
-            turn: "question",
-            message,
-            questionType,
-            options: options.length > 0 ? options : undefined,
-        };
-    }
-    throw new Error('Invalid JSON: "turn" must be "question", "confirm", or "done".');
-}

package/dist/lib/resolve-task.js

@@ -0,0 +1,34 @@
+import { findTaskFile, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
+export function normalizeTaskRef(ref) {
+    const t = ref.trim();
+    if (/^task-/i.test(t) && !/^TASK-/i.test(t)) {
+        return `TASK-${t.replace(/^task-/i, "")}`;
+    }
+    return t.toUpperCase().startsWith("TASK-") ? t.toUpperCase() : `TASK-${t}`;
+}
+export async function resolveTask(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    if (trimmed !== undefined && trimmed.length > 0) {
+        const taskId = normalizeTaskRef(trimmed);
+        const taskFile = await findTaskFile(paths.docsTasks, taskId);
+        if (taskFile === null)
+            return null;
+        return { taskId, taskFile };
+    }
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null) {
+        return { taskId: inProgress.id, taskFile: inProgress.filePath };
+    }
+    const onBranch = await pickActiveTask(paths.docsTasks, cwd);
+    if (onBranch !== null && onBranch.status !== "done") {
+        return { taskId: onBranch.id, taskFile: onBranch.filePath };
+    }
+    return null;
+}
+export function taskNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No open TASK found. Run `vibeops task add` or pass `vibeops task done TASK-NNN`.";
+}

package/dist/lib/slug.js

@@ -0,0 +1,11 @@
+/** Filename-safe slug (TASK-mvp-*, branch names, etc.). */
+export function slugify(input, fallback = "task") {
+    const cleaned = input
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-+/g, "-");
+    return cleaned.length > 0 ? cleaned.slice(0, 80) : fallback;
+}

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

@@ -0,0 +1,81 @@
+import { join, relative } from "node:path";
+import { readTextOrNull } from "./filesystem.js";
+import { llmCompleteJson } from "./llm-complete.js";
+import { projectPaths } from "./paths.js";
+import { slugify } from "./slug.js";
+import { buildMinimalTaskMarkdown, ensureV3Sections, normalizeTaskHeader, titleFromIdea, } from "./task-scaffold.js";
+import { statusDisplay } from "./task.js";
+import { extractJsonObject } from "./plan-llm-openai.js";
+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 loadProjectContextForLlm(cwd) {
+    const paths = projectPaths(cwd);
+    const candidates = [
+        join(paths.docsProject, "05-current-state.md"),
+        join(paths.docsProject, "03-architecture.md"),
+        join(paths.docsProject, "06-decisions.md"),
+    ];
+    const chunks = [];
+    for (const p of candidates) {
+        const snip = await readSnippet(p, 3000);
+        if (snip)
+            chunks.push(`### ${relative(cwd, p)}\n\n${snip}`);
+    }
+    return chunks.length > 0 ? chunks.join("\n\n") : "(no project docs yet)";
+}
+function systemPrompt() {
+    return `You are a VibeOps TASK author. Reply with JSON only.
+
+{
+  "title": "short title without TASK- id",
+  "slug": "kebab-case-max-60-chars",
+  "markdown": "full TASK markdown"
+}
+
+markdown must include sections: Status, Goal, Scope, Out of Scope, Acceptance Criteria, Test Plan, Git Context, Result, Test Result.
+Status body: ${statusDisplay("planned")}
+Result and Test Result: (not yet)
+Git Context: (populated by vibeops task add)
+Use the exact TASK id given in the user message for the # heading.`;
+}
+export async function llmScaffoldTask(params) {
+    try {
+        const context = await loadProjectContextForLlm(params.cwd);
+        const messages = [
+            { role: "system", content: systemPrompt() },
+            {
+                role: "user",
+                content: [`TASK id: ${params.taskId}`, `Idea: ${params.idea}`, "", context].join("\n"),
+            },
+        ];
+        const { text: raw, provider } = await llmCompleteJson(messages, { cwd: params.cwd });
+        const parsed = JSON.parse(extractJsonObject(raw));
+        const title = typeof parsed.title === "string"
+            ? parsed.title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim()
+            : "";
+        const slug = typeof parsed.slug === "string" ? slugify(parsed.slug, "task") : slugify(title, "task");
+        const markdown = typeof parsed.markdown === "string" ? parsed.markdown.trim() : "";
+        if (title.length === 0 || markdown.length === 0)
+            return null;
+        const body = ensureV3Sections(normalizeTaskHeader(markdown, params.taskId, title));
+        return { title, slug, markdown: body, provider };
+    }
+    catch {
+        return null;
+    }
+}
+export function fallbackTaskDraft(taskId, idea) {
+    const title = titleFromIdea(idea);
+    const draft = { id: taskId, title, idea };
+    const slug = slugify(title);
+    return {
+        title,
+        slug,
+        markdown: ensureV3Sections(normalizeTaskHeader(buildMinimalTaskMarkdown(draft), taskId, title)),
+    };
+}

package/dist/lib/task-context.js

@@ -0,0 +1,68 @@
+import { relative } from "node:path";
+import { gitBranchExists, readGitInfo } from "./git.js";
+import { readGitContext } from "./task.js";
+import { isOnTaskBranch, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
+/** TASK that blocks `task add` — in progress or open on current task branch. */
+export async function findBlockingTask(paths, cwd) {
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null)
+        return inProgress;
+    const git = await readGitInfo(cwd);
+    if (git.isRepo && typeof git.branch === "string" && git.branch.startsWith("task/")) {
+        for (const t of tasks) {
+            if (t.status === "done")
+                continue;
+            const ctx = await readGitContext(t.filePath);
+            if (isOnTaskBranch(git.branch, ctx))
+                return t;
+        }
+    }
+    return null;
+}
+export async function pickFocusTask(paths, cwd) {
+    return pickActiveTask(paths.docsTasks, cwd);
+}
+export function relPath(cwd, filePath) {
+    const r = relative(cwd, filePath).replace(/\\/g, "/");
+    return r.startsWith("..") ? filePath : r;
+}
+export function computeNextHint(input) {
+    if (!input.isVibeopsProject)
+        return "init";
+    if (input.focus === null)
+        return "task-add";
+    if (input.focus.status === "done")
+        return "task-add";
+    if (!input.resultFilled || !input.testFilled) {
+        return input.onTaskBranch === true ? "cursor-implement" : "cursor-plan";
+    }
+    return "task-done";
+}
+export function hintToText(hint, cwd, task) {
+    switch (hint) {
+        case "init":
+            return "Run `vibeops init` in this directory.";
+        case "task-add":
+            return "Run `vibeops task add` to start the next slice.";
+        case "task-done":
+            return task ? `Run \`vibeops task done ${task.id}\`.` : "Run `vibeops task done`.";
+        case "cursor-plan":
+            return task
+                ? `In Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC.`
+                : "Open the TASK file in Cursor Ask.";
+        case "cursor-implement":
+            return task
+                ? `In Cursor Agent: @${relPath(cwd, task.filePath)} — implement, then task done.`
+                : "Implement per the TASK file in Cursor.";
+    }
+}
+export async function listInProgressTasks(paths) {
+    return (await loadActionableTasks(paths.docsTasks)).filter((t) => t.status === "in_progress");
+}
+export async function taskBranchExistsFor(cwd, task) {
+    const ctx = await readGitContext(task.filePath);
+    if (ctx === null)
+        return false;
+    return gitBranchExists(cwd, ctx.taskBranch);
+}

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

@@ -0,0 +1,148 @@
+import { join } from "node:path";
+import { readText, readTextOrNull, writeText } from "./filesystem.js";
+import { llmCompleteJson } from "./llm-complete.js";
+import { gitDiffNameOnly, readGitInfo } from "./git.js";
+import { projectPaths, PROJECT_MEMORY_FILES } from "./paths.js";
+import { extractJsonObject } from "./plan-llm-openai.js";
+import { readSection, updateTaskSection } from "./task.js";
+function localDateFilename() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}.md`;
+}
+async function readOptional(path) {
+    return readTextOrNull(path);
+}
+export async function llmCompleteTaskDone(params) {
+    const git = await readGitInfo(params.cwd);
+    let diffSummary = "";
+    if (git.isRepo) {
+        const names = await gitDiffNameOnly(params.cwd);
+        diffSummary = names.slice(0, 40).join("\n") || "(no diff vs HEAD index yet)";
+    }
+    const paths = projectPaths(params.cwd);
+    const currentState = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.currentState))) ?? "";
+    const architecture = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.architecture))) ?? "";
+    const decisions = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.decisions))) ?? "";
+    const messages = [
+        {
+            role: "system",
+            content: `You close a VibeOps TASK. Reply with JSON only:
+{
+  "result": "markdown for TASK Result section — facts, paths, commands",
+  "testResult": "markdown for Test Result — commands and outcomes",
+  "currentStateMarkdown": "full replacement for docs/project/05-current-state.md OR null to skip",
+  "decisionsAppend": "markdown bullets to append under ## Decisions in 06-decisions.md OR null",
+  "architectureUpdate": "full replacement for 03-architecture.md OR null if structure unchanged",
+  "logLine": "one line for docs/logs/YYYY-MM-DD.md"
+}
+Be factual. Do not invent files not in the diff.`,
+        },
+        {
+            role: "user",
+            content: [
+                `TASK: ${params.taskId} — ${params.taskTitle}`,
+                `File: ${params.taskFileRel}`,
+                "",
+                "TASK body:",
+                params.taskBody.slice(0, 8000),
+                "",
+                "Changed paths (git):",
+                diffSummary,
+                "",
+                "Current 05-current-state.md:",
+                currentState.slice(0, 4000),
+                "",
+                "Current 03-architecture.md:",
+                architecture.slice(0, 4000),
+                "",
+                "Current 06-decisions.md:",
+                decisions.slice(0, 2000),
+            ].join("\n"),
+        },
+    ];
+    try {
+        const { text: raw, provider } = await llmCompleteJson(messages, { cwd: params.cwd });
+        const parsed = JSON.parse(extractJsonObject(raw));
+        const result = typeof parsed.result === "string" ? parsed.result.trim() : "";
+        const testResult = typeof parsed.testResult === "string" ? parsed.testResult.trim() : "";
+        if (result.length === 0 || testResult.length === 0)
+            return null;
+        return {
+            result,
+            testResult,
+            currentStateMarkdown: typeof parsed.currentStateMarkdown === "string" && parsed.currentStateMarkdown.trim().length > 0
+                ? parsed.currentStateMarkdown.trim()
+                : null,
+            decisionsAppend: typeof parsed.decisionsAppend === "string" && parsed.decisionsAppend.trim().length > 0
+                ? parsed.decisionsAppend.trim()
+                : null,
+            architectureUpdate: typeof parsed.architectureUpdate === "string" && parsed.architectureUpdate.trim().length > 0
+                ? parsed.architectureUpdate.trim()
+                : null,
+            logLine: typeof parsed.logLine === "string" && parsed.logLine.trim().length > 0
+                ? parsed.logLine.trim()
+                : `${params.taskId} done.`,
+            provider,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function applyTaskDoneMemory(cwd, patch) {
+    const paths = projectPaths(cwd);
+    const updated = [];
+    const skipped = [];
+    if (patch.currentStateMarkdown) {
+        const p = join(paths.root, PROJECT_MEMORY_FILES.currentState);
+        await writeText(p, `${patch.currentStateMarkdown.trimEnd()}\n`);
+        updated.push(PROJECT_MEMORY_FILES.currentState);
+    }
+    else {
+        skipped.push(PROJECT_MEMORY_FILES.currentState);
+    }
+    if (patch.architectureUpdate) {
+        const p = join(paths.root, PROJECT_MEMORY_FILES.architecture);
+        await writeText(p, `${patch.architectureUpdate.trimEnd()}\n`);
+        updated.push(PROJECT_MEMORY_FILES.architecture);
+    }
+    else {
+        skipped.push(PROJECT_MEMORY_FILES.architecture);
+    }
+    if (patch.decisionsAppend) {
+        const p = join(paths.root, PROJECT_MEMORY_FILES.decisions);
+        const existing = (await readOptional(p)) ?? "# Decisions\n\n";
+        const next = `${existing.trimEnd()}\n\n${patch.decisionsAppend.trim()}\n`;
+        await writeText(p, next);
+        updated.push(PROJECT_MEMORY_FILES.decisions);
+    }
+    else {
+        skipped.push(PROJECT_MEMORY_FILES.decisions);
+    }
+    const logPath = join(paths.docsLogs, localDateFilename());
+    const logExisting = (await readOptional(logPath)) ?? `# ${localDateFilename().replace(".md", "")}\n\n`;
+    await writeText(logPath, `${logExisting.trimEnd()}\n\n- ${patch.logLine}\n`);
+    updated.push(relativeLogPath(logPath, paths.root));
+    return { updated, skipped };
+}
+function relativeLogPath(abs, root) {
+    return abs.startsWith(root) ? abs.slice(root.length + 1) : abs;
+}
+export async function writeTaskResultSections(taskFile, result, testResult) {
+    await updateTaskSection(taskFile, "Result", result);
+    await updateTaskSection(taskFile, "Test Result", testResult);
+}
+/** Minimal fallback when LLM unavailable — git-only sections from diff. */
+export async function fallbackResultSections(cwd, taskId, taskFile) {
+    const names = await gitDiffNameOnly(cwd);
+    const body = await readText(taskFile);
+    const goal = readSection(body, "Goal").slice(0, 200);
+    const result = [`Completed ${taskId}.`, goal.length > 0 ? `Goal: ${goal}` : "", names.length > 0 ? `Paths: ${names.slice(0, 15).join(", ")}` : ""]
+        .filter((l) => l.length > 0)
+        .join("\n");
+    const testResult = names.length > 0 ? `Changed: ${names.join(", ")}` : "Manual verification required.";
+    return { result, testResult };
+}

package/dist/lib/task-merge.js

@@ -0,0 +1,115 @@
+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;
+    return `merge(${taskId.toLowerCase()}): ${slug} (${taskBranch})`;
+}
+async function gitPush(cwd, remote, ref, setUpstream) {
+    const args = ["push"];
+    if (setUpstream)
+        args.push("-u");
+    args.push(remote, ref);
+    await runGit(cwd, args);
+}
+export async function mergeTaskBranch(opts) {
+    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 };
+    }
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        return { ok: false };
+    }
+    const branchExists = await gitBranchExists(cwd, taskBranch);
+    if (!branchExists) {
+        log.error(`Local task branch not found: ${taskBranch}`);
+        return { ok: false };
+    }
+    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 };
+    }
+    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 };
+        }
+        log.warn("Dirty tree is governance-only — proceeding.");
+    }
+    log.step(bold(`Merging ${cyan(taskBranch)} → ${cyan(baseBranch)}`));
+    try {
+        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.`);
+            }
+        }
+        await gitCheckout(cwd, baseBranch);
+        if (hasRemote) {
+            try {
+                await runGit(cwd, ["pull", remote, baseBranch]);
+            }
+            catch {
+                log.warn(dim(`Could not pull ${remote}/${baseBranch} — merging locally.`));
+            }
+        }
+        await runGit(cwd, [
+            "merge",
+            "--no-ff",
+            taskBranch,
+            "-m",
+            mergeCommitMessage(taskId, taskTitle, taskBranch),
+        ]);
+        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}`);
+        return { ok: false };
+    }
+    try {
+        await gitDeleteBranch(cwd, taskBranch, { force: false });
+        log.ok(`Deleted local branch ${taskBranch}`);
+    }
+    catch {
+        try {
+            await gitDeleteBranch(cwd, taskBranch, { force: true });
+        }
+        catch {
+            log.warn(`Could not delete local branch ${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 };
+}