@boopkit/cli 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,295 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const profile_1 = require("../lib/profile");
+const capability_1 = require("../lib/capability");
+const scaffold_1 = require("../lib/scaffold");
+const project_1 = require("../lib/project");
+const env_1 = require("../lib/env");
+const safe_io_1 = require("../lib/safe-io");
+function runInit(name, options) {
+    const profileName = options.profile ?? 'web-app';
+    const shouldInstall = options.install !== false;
+    // --- Validate ---
+    // Guard: project name must not be empty
+    if (!name || !name.trim()) {
+        console.error('Error: Project name is required and cannot be empty.');
+        process.exitCode = 1;
+        return;
+    }
+    const targetDir = path.resolve(process.cwd(), name);
+    // Guard: target directory must not exist or must be empty
+    if (fs.existsSync(targetDir)) {
+        const entries = fs.readdirSync(targetDir);
+        if (entries.length > 0) {
+            console.error(`Error: Directory "${name}" already exists and is not empty.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // --- Resolve profile ---
+    const profile = (0, profile_1.getProfile)(profileName);
+    if (!profile) {
+        console.error(`Error: Profile "${profileName}" not found.`);
+        process.exitCode = 1;
+        return;
+    }
+    // --- Node version check ---
+    const requiredNodeVersion = profile.kernel.nodeVersion;
+    if (requiredNodeVersion && !process.env.BOOP_SKIP_VERSION_CHECK) {
+        const minVersion = requiredNodeVersion.replace(/^[>=^~]+/, '');
+        const currentMajor = parseInt(process.versions.node.split('.')[0], 10);
+        const requiredMajor = parseInt(minVersion.split('.')[0], 10);
+        if (currentMajor < requiredMajor) {
+            console.error(`Error: Node.js v${requiredMajor}+ required. You're running v${process.versions.node}.`);
+            console.error(`Run \`nvm install ${requiredMajor}\` to upgrade.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // --- Pre-flight: detect script conflicts before writing anything ---
+    const capabilityNames = profile.defaultCapabilities;
+    const preflightScripts = {};
+    for (const capName of capabilityNames) {
+        const cap = (0, capability_1.getCapability)(capName);
+        if (!cap?.scripts)
+            continue;
+        for (const scriptName of Object.keys(cap.scripts)) {
+            if (scriptName in preflightScripts) {
+                console.error(`Error: Script "${scriptName}" conflicts between capabilities "${preflightScripts[scriptName]}" and "${capName}".`);
+                process.exitCode = 1;
+                return;
+            }
+            preflightScripts[scriptName] = capName;
+        }
+    }
+    // --- Create directory ---
+    fs.mkdirSync(targetDir, { recursive: true });
+    // --- Collect hooks from capabilities ---
+    const hookEntries = [];
+    for (const capName of capabilityNames) {
+        const cap = (0, capability_1.getCapability)(capName);
+        if (cap?.hooks) {
+            hookEntries.push({ name: capName, hooks: cap.hooks });
+        }
+    }
+    const hookVars = (0, scaffold_1.collectHooks)(hookEntries);
+    // --- Scaffold kernel ---
+    const variables = {
+        projectName: name,
+        port: profile.kernel.port,
+        scripts: profile.kernel.scripts,
+        nodeVersion: profile.kernel.nodeVersion ?? '>=18.0.0',
+        ...hookVars,
+    };
+    const kernelFiles = (0, scaffold_1.scaffoldKernel)(targetDir, variables);
+    // --- Merge kernel dependencies ---
+    (0, scaffold_1.mergePackageJson)(targetDir, profile.kernel.dependencies, profile.kernel.devDependencies, undefined, { skipBackup: true });
+    // --- Create minimal manifest so capability hash storage can find config.json ---
+    (0, project_1.writeProjectManifest)(targetDir, {
+        name,
+        profile: profileName,
+        boopVersion: '0.1.0',
+        capabilities: [],
+        createdAt: new Date().toISOString(),
+    });
+    // --- Resolve and install capabilities ---
+    const installedCapabilities = [];
+    const allScripts = {};
+    const scriptSources = {};
+    const capabilityFiles = [];
+    const cssCapMap = {};
+    for (const capName of capabilityNames) {
+        const cap = (0, capability_1.getCapability)(capName);
+        if (!cap) {
+            console.error(`Warning: Capability "${capName}" not found, skipping.`);
+            continue;
+        }
+        // Copy capability files (skills, scaffolded files, etc.)
+        const copied = (0, scaffold_1.copyCapabilityFiles)(targetDir, capName);
+        capabilityFiles.push(...copied);
+        // Track CSS partials for annotation
+        for (const f of copied) {
+            if (f.startsWith('styles/') && f.endsWith('.css') && f !== 'styles/styles.css') {
+                cssCapMap[path.basename(f)] = capName;
+            }
+        }
+        // Merge dependencies
+        (0, scaffold_1.mergePackageJson)(targetDir, cap.dependencies, cap.devDependencies, undefined, { skipBackup: true });
+        // Add capability package as semver dependency if specified
+        if (cap.package) {
+            (0, scaffold_1.mergePackageJson)(targetDir, undefined, undefined, {
+                [cap.package]: (0, scaffold_1.getBoopkitVersion)(cap.package),
+            }, { skipBackup: true });
+        }
+        // Collect scripts (conflicts already checked in pre-flight)
+        if (cap.scripts) {
+            for (const [scriptName, scriptDef] of Object.entries(cap.scripts)) {
+                allScripts[scriptName] = scriptDef.cmd;
+                scriptSources[scriptName] = capName;
+            }
+        }
+        installedCapabilities.push(capName);
+    }
+    // --- Inject CSS imports for capability partials ---
+    (0, scaffold_1.injectCssImports)(targetDir, cssCapMap, { skipBackup: true });
+    // --- Merge capability scripts into package.json ---
+    if (Object.keys(allScripts).length > 0) {
+        const pkgPath = path.join(targetDir, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        for (const [scriptName, cmd] of Object.entries(allScripts)) {
+            pkg.scripts[scriptName] = cmd;
+        }
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+    }
+    // --- Copy reference docs from profile ---
+    const boopRoot = (0, config_1.getBoopRoot)();
+    const profileDir = path.join(boopRoot, 'profiles', profileName);
+    const profileRefDir = path.join(profileDir, 'reference');
+    if (fs.existsSync(profileRefDir)) {
+        (0, safe_io_1.safeCopyDir)(profileRefDir, path.join(targetDir, 'reference'), { onConflict: 'skip' });
+    }
+    // --- Generate skills index from installed skill files ---
+    (0, scaffold_1.generateSkillsIndex)(targetDir);
+    // --- Build capabilityConfig for capabilities with env vars ---
+    const capabilityConfig = {};
+    const envEntries = [];
+    for (const capName of installedCapabilities) {
+        const cap = (0, capability_1.getCapability)(capName);
+        if (cap?.env && cap.env.length > 0) {
+            const envConfig = {};
+            for (const e of cap.env) {
+                envConfig[e.name] = { required: e.required, set: false };
+                envEntries.push({ name: e.name, description: e.description, default: e.default, capability: capName });
+            }
+            capabilityConfig[capName] = { env: envConfig };
+        }
+    }
+    // --- Generate .env and .env.example ---
+    if (envEntries.length > 0) {
+        (0, env_1.generateEnvFiles)(targetDir, envEntries, name);
+    }
+    // --- Write final manifest, preserving capabilityMeta from hash storage ---
+    const existingManifest = (0, project_1.readProjectManifest)(targetDir);
+    const manifest = {
+        name,
+        profile: profileName,
+        boopVersion: '0.1.0',
+        capabilities: installedCapabilities,
+        ...(Object.keys(capabilityConfig).length > 0 && { capabilityConfig }),
+        ...(existingManifest?.capabilityMeta && { capabilityMeta: existingManifest.capabilityMeta }),
+        createdAt: new Date().toISOString(),
+    };
+    (0, project_1.writeProjectManifest)(targetDir, manifest);
+    // --- Print summary ---
+    console.log(`\nCreated project "${name}" with profile "${profileName}"\n`);
+    const scriptCount = Object.keys(allScripts).length;
+    const parts = [
+        `${kernelFiles.length} kernel files`,
+        `${installedCapabilities.length} capabilities`,
+        `${capabilityFiles.length} capability files`,
+        ...(scriptCount > 0 ? [`${scriptCount} scripts`] : []),
+    ];
+    console.log(`  ${parts.join(' · ')}`);
+    const typeLabels = {
+        application: 'Application',
+        development: 'Development',
+        operations: 'Operations',
+        demo: 'Demo',
+    };
+    const typeOrder = ['application', 'development', 'operations', 'demo'];
+    const grouped = new Map();
+    for (const capName of installedCapabilities) {
+        const cap = (0, capability_1.getCapability)(capName);
+        const key = cap?.type ?? 'other';
+        if (!grouped.has(key))
+            grouped.set(key, []);
+        grouped.get(key).push(capName);
+    }
+    for (const type of [...typeOrder, ...grouped.keys()]) {
+        const caps = grouped.get(type);
+        if (!caps)
+            continue;
+        grouped.delete(type);
+        const label = typeLabels[type] ?? type;
+        console.log(`    ${label}: ${caps.join(', ')}`);
+    }
+    // --- npm install (after summary so output is clear) ---
+    if (shouldInstall) {
+        try {
+            console.log('\nInstalling dependencies...');
+            (0, child_process_1.execSync)('npm install', { cwd: targetDir, stdio: 'inherit' });
+        }
+        catch {
+            console.error('Warning: npm install failed. You can run it manually later.');
+        }
+        // Build CSS if tailwind:build script exists
+        const pkgPath = path.join(targetDir, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (pkg.scripts?.['tailwind:build']) {
+            try {
+                console.log('\nBuilding CSS...');
+                (0, child_process_1.execSync)('npm run tailwind:build', { cwd: targetDir, stdio: 'inherit' });
+            }
+            catch {
+                console.error('Warning: CSS build failed. Run `npm run tailwind:build` manually.');
+            }
+        }
+        // Generate Prisma client if db:generate script exists
+        if (pkg.scripts?.['db:generate']) {
+            try {
+                console.log('\nGenerating Prisma client...');
+                (0, child_process_1.execSync)('npm run db:generate', { cwd: targetDir, stdio: 'inherit' });
+            }
+            catch {
+                console.error('Warning: Prisma generate failed. Run `npm run db:generate` manually.');
+            }
+        }
+    }
+    console.log(`\nNext steps:`);
+    console.log(`  cd ${name}`);
+    if (!shouldInstall) {
+        console.log('  npm install');
+    }
+    console.log('  boop status          ← check what needs configuration');
+    console.log('  npm run dev          ← start development server');
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,6 @@
+export declare function runList(type: string): void;
+/**
+ * Print capabilities grouped by type with install status markers.
+ * Reused by both `boop list capabilities` and `boop add` (no arg).
+ */
+export declare function printGroupedCapabilities(): void;

package/dist/commands/list.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runList = runList;
+exports.printGroupedCapabilities = printGroupedCapabilities;
+const capability_1 = require("../lib/capability");
+const profile_1 = require("../lib/profile");
+const project_1 = require("../lib/project");
+function runList(type) {
+    switch (type) {
+        case 'profiles':
+            listProfilesCommand();
+            break;
+        case 'capabilities':
+            listCapabilitiesCommand();
+            break;
+        default:
+            console.error(`Unknown type: ${type}. Use 'profiles' or 'capabilities'.`);
+            process.exitCode = 1;
+    }
+}
+function listProfilesCommand() {
+    const profiles = (0, profile_1.listProfiles)();
+    if (profiles.length === 0) {
+        console.log('No profiles found.');
+        return;
+    }
+    console.log('Available profiles:\n');
+    const typeLabels = {
+        application: 'Application',
+        development: 'Development',
+        operations: 'Operations',
+        demo: 'Demo',
+    };
+    const typeOrder = ['application', 'development', 'operations', 'demo'];
+    for (const p of profiles) {
+        console.log(`  ${p.name}`);
+        console.log(`    ${p.description}`);
+        console.log(`    runtime: ${p.kernel.runtime} | deploy: ${p.kernel.deploy} | port: ${p.kernel.port}`);
+        const grouped = new Map();
+        for (const capName of p.defaultCapabilities) {
+            const cap = (0, capability_1.getCapability)(capName);
+            const key = cap?.type ?? 'other';
+            if (!grouped.has(key))
+                grouped.set(key, []);
+            grouped.get(key).push(capName);
+        }
+        console.log('    capabilities:');
+        for (const type of [...typeOrder, ...grouped.keys()]) {
+            const caps = grouped.get(type);
+            if (!caps)
+                continue;
+            grouped.delete(type);
+            const label = typeLabels[type] ?? type;
+            console.log(`      ${label}: ${caps.join(', ')}`);
+        }
+        console.log();
+    }
+}
+/**
+ * Print capabilities grouped by type with install status markers.
+ * Reused by both `boop list capabilities` and `boop add` (no arg).
+ */
+function printGroupedCapabilities() {
+    const capabilities = (0, capability_1.listCapabilities)().filter(c => !c.name.startsWith('_'));
+    if (capabilities.length === 0) {
+        console.log('No capabilities found.');
+        return;
+    }
+    const typeLabels = {
+        application: 'Application',
+        development: 'Development',
+        operations: 'Operations',
+        demo: 'Demo',
+    };
+    const typeOrder = ['application', 'development', 'operations', 'demo'];
+    const grouped = new Map();
+    for (const c of capabilities) {
+        const key = c.type ?? 'other';
+        if (!grouped.has(key))
+            grouped.set(key, []);
+        grouped.get(key).push(c);
+    }
+    const manifest = (0, project_1.readProjectManifest)(process.cwd());
+    const installed = new Set(manifest?.capabilities ?? []);
+    console.log('Available capabilities:\n');
+    for (const type of [...typeOrder, ...grouped.keys()]) {
+        const caps = grouped.get(type);
+        if (!caps)
+            continue;
+        grouped.delete(type);
+        const label = typeLabels[type] ?? type;
+        console.log(`  ${label}`);
+        for (const c of caps) {
+            const isInstalled = installed.has(c.name);
+            const mark = isInstalled ? '\x1b[2m\u2713\x1b[0m ' : '\x1b[32m\u25cb\x1b[0m ';
+            const name = isInstalled ? `\x1b[2m${c.name}\x1b[0m` : `\x1b[32m${c.name}\x1b[0m`;
+            const desc = isInstalled ? `\x1b[2m${c.description}\x1b[0m` : c.description;
+            console.log(`    ${mark}${name} \u2014 ${desc}`);
+        }
+        console.log();
+    }
+}
+function listCapabilitiesCommand() {
+    printGroupedCapabilities();
+}

package/dist/commands/loop.d.ts

@@ -0,0 +1,63 @@
+export interface LoopOptions {
+    run?: boolean;
+    prefix?: string;
+    work?: string;
+    flow?: string;
+    max?: string;
+    budget?: string;
+    resumeLimit?: string;
+    poll?: boolean;
+    pollInterval?: string;
+    model?: string;
+    perIssueBranch?: boolean;
+    noBranch?: boolean;
+    features?: boolean;
+    skipPerms?: boolean;
+    bare?: boolean;
+    json?: boolean;
+}
+interface ClaudeRunResult {
+    exitCode: number;
+    limitHit: boolean;
+}
+export interface PlanResult {
+    featureId: string | null;
+    costUsd: number | null;
+}
+export declare function buildPlanningPrompt(workContent: string, flowContent: string, prefix?: string): string;
+export type RunClaudeFn = (prompt: string, opts: {
+    budget: string;
+    model: string;
+    skipPerms: boolean;
+    sessionId: string;
+    resume?: boolean;
+    bare?: boolean;
+}, logFile: string, readableLogFile?: string) => Promise<ClaudeRunResult>;
+export declare function planWork(opts: {
+    workPath: string;
+    flowPath: string;
+    prefix?: string;
+    budget: string;
+    model: string;
+    skipPerms: boolean;
+    bare: boolean;
+    logDir: string;
+    runClaudeFn?: RunClaudeFn;
+    execSyncFn?: (cmd: string, opts: {
+        encoding: string;
+    }) => string;
+}): Promise<PlanResult>;
+export declare function findFallbackFeature(features: Array<{
+    id?: string;
+    created_at?: string;
+    title?: string;
+}>, workContent: string, workPath: string): string | null;
+export declare function extractFeatureId(text: string): string | null;
+export declare function isUsageLimitText(text: string): boolean;
+export declare function isStandaloneUsageLimitMessage(text: string): boolean;
+export declare function isIssueInScope(issue: {
+    id: string;
+    parent?: string;
+}, prefix: string, getParentById: (id: string) => string | null): boolean;
+export declare function runLoop(options: LoopOptions): Promise<void>;
+export {};