@goodtek/vibeops 0.2.0

package/dist/commands/task-pull.js

@@ -0,0 +1,277 @@
+import { resolve } from "node:path";
+import { bold, cyan, dim, gray, green, log, yellow } from "../lib/logger.js";
+import { maskToken } from "../lib/notion-env.js";
+import { notionApiError } from "../lib/notion-client.js";
+import { createNotionClient, fetchSchemas, loadSyncContext, } from "../lib/notion-sync.js";
+import { executePullEntry, planPull, } from "../lib/task-pull.js";
+function emptyReport(cwd, dryRun) {
+    return {
+        cwd,
+        ok: false,
+        dryRun,
+        tokenMasked: null,
+        notion: null,
+        filter: { projectId: "", statusNames: [], limit: 0 },
+        considered: 0,
+        entries: [],
+        skipped: [],
+        trace: [],
+        errors: [],
+    };
+}
+function parseStatusList(raw) {
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        return ["Planned"];
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+function parseLimit(raw) {
+    if (typeof raw === "number")
+        return raw;
+    if (typeof raw === "string" && raw.length > 0) {
+        const n = Number.parseInt(raw, 10);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return 20;
+}
+export async function taskPullCommand(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    const wantJson = options.json === true;
+    const verbose = options.verbose === true;
+    const report = emptyReport(cwd, dryRun);
+    const ctxRes = await loadSyncContext(cwd);
+    if (!ctxRes.ok) {
+        report.errors.push({ reason: ctxRes.reason, message: ctxRes.message });
+        return finalize(report, wantJson, verbose);
+    }
+    const ctx = ctxRes;
+    report.tokenMasked = maskToken(ctx.token);
+    report.notion = {
+        projectsTargetId: ctx.notion.projectsTargetId,
+        tasksTargetId: ctx.notion.tasksTargetId,
+        projectsDatabaseId: ctx.notion.projectsDatabaseId,
+        tasksDatabaseId: ctx.notion.tasksDatabaseId,
+    };
+    const statusNames = parseStatusList(options.status);
+    const limit = parseLimit(options.limit);
+    report.filter = {
+        projectId: ctx.project.projectId,
+        statusNames: [...statusNames],
+        limit,
+    };
+    let client;
+    try {
+        client = await createNotionClient(ctx.token);
+    }
+    catch (err) {
+        const apiErr = notionApiError(err);
+        report.errors.push({
+            reason: "sdk-load",
+            message: `Failed to load @notionhq/client — ${apiErr.message}`,
+            details: apiErr,
+        });
+        return finalize(report, wantJson, verbose);
+    }
+    const schemaRes = await fetchSchemas(client, ctx.notion);
+    if (!schemaRes.ok) {
+        report.errors.push({
+            reason: schemaRes.reason,
+            message: explainNotionError(schemaRes.error),
+            details: schemaRes.error,
+        });
+        return finalize(report, wantJson, verbose);
+    }
+    const violations = [
+        ...schemaRes.projects.violations,
+        ...schemaRes.tasks.violations,
+    ];
+    if (violations.length > 0) {
+        report.errors.push({
+            reason: "schema",
+            message: `Notion DB schema does not match VibeOps requirements (${violations.length} violation${violations.length === 1 ? "" : "s"}). Inspect details with \`vibeops notion test\`.`,
+            details: violations,
+        });
+        return finalize(report, wantJson, verbose);
+    }
+    let plan;
+    try {
+        plan = await planPull({
+            cwd,
+            client,
+            tasksDataSourceId: schemaRes.tasks.resolvedId,
+            projectId: ctx.project.projectId,
+            statusNames,
+            limit,
+        });
+    }
+    catch (err) {
+        const apiErr = notionApiError(err);
+        report.errors.push({
+            reason: "query",
+            message: explainNotionError(apiErr),
+            details: apiErr,
+        });
+        return finalize(report, wantJson, verbose);
+    }
+    report.considered = plan.considered;
+    for (const e of plan.entries) {
+        report.entries.push({
+            taskId: e.taskId,
+            title: e.title,
+            status: e.status,
+            mvpPhase: e.mvpPhase,
+            pageId: e.pageId,
+            docsRelativePath: e.docsRelativePath,
+            notionNeedsDocsPath: e.notionNeedsDocsPath,
+            ...(e.detail !== undefined ? { detail: e.detail } : {}),
+        });
+    }
+    for (const s of plan.skipped) {
+        report.skipped.push({
+            pageId: s.pageId,
+            taskId: s.taskId,
+            reason: s.reason,
+            docsRelativePath: s.docsRelativePath,
+            ...(s.detail !== undefined ? { detail: s.detail } : {}),
+        });
+    }
+    for (const t of plan.trace) {
+        report.trace.push({
+            taskId: t.taskId,
+            pageId: t.pageId,
+            notionDocsPath: t.notionDocsPath,
+            localResolvedPath: t.localResolvedPath,
+            decision: t.decision,
+            reason: t.reason,
+        });
+    }
+    if (dryRun) {
+        report.ok = true;
+        return finalize(report, wantJson, verbose);
+    }
+    let mutateFailed = false;
+    for (let i = 0; i < plan.entries.length; i++) {
+        const entry = plan.entries[i];
+        try {
+            const res = await executePullEntry(client, entry);
+            report.entries[i].created = true;
+            report.entries[i].notionUpdated = res.notionUpdated;
+        }
+        catch (err) {
+            mutateFailed = true;
+            const apiErr = notionApiError(err);
+            report.errors.push({
+                reason: "pull-execute",
+                message: `${entry.taskId}: ${explainNotionError(apiErr)}`,
+                details: apiErr,
+            });
+        }
+    }
+    report.ok = !mutateFailed;
+    finalize(report, wantJson, verbose);
+}
+function explainNotionError(err) {
+    const tail = err.status ? ` (HTTP ${err.status})` : "";
+    switch (err.code) {
+        case "unauthorized":
+            return `NOTION_TOKEN was rejected. Verify the integration is not expired and the value is correct.${tail}`;
+        case "restricted_resource":
+            return `The Notion DB is not shared with the integration. Add it via Notion DB → Connections.${tail}`;
+        case "object_not_found":
+            return `Notion resource not found. Verify the database id / page id.${tail}`;
+        case "validation_error":
+            return `Request rejected (validation_error): ${err.message}${tail}`;
+        case "rate_limited":
+            return `Notion API rate limit — retry shortly.${tail}`;
+        case "request_timeout":
+        case "ETIMEDOUT":
+            return `Notion API 5s timeout. Check your network.${tail}`;
+        default:
+            return `${err.code}: ${err.message}${tail}`;
+    }
+}
+function finalize(report, wantJson, verbose) {
+    if (wantJson) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        process.exitCode = report.ok ? 0 : 1;
+        return;
+    }
+    log.info(bold("vibeops task pull"));
+    log.info(`  ${dim("cwd")}  ${report.cwd}${report.dryRun ? `  ${yellow("[dry-run]")}` : ""}`);
+    if (report.tokenMasked)
+        log.info(`  ${dim("token")} ${report.tokenMasked}`);
+    if (report.filter.projectId.length > 0) {
+        log.info(`  ${dim("filter")} Project ID=${cyan(report.filter.projectId)}  Status ∈ {${report.filter.statusNames
+            .map((s) => cyan(s))
+            .join(", ")}}  ${dim(`limit=${report.filter.limit}`)}`);
+    }
+    log.blank();
+    for (const e of report.errors) {
+        log.error(`${cyan(e.reason)} — ${e.message}`);
+    }
+    if (report.errors.length > 0)
+        log.blank();
+    log.info(`  ${bold("considered")} ${report.considered} rows  ${dim("→")}  ${green(`new ${report.entries.length}`)}  ${yellow(`skipped ${report.skipped.length}`)}`);
+    log.blank();
+    if (report.entries.length > 0) {
+        log.info(bold("would create"));
+        for (const e of report.entries) {
+            const tag = e.created ? green("✓") : yellow("·");
+            const sync = e.notionUpdated ? cyan(" notion.docsPath←") : "";
+            log.info(`  ${tag} ${cyan(e.taskId)} ${e.title}${gray(`  status=${e.status} phase=${e.mvpPhase}`)}${sync}`);
+            log.info(`      ${dim(e.docsRelativePath)}`);
+            if (verbose && typeof e.detail === "string" && e.detail.length > 0) {
+                for (const line of e.detail.split(/\r?\n/)) {
+                    log.info(`      ${dim(line)}`);
+                }
+            }
+        }
+        log.blank();
+    }
+    if (report.skipped.length > 0) {
+        log.info(bold("skipped"));
+        for (const s of report.skipped) {
+            log.info(`  ${yellow("·")} ${cyan(s.taskId)} ${gray(s.reason)}  ${dim(s.docsRelativePath)}`);
+            if (typeof s.detail === "string" && s.detail.length > 0) {
+                // Print the per-skip detail unconditionally — the new mismatch /
+                // duplicate-task-id branches NEED to call out the Notion docs path
+                // and the action the user should take.
+                for (const line of s.detail.split(/\r?\n/)) {
+                    log.info(`      ${dim(line)}`);
+                }
+            }
+        }
+        log.blank();
+    }
+    if (verbose && report.trace.length > 0) {
+        log.info(bold("trace"));
+        for (const t of report.trace) {
+            log.info(`  ${cyan(t.taskId)}  ${gray(t.decision)}  ${dim(`page=${t.pageId}`)}`);
+            log.info(`      ${dim(`notion docs path : ${t.notionDocsPath || "(empty)"}`)}`);
+            log.info(`      ${dim(`local resolved   : ${t.localResolvedPath || "(none)"}`)}`);
+            log.info(`      ${dim(`reason           : ${t.reason}`)}`);
+        }
+        log.blank();
+    }
+    if (report.dryRun) {
+        log.info(yellow("  dry-run — no file or Notion mutation performed."));
+    }
+    if (report.ok && report.errors.length === 0) {
+        log.ok(report.dryRun
+            ? "Pull plan OK — re-run without --dry-run to apply."
+            : `task pull complete — ${report.entries.filter((e) => e.created).length} file(s) created.`);
+        process.exitCode = 0;
+    }
+    else if (report.ok) {
+        log.warn("Some rows were skipped.");
+        process.exitCode = 0;
+    }
+    else {
+        log.error("task pull failed — see errors above.");
+        process.exitCode = 1;
+    }
+}

package/dist/commands/task-rollback.js

@@ -0,0 +1,174 @@
+import { relative, resolve } from "node:path";
+import { gitBranchExists, gitCheckout, gitDeleteBranch, gitResetHard, readGitInfo, } from "../lib/git.js";
+import { bold, cyan, dim, log, red, yellow } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { findTaskFile, readGitContext, readTaskFile, statusDisplay } from "../lib/task.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+function shellQuote(s) {
+    return /^[A-Za-z0-9._/\-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function strategyCommands(strategy, ctx) {
+    switch (strategy) {
+        case "branch-delete":
+            return [
+                `git switch ${shellQuote(ctx.baseBranch)}`,
+                `git branch -D ${shellQuote(ctx.taskBranch)}`,
+            ];
+        case "reset-base":
+            return [
+                `git switch ${shellQuote(ctx.taskBranch)}`,
+                `git reset --hard ${shellQuote(ctx.baseCommit)}`,
+            ];
+        case "revert-merge":
+            return [
+                `git switch ${shellQuote(ctx.baseBranch)}`,
+                `# find the merge commit:`,
+                `git log --oneline --merges ${shellQuote(ctx.baseBranch)} | head -5`,
+                `# then:`,
+                `git revert -m 1 <merge-sha>`,
+            ];
+    }
+}
+function strategyRisk(strategy) {
+    switch (strategy) {
+        case "branch-delete":
+            return "The task branch will be deleted along with any unmerged changes on it.";
+        case "reset-base":
+            return "Hard-reset the current branch to the base commit. Uncommitted and unpushed changes will be lost.";
+        case "revert-merge":
+            return "For already-merged-and-pushed work: adds new revert commits while keeping history. VibeOps never force-pushes.";
+    }
+}
+const STRATEGY_LIST = ["branch-delete", "reset-base", "revert-merge"];
+function isDestructive(strategy) {
+    return strategy === "reset-base";
+}
+export async function taskRollbackCommand(taskId, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const taskFile = await findTaskFile(paths.docsTasks, taskId);
+    if (!taskFile) {
+        log.error(`TASK not found: ${taskId} (looked in ${relOrAbs(cwd, paths.docsTasks)})`);
+        process.exitCode = 1;
+        return;
+    }
+    const meta = await readTaskFile(taskFile);
+    const ctx = await readGitContext(taskFile);
+    const git = await readGitInfo(cwd);
+    log.info(bold(`vibeops task rollback ${meta.id}`));
+    log.info(`  ${dim("file")}    ${relOrAbs(cwd, taskFile)}`);
+    log.info(`  ${dim("status")}  ${statusDisplay(meta.status)}`);
+    if (git.isRepo) {
+        log.info(`  ${dim("branch")}  ${git.branch ?? dim("(detached)")}`);
+        log.info(`  ${dim("dirty")}   ${git.dirty ? yellow("yes") : "no"}`);
+    }
+    else {
+        log.info(`  ${red("✗")} not a git repository`);
+    }
+    log.blank();
+    if (ctx === null) {
+        log.error(`Git Context not recorded in ${relOrAbs(cwd, taskFile)}. Was \`vibeops task start ${meta.id}\` ever run?`);
+        log.info(`If you started the branch manually, add a "## Git Context" section to the TASK file with: Base Branch, Base Commit, Task Branch, Started At.`);
+        process.exitCode = 1;
+        return;
+    }
+    log.info(bold("Git Context (from TASK file)"));
+    log.info(`  ${dim("base branch")} ${ctx.baseBranch}`);
+    log.info(`  ${dim("base commit")} ${ctx.baseCommit}`);
+    log.info(`  ${dim("task branch")} ${cyan(ctx.taskBranch)}`);
+    log.info(`  ${dim("started at")}  ${ctx.startedAt}`);
+    log.blank();
+    log.info(bold("Available strategies"));
+    for (const s of STRATEGY_LIST) {
+        const destructive = isDestructive(s);
+        const tag = destructive ? red("destructive") : yellow("non-destructive");
+        log.info(`  ${bold(s)}  ${dim("·")} ${tag}`);
+        log.info(`    ${dim(strategyRisk(s))}`);
+        for (const cmd of strategyCommands(s, ctx)) {
+            if (cmd.startsWith("#")) {
+                log.info(`      ${dim(cmd)}`);
+            }
+            else {
+                log.info(`      ${dim("$")} ${cmd}`);
+            }
+        }
+        log.blank();
+    }
+    const wantConfirm = options.confirm === true || options.confirmDestructive === true;
+    if (!wantConfirm) {
+        log.info(`${yellow("!")} guidance only. add ${cyan("--confirm")} (non-destructive) or ${cyan("--confirm-destructive")} (allows hard reset) to actually run.`);
+        return;
+    }
+    const strategy = options.strategy ?? "branch-delete";
+    if (!STRATEGY_LIST.includes(strategy)) {
+        log.error(`Unknown strategy: ${strategy}. Choose from: ${STRATEGY_LIST.join(", ")}.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (strategy === "revert-merge") {
+        log.info(`${yellow("!")} ${bold("revert-merge")} is never executed automatically. Run the commands above manually. ` +
+            `(VibeOps never force-pushes, regardless of flag combination.)`);
+        return;
+    }
+    if (isDestructive(strategy) && options.confirmDestructive !== true) {
+        log.error(`${strategy} is a destructive operation. --confirm alone is not enough; pass --confirm-destructive to proceed.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!git.isRepo) {
+        log.error("Cannot run rollback: not a git repository.");
+        process.exitCode = 1;
+        return;
+    }
+    if (git.dirty === true && options.confirmDestructive !== true) {
+        log.error("Working tree is dirty. Commit / stash first, or rerun with --confirm-destructive to acknowledge the risk.");
+        process.exitCode = 1;
+        return;
+    }
+    if (options.dryRun === true) {
+        log.info(bold(`dry-run — would run for strategy=${strategy}:`));
+        for (const cmd of strategyCommands(strategy, ctx)) {
+            if (cmd.startsWith("#"))
+                continue;
+            log.info(`  ${dim("$")} ${cmd}`);
+        }
+        log.blank();
+        log.info(dim("no git command was executed."));
+        return;
+    }
+    if (strategy === "branch-delete") {
+        if (git.branch === ctx.taskBranch) {
+            log.info(`switching off ${ctx.taskBranch} → ${ctx.baseBranch}`);
+            await gitCheckout(cwd, ctx.baseBranch);
+        }
+        if (!(await gitBranchExists(cwd, ctx.taskBranch))) {
+            log.warn(`task branch already absent: ${ctx.taskBranch}`);
+        }
+        else {
+            if (options.keepBranch === true) {
+                log.info(`--keep-branch given → leaving ${ctx.taskBranch} intact.`);
+            }
+            else {
+                await gitDeleteBranch(cwd, ctx.taskBranch, { force: true });
+                log.ok(`deleted branch: ${ctx.taskBranch}`);
+            }
+        }
+        log.blank();
+        log.info(`Done. Current branch: ${cyan(ctx.baseBranch)}. TASK file Status is unchanged on purpose — edit it manually if needed.`);
+        return;
+    }
+    if (strategy === "reset-base") {
+        if (git.branch !== ctx.taskBranch) {
+            log.info(`switching to ${ctx.taskBranch}`);
+            await gitCheckout(cwd, ctx.taskBranch);
+        }
+        await gitResetHard(cwd, ctx.baseCommit);
+        log.ok(`hard reset ${ctx.taskBranch} → ${ctx.baseCommit}`);
+        log.blank();
+        log.info(`Done. Branch ${cyan(ctx.taskBranch)} now points at ${ctx.baseCommit}. TASK file Status is unchanged on purpose.`);
+        return;
+    }
+}

package/dist/commands/task-start.js

@@ -0,0 +1,90 @@
+import { relative, resolve } from "node:path";
+import { branchNameForTaskFile, findTaskFile, upsertGitContext, updateInlineStatus, } from "../lib/task.js";
+import { detectDefaultBranch, gitBranchExists, gitCheckoutNewBranch, gitHeadCommit, readGitInfo, } from "../lib/git.js";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+import { buildTaskPromptString } from "../lib/task-prompt.js";
+import { projectPaths } from "../lib/paths.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+export async function taskStartCommand(taskId, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const agentName = options.agent ?? "builder";
+    const taskFile = await findTaskFile(paths.docsTasks, taskId);
+    if (!taskFile) {
+        log.error(`TASK not found: ${taskId} (looked in ${relOrAbs(cwd, paths.docsTasks)})`);
+        process.exitCode = 1;
+        return;
+    }
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error(`Not a git repository: ${cwd}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (git.dirty === true && options.allowDirty !== true) {
+        log.error("Git working tree is dirty. Commit or stash first, or rerun with --allow-dirty.");
+        process.exitCode = 1;
+        return;
+    }
+    const baseBranch = git.branch ?? (await detectDefaultBranch(cwd)) ?? "main";
+    const baseCommit = (await gitHeadCommit(cwd)) ?? "";
+    if (baseCommit.length === 0) {
+        log.error("Failed to read HEAD commit. Repo has no commits yet?");
+        process.exitCode = 1;
+        return;
+    }
+    const taskBranch = branchNameForTaskFile(taskFile);
+    const startedAt = new Date().toISOString();
+    const ctx = { baseBranch, baseCommit, taskBranch, startedAt };
+    log.info(bold(`vibeops task start ${taskId}`));
+    log.info(`  ${dim("file")}        ${relOrAbs(cwd, taskFile)}`);
+    log.info(`  ${dim("base branch")} ${baseBranch}`);
+    log.info(`  ${dim("base commit")} ${baseCommit}`);
+    log.info(`  ${dim("task branch")} ${cyan(taskBranch)}`);
+    log.info(`  ${dim("started at")}  ${startedAt}`);
+    log.blank();
+    if (options.dryRun === true) {
+        log.info(bold("dry-run — would perform:"));
+        log.info(`  · git checkout -b ${taskBranch} ${baseBranch}`);
+        log.info(`  · update Status → In Progress in ${relOrAbs(cwd, taskFile)}`);
+        log.info(`  · upsert "## Git Context" section in ${relOrAbs(cwd, taskFile)}`);
+        log.info(`  · build Cursor prompt for agent "${agentName}"`);
+        log.blank();
+        log.info(dim("no files were written and no git command was executed."));
+        return;
+    }
+    if (await gitBranchExists(cwd, taskBranch)) {
+        log.error(`Task branch already exists: ${taskBranch}`);
+        log.info(`  Use a different TASK or delete the existing branch first: \`git branch -D ${taskBranch}\`.`);
+        process.exitCode = 1;
+        return;
+    }
+    await gitCheckoutNewBranch(cwd, taskBranch, baseBranch);
+    log.ok(`checked out new branch: ${taskBranch}`);
+    await updateInlineStatus(taskFile, "in_progress");
+    await upsertGitContext(taskFile, ctx);
+    log.ok(`updated ${relOrAbs(cwd, taskFile)} (Status + Git Context)`);
+    log.blank();
+    const promptResult = await buildTaskPromptString({
+        projectRoot: paths.root,
+        agentsDir: paths.vibeopsAgents,
+        agentName,
+        taskFilePath: taskFile,
+    });
+    if (!promptResult.ok) {
+        log.warn(`agent "${agentName}" not found in ${relOrAbs(cwd, paths.vibeopsAgents)} — skipping prompt.`);
+        if (promptResult.available.length > 0) {
+            log.info(`Available agents: ${promptResult.available.join(", ")}`);
+        }
+        log.info(`Run \`vibeops task prompt ${taskId} --agent <name>\` later to generate the Cursor prompt.`);
+        return;
+    }
+    log.info(bold(`Cursor prompt (agent: ${agentName}):`));
+    log.info(dim("─".repeat(60)));
+    log.raw(promptResult.prompt.endsWith("\n") ? promptResult.prompt : `${promptResult.prompt}\n`);
+    log.info(dim("─".repeat(60)));
+    log.info(`Copy the block above into Cursor. When done, run \`vibeops task check ${taskId}\`.`);
+}