@goodtek/vibeops 0.2.0

package/dist/lib/brief.js

@@ -0,0 +1,349 @@
+import { basename } from "node:path";
+import { askCheckbox, askConfirm, askInput, askSelect, } from "./inquirer-helpers.js";
+import { VERSION } from "../version.js";
+import { AGENT_WORKFLOW_CHOICES, AUTH_REQUIREMENT_CHOICES, BACKEND_CHOICES, DATABASE_CHOICES, DB_LAYER_CHOICES, DEPLOYMENT_TARGET_CHOICES, FRONTEND_CHOICES, INTEGRATION_CHOICES, MVP_FEATURE_CHOICES, OUT_OF_SCOPE_CHOICES, PACKAGE_MANAGER_CHOICES, PROJECT_BRIEF_SCHEMA_VERSION, PROJECT_TYPE_CHOICES, RISK_AREA_CHOICES, TARGET_USER_CHOICES, } from "../types/brief.js";
+const PLACEHOLDER_PROJECT_NAME = "Unnamed Project";
+const PLACEHOLDER_IDEA = "(no idea provided — Planner Agent must fill this in)";
+const PLACEHOLDER_PROBLEM = "(no core problem provided — Planner Agent must fill this in)";
+const PLACEHOLDER_SUCCESS = "(no success criteria provided — Planner Agent must fill this in)";
+export function parseIdea(idea) {
+    if (typeof idea !== "string")
+        return {};
+    const trimmed = idea.trim();
+    if (trimmed.length === 0)
+        return {};
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx > 0 && colonIdx < 40) {
+        const head = trimmed.slice(0, colonIdx).trim();
+        const tail = trimmed.slice(colonIdx + 1).trim();
+        if (head.length > 0 && !head.includes(" ") && tail.length > 0) {
+            return { projectName: head, oneLineIdea: tail };
+        }
+    }
+    return { oneLineIdea: trimmed };
+}
+function deriveProjectTypeDefault(idea) {
+    if (typeof idea === "string" && /browser/i.test(idea)) {
+        return "Browser Automation";
+    }
+    return "SaaS";
+}
+export async function gatherBrief(inputs) {
+    const assumptions = [];
+    const seed = inputs.seed ?? {};
+    const ideaParsed = parseIdea(inputs.idea);
+    const defaultName = seed.projectName ?? ideaParsed.projectName ?? basename(inputs.cwd) ?? PLACEHOLDER_PROJECT_NAME;
+    const projectName = await askInput({
+        message: "1/20 · Project name",
+        nonInteractive: inputs.nonInteractive,
+        default: defaultName,
+        required: !inputs.nonInteractive,
+        fallback: PLACEHOLDER_PROJECT_NAME,
+    });
+    const finalProjectName = projectName.length > 0 ? projectName : PLACEHOLDER_PROJECT_NAME;
+    if (finalProjectName === PLACEHOLDER_PROJECT_NAME) {
+        assumptions.push('projectName: directory name was empty too — defaulted to "Unnamed Project"');
+    }
+    const oneLineIdea = await askInput({
+        message: "2/20 · One-line idea",
+        nonInteractive: inputs.nonInteractive,
+        default: seed.oneLineIdea ?? ideaParsed.oneLineIdea,
+        required: !inputs.nonInteractive,
+        fallback: PLACEHOLDER_IDEA,
+    });
+    const finalIdea = oneLineIdea.length > 0 ? oneLineIdea : PLACEHOLDER_IDEA;
+    if (finalIdea === PLACEHOLDER_IDEA) {
+        assumptions.push("oneLineIdea: not provided — placeholder for Planner Agent to fill");
+    }
+    const projectType = await askSelect({
+        message: "3/20 · Project type",
+        nonInteractive: inputs.nonInteractive,
+        choices: PROJECT_TYPE_CHOICES,
+        default: seed.projectType ?? deriveProjectTypeDefault(inputs.idea ?? seed.oneLineIdea),
+    });
+    const targetUsers = await askCheckbox({
+        message: "4/20 · Target users (Space to toggle, Enter to confirm)",
+        nonInteractive: inputs.nonInteractive,
+        choices: TARGET_USER_CHOICES,
+        default: seed.targetUsers,
+    });
+    const coreProblem = await askInput({
+        message: "5/20 · Core problem",
+        nonInteractive: inputs.nonInteractive,
+        default: seed.coreProblem,
+        fallback: PLACEHOLDER_PROBLEM,
+    });
+    const finalCoreProblem = coreProblem.length > 0 ? coreProblem : PLACEHOLDER_PROBLEM;
+    if (finalCoreProblem === PLACEHOLDER_PROBLEM) {
+        assumptions.push("coreProblem: not provided — placeholder for Planner Agent to fill");
+    }
+    const mvpFeatures = await askCheckbox({
+        message: "6/20 · MVP must-have features",
+        nonInteractive: inputs.nonInteractive,
+        choices: MVP_FEATURE_CHOICES,
+        default: seed.mvpFeatures,
+    });
+    const outOfScope = await askCheckbox({
+        message: "7/20 · Out of scope for MVP",
+        nonInteractive: inputs.nonInteractive,
+        choices: OUT_OF_SCOPE_CHOICES,
+        default: seed.outOfScope,
+    });
+    const frontend = await askSelect({
+        message: "8/20 · Preferred frontend",
+        nonInteractive: inputs.nonInteractive,
+        choices: FRONTEND_CHOICES,
+        default: seed.frontend ?? "Next.js",
+    });
+    const backend = await askSelect({
+        message: "9/20 · Preferred backend",
+        nonInteractive: inputs.nonInteractive,
+        choices: BACKEND_CHOICES,
+        default: seed.backend ?? "NestJS",
+    });
+    const database = await askSelect({
+        message: "10/20 · Database",
+        nonInteractive: inputs.nonInteractive,
+        choices: DATABASE_CHOICES,
+        default: seed.database ?? "PostgreSQL",
+    });
+    const dbLayer = await askSelect({
+        message: "11/20 · ORM / DB layer",
+        nonInteractive: inputs.nonInteractive,
+        choices: DB_LAYER_CHOICES,
+        default: seed.dbLayer ?? "Drizzle",
+    });
+    const packageManager = await askSelect({
+        message: "12/20 · Package manager",
+        nonInteractive: inputs.nonInteractive,
+        choices: PACKAGE_MANAGER_CHOICES,
+        default: seed.packageManager ?? "pnpm",
+    });
+    const deploymentTargets = await askCheckbox({
+        message: "13/20 · Deployment target",
+        nonInteractive: inputs.nonInteractive,
+        choices: DEPLOYMENT_TARGET_CHOICES,
+        default: seed.deploymentTargets,
+    });
+    const authRequirements = await askCheckbox({
+        message: "14/20 · Auth requirement",
+        nonInteractive: inputs.nonInteractive,
+        choices: AUTH_REQUIREMENT_CHOICES,
+        default: seed.authRequirements,
+    });
+    const integrations = await askCheckbox({
+        message: "15/20 · External integrations",
+        nonInteractive: inputs.nonInteractive,
+        choices: INTEGRATION_CHOICES,
+        default: seed.integrations,
+    });
+    const useNotion = await askConfirm({
+        message: "16/20 · Use Notion dashboard sync?",
+        nonInteractive: inputs.nonInteractive,
+        default: seed.useNotion ?? true,
+    });
+    const useGitWorkflow = await askConfirm({
+        message: "17/20 · Use Git task branch workflow?",
+        nonInteractive: inputs.nonInteractive,
+        default: seed.useGitWorkflow ?? true,
+    });
+    const agentWorkflowLevel = await askSelect({
+        message: "18/20 · Agent workflow level",
+        nonInteractive: inputs.nonInteractive,
+        choices: AGENT_WORKFLOW_CHOICES,
+        default: seed.agentWorkflowLevel ??
+            "Advanced: Orchestrator + Planner + Architect + Builder + Tester + Reviewer + Docs + Recovery",
+    });
+    const risks = await askCheckbox({
+        message: "19/20 · Risk areas",
+        nonInteractive: inputs.nonInteractive,
+        choices: RISK_AREA_CHOICES,
+        default: seed.risks,
+    });
+    const successCriteria = await askInput({
+        message: "20/20 · Success criteria",
+        nonInteractive: inputs.nonInteractive,
+        default: seed.successCriteria,
+        fallback: PLACEHOLDER_SUCCESS,
+    });
+    const finalSuccess = successCriteria.length > 0 ? successCriteria : PLACEHOLDER_SUCCESS;
+    if (finalSuccess === PLACEHOLDER_SUCCESS) {
+        assumptions.push("successCriteria: not provided — placeholder for Planner Agent to fill");
+    }
+    const brief = {
+        projectName: finalProjectName,
+        oneLineIdea: finalIdea,
+        projectType,
+        targetUsers,
+        coreProblem: finalCoreProblem,
+        mvpFeatures,
+        outOfScope,
+        frontend,
+        backend,
+        database,
+        dbLayer,
+        packageManager,
+        deploymentTargets,
+        authRequirements,
+        integrations,
+        useNotion,
+        useGitWorkflow,
+        agentWorkflowLevel,
+        risks,
+        successCriteria: finalSuccess,
+    };
+    const meta = {
+        vibeopsVersion: VERSION,
+        generatedAt: new Date().toISOString(),
+        source: inputs.nonInteractive ? "non-interactive" : "interactive",
+        schemaVersion: PROJECT_BRIEF_SCHEMA_VERSION,
+        assumptions,
+    };
+    return { brief, meta };
+}
+const SECTIONS = [
+    { num: 1, title: "Project name", field: "projectName" },
+    { num: 2, title: "One-line idea", field: "oneLineIdea" },
+    { num: 3, title: "Project type", field: "projectType" },
+    { num: 4, title: "Target users", field: "targetUsers" },
+    { num: 5, title: "Core problem", field: "coreProblem" },
+    { num: 6, title: "MVP must-have features", field: "mvpFeatures" },
+    { num: 7, title: "Out of scope for MVP", field: "outOfScope" },
+    { num: 8, title: "Preferred frontend", field: "frontend" },
+    { num: 9, title: "Preferred backend", field: "backend" },
+    { num: 10, title: "Database", field: "database" },
+    { num: 11, title: "ORM / DB layer", field: "dbLayer" },
+    { num: 12, title: "Package manager", field: "packageManager" },
+    { num: 13, title: "Deployment target", field: "deploymentTargets" },
+    { num: 14, title: "Auth requirement", field: "authRequirements" },
+    { num: 15, title: "External integrations", field: "integrations" },
+    { num: 16, title: "Use Notion dashboard sync?", field: "useNotion" },
+    { num: 17, title: "Use Git task branch workflow?", field: "useGitWorkflow" },
+    { num: 18, title: "Agent workflow level", field: "agentWorkflowLevel" },
+    { num: 19, title: "Risk areas", field: "risks" },
+    { num: 20, title: "Success criteria", field: "successCriteria" },
+];
+function renderList(values) {
+    if (values.length === 0)
+        return "_(none)_";
+    return values.map((v) => `- ${v}`).join("\n");
+}
+function renderScalar(value) {
+    return value.length > 0 ? value : "_(empty)_";
+}
+function renderBool(value) {
+    return value ? "yes" : "no";
+}
+export function briefToMarkdown(brief, meta) {
+    const lines = [];
+    lines.push(`# Project Brief — ${brief.projectName}`);
+    lines.push("");
+    lines.push(`> Generated: ${meta.generatedAt} · VibeOps ${meta.vibeopsVersion} · Source: ${meta.source} · schemaVersion: ${meta.schemaVersion}`);
+    lines.push("");
+    lines.push("This brief is the input for the Cursor **Planner Agent**. VibeOps does not call LLMs directly.");
+    lines.push("The Planner Agent reads this brief, fills in `docs/project/*`, and creates the initial backlog.");
+    lines.push("");
+    for (const sec of SECTIONS) {
+        lines.push(`## ${sec.num}. ${sec.title}`);
+        lines.push("");
+        const value = brief[sec.field];
+        if (typeof value === "boolean") {
+            lines.push(renderBool(value));
+        }
+        else if (Array.isArray(value)) {
+            lines.push(renderList(value));
+        }
+        else {
+            lines.push(renderScalar(value));
+        }
+        lines.push("");
+    }
+    lines.push("## Assumptions");
+    lines.push("");
+    if (meta.assumptions.length === 0) {
+        lines.push("_(none)_");
+    }
+    else {
+        for (const a of meta.assumptions)
+            lines.push(`- ${a}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function extractSection(md, num) {
+    const re = new RegExp(String.raw `^##\s+${num}\.\s+[^\n]*\n([\s\S]*?)(?=^##\s+|\Z)`, "m");
+    const match = md.match(re);
+    return match ? (match[1] ?? "").trim() : "";
+}
+function parseList(text) {
+    if (text.length === 0 || text === "_(none)_")
+        return [];
+    const items = [];
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (line.startsWith("- ")) {
+            const v = line.slice(2).trim();
+            if (v.length > 0)
+                items.push(v);
+        }
+    }
+    return items;
+}
+function parseScalar(text) {
+    if (text === "_(empty)_")
+        return "";
+    return text.trim();
+}
+function parseBool(text) {
+    const t = text.trim().toLowerCase();
+    return t === "yes" || t === "true" || t === "y";
+}
+export function parseBriefFromMarkdown(md) {
+    const brief = {
+        projectName: parseScalar(extractSection(md, 1)),
+        oneLineIdea: parseScalar(extractSection(md, 2)),
+        projectType: parseScalar(extractSection(md, 3)),
+        targetUsers: parseList(extractSection(md, 4)),
+        coreProblem: parseScalar(extractSection(md, 5)),
+        mvpFeatures: parseList(extractSection(md, 6)),
+        outOfScope: parseList(extractSection(md, 7)),
+        frontend: parseScalar(extractSection(md, 8)),
+        backend: parseScalar(extractSection(md, 9)),
+        database: parseScalar(extractSection(md, 10)),
+        dbLayer: parseScalar(extractSection(md, 11)),
+        packageManager: parseScalar(extractSection(md, 12)),
+        deploymentTargets: parseList(extractSection(md, 13)),
+        authRequirements: parseList(extractSection(md, 14)),
+        integrations: parseList(extractSection(md, 15)),
+        useNotion: parseBool(extractSection(md, 16)),
+        useGitWorkflow: parseBool(extractSection(md, 17)),
+        agentWorkflowLevel: parseScalar(extractSection(md, 18)),
+        risks: parseList(extractSection(md, 19)),
+        successCriteria: parseScalar(extractSection(md, 20)),
+    };
+    const assumptionMatch = md.match(/^##\s+Assumptions\s*\n([\s\S]*?)(?=^##\s+|\Z)/m);
+    const assumptions = assumptionMatch && assumptionMatch[1] ? parseList(assumptionMatch[1].trim()) : [];
+    const headerMatch = md.match(/^>\s+Generated:\s+([^\s]+)\s+·\s+VibeOps\s+([^\s]+)\s+·\s+Source:\s+([^\s·]+)/m);
+    const generatedAt = headerMatch?.[1] ?? new Date().toISOString();
+    const recordedVersion = headerMatch?.[2] ?? VERSION;
+    const recordedSource = headerMatch?.[3] ?? "from-file";
+    const meta = {
+        vibeopsVersion: recordedVersion,
+        generatedAt,
+        source: recordedSource === "from-file" ? "from-file" : recordedSource,
+        schemaVersion: PROJECT_BRIEF_SCHEMA_VERSION,
+        assumptions,
+    };
+    return { brief, meta };
+}
+export function findMissingRequired(brief) {
+    const missing = [];
+    if (brief.projectName.length === 0 || brief.projectName === PLACEHOLDER_PROJECT_NAME) {
+        missing.push("projectName");
+    }
+    if (brief.oneLineIdea.length === 0 ||
+        brief.oneLineIdea === PLACEHOLDER_IDEA) {
+        missing.push("oneLineIdea");
+    }
+    return missing;
+}

package/dist/lib/config.js

@@ -0,0 +1,158 @@
+import { join } from "node:path";
+import { readTextOrNull, writeText } from "./filesystem.js";
+import { VIBEOPS_CONFIG_FILE } from "./paths.js";
+import { VERSION } from "../version.js";
+import { DEFAULT_GITHUB_CONFIG, VIBEOPS_CONFIG_SCHEMA_VERSION, } from "../types/config.js";
+function parseNotionSection(raw) {
+    if (raw === null || typeof raw !== "object")
+        return undefined;
+    const r = raw;
+    const out = {
+        enabled: typeof r.enabled === "boolean" ? r.enabled : false,
+        projectsTargetId: typeof r.projectsTargetId === "string" ? r.projectsTargetId : "",
+        tasksTargetId: typeof r.tasksTargetId === "string" ? r.tasksTargetId : "",
+        projectsDatabaseId: typeof r.projectsDatabaseId === "string" ? r.projectsDatabaseId : "",
+        tasksDatabaseId: typeof r.tasksDatabaseId === "string" ? r.tasksDatabaseId : "",
+    };
+    return out;
+}
+function parseGithubVisibility(raw) {
+    if (raw === "public" || raw === "private")
+        return raw;
+    return "";
+}
+function parseGithubSection(raw) {
+    if (raw === null || typeof raw !== "object")
+        return undefined;
+    const r = raw;
+    return {
+        enabled: typeof r.enabled === "boolean" ? r.enabled : false,
+        mode: r.mode === "gh-cli" ? "gh-cli" : "gh-cli",
+        owner: typeof r.owner === "string" ? r.owner : "",
+        repo: typeof r.repo === "string" ? r.repo : "",
+        remote: typeof r.remote === "string" && r.remote.length > 0 ? r.remote : "origin",
+        visibility: parseGithubVisibility(r.visibility),
+        url: typeof r.url === "string" ? r.url : "",
+    };
+}
+export async function readConfig(root) {
+    const text = await readTextOrNull(join(root, VIBEOPS_CONFIG_FILE));
+    if (text === null)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.name === "string" &&
+            typeof parsed.vibeopsVersion === "string" &&
+            typeof parsed.createdAt === "string" &&
+            parsed.schemaVersion === VIBEOPS_CONFIG_SCHEMA_VERSION) {
+            const notion = parseNotionSection(parsed.notion);
+            const github = parseGithubSection(parsed.github);
+            const config = {
+                name: parsed.name,
+                vibeopsVersion: parsed.vibeopsVersion,
+                schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
+                createdAt: parsed.createdAt,
+            };
+            if (notion)
+                config.notion = notion;
+            if (github)
+                config.github = github;
+            return config;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildConfig(name, nowIso) {
+    return {
+        name,
+        vibeopsVersion: VERSION,
+        schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
+        createdAt: nowIso ?? new Date().toISOString(),
+    };
+}
+export function configToJson(config) {
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
+export async function writeConfig(root, config) {
+    await writeText(join(root, VIBEOPS_CONFIG_FILE), configToJson(config));
+}
+/** Merge a partial notion section into an existing config without touching other fields. */
+export function mergeNotionConfig(base, patch) {
+    const current = base.notion ?? {
+        enabled: false,
+        projectsTargetId: "",
+        tasksTargetId: "",
+        projectsDatabaseId: "",
+        tasksDatabaseId: "",
+    };
+    const next = {
+        enabled: patch.enabled ?? current.enabled,
+        projectsTargetId: patch.projectsTargetId !== undefined && patch.projectsTargetId.length > 0
+            ? patch.projectsTargetId
+            : current.projectsTargetId,
+        tasksTargetId: patch.tasksTargetId !== undefined && patch.tasksTargetId.length > 0
+            ? patch.tasksTargetId
+            : current.tasksTargetId,
+        projectsDatabaseId: patch.projectsDatabaseId !== undefined && patch.projectsDatabaseId.length > 0
+            ? patch.projectsDatabaseId
+            : current.projectsDatabaseId,
+        tasksDatabaseId: patch.tasksDatabaseId !== undefined && patch.tasksDatabaseId.length > 0
+            ? patch.tasksDatabaseId
+            : current.tasksDatabaseId,
+    };
+    const changed = base.notion === undefined ||
+        next.enabled !== current.enabled ||
+        next.projectsTargetId !== current.projectsTargetId ||
+        next.tasksTargetId !== current.tasksTargetId ||
+        next.projectsDatabaseId !== current.projectsDatabaseId ||
+        next.tasksDatabaseId !== current.tasksDatabaseId;
+    return { merged: { ...base, notion: next }, changed };
+}
+/** Preferred Projects target id for API calls: data_source target first, legacy DB fallback. */
+export function notionProjectsTargetId(notion) {
+    return notion.projectsTargetId.length > 0
+        ? notion.projectsTargetId
+        : notion.projectsDatabaseId;
+}
+/** Preferred Tasks target id for API calls: data_source target first, legacy DB fallback. */
+export function notionTasksTargetId(notion) {
+    return notion.tasksTargetId.length > 0 ? notion.tasksTargetId : notion.tasksDatabaseId;
+}
+/**
+ * Merge a partial github section into an existing config without touching
+ * other fields (notion, name, etc.). Empty strings in the patch are treated
+ * as "no value provided" — the existing value is kept. Pass through
+ * `enabled` / `mode` always (booleans / enums always overwrite).
+ */
+export function mergeGithubConfig(base, patch) {
+    const current = base.github ?? DEFAULT_GITHUB_CONFIG;
+    const next = {
+        enabled: patch.enabled ?? current.enabled,
+        mode: patch.mode ?? current.mode,
+        owner: patch.owner !== undefined && patch.owner.length > 0
+            ? patch.owner
+            : current.owner,
+        repo: patch.repo !== undefined && patch.repo.length > 0
+            ? patch.repo
+            : current.repo,
+        remote: patch.remote !== undefined && patch.remote.length > 0
+            ? patch.remote
+            : current.remote,
+        visibility: patch.visibility !== undefined && patch.visibility.length > 0
+            ? patch.visibility
+            : current.visibility,
+        url: patch.url !== undefined && patch.url.length > 0 ? patch.url : current.url,
+    };
+    const changed = base.github === undefined ||
+        next.enabled !== current.enabled ||
+        next.mode !== current.mode ||
+        next.owner !== current.owner ||
+        next.repo !== current.repo ||
+        next.remote !== current.remote ||
+        next.visibility !== current.visibility ||
+        next.url !== current.url;
+    return { merged: { ...base, github: next }, changed };
+}

package/dist/lib/filesystem.js

@@ -0,0 +1,67 @@
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, relative } from "node:path";
+export async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isFile(path) {
+    try {
+        const s = await stat(path);
+        return s.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDirectory(path) {
+    try {
+        const s = await stat(path);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function readText(path) {
+    return readFile(path, "utf-8");
+}
+export async function readTextOrNull(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+export async function ensureDir(path) {
+    await mkdir(path, { recursive: true });
+}
+export async function writeText(path, contents) {
+    await ensureDir(dirname(path));
+    await writeFile(path, contents, "utf-8");
+}
+export async function walk(root) {
+    const out = [];
+    async function visit(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const abs = `${dir}/${entry.name}`;
+            if (entry.isDirectory()) {
+                await visit(abs);
+            }
+            else if (entry.isFile()) {
+                out.push(abs);
+            }
+        }
+    }
+    await visit(root);
+    return out;
+}
+export function relativeFrom(root, target) {
+    return relative(root, target);
+}