@boopkit/cli 0.1.0

package/dist/lib/preflight.js

@@ -0,0 +1,402 @@
+"use strict";
+/**
+ * Pre-flight planning for `boop add`.
+ *
+ * Reads all inputs, validates everything, and produces a manifest of tasks
+ * to execute — without writing a single file.
+ */
+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.PreflightError = void 0;
+exports.planAdd = planAdd;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const capability_1 = require("./capability");
+const project_1 = require("./project");
+class PreflightError extends Error {
+    constructor(message, checks) {
+        super(message);
+        this.name = 'PreflightError';
+        this.checks = checks;
+    }
+}
+exports.PreflightError = PreflightError;
+/**
+ * Plan a `boop add` operation. Reads filesystem, validates everything,
+ * and produces a manifest. Writes nothing.
+ *
+ * Throws PreflightError if any check fails.
+ */
+function planAdd(targetDir, capabilityName) {
+    const checks = [];
+    const tasks = [];
+    const warnings = [];
+    const boopRoot = (0, config_1.getBoopRoot)();
+    // --- Pre-flight checks ---
+    // 1. Validate project
+    const projectManifest = (0, project_1.readProjectManifest)(targetDir);
+    if (!projectManifest) {
+        checks.push({ name: 'project-exists', passed: false, message: 'Not a boop project (no .boop/config.json)' });
+        throw new PreflightError('Pre-flight failed', checks);
+    }
+    checks.push({ name: 'project-exists', passed: true });
+    // 2. Resolve capability
+    const cap = (0, capability_1.getCapability)(capabilityName);
+    if (!cap) {
+        checks.push({ name: 'capability-exists', passed: false, message: `Capability "${capabilityName}" not found` });
+        throw new PreflightError('Pre-flight failed', checks);
+    }
+    checks.push({ name: 'capability-exists', passed: true });
+    // 3. Not already installed
+    if (projectManifest.capabilities.includes(capabilityName)) {
+        checks.push({ name: 'not-already-installed', passed: false, message: `Capability "${capabilityName}" is already installed` });
+        throw new PreflightError('Pre-flight failed', checks);
+    }
+    checks.push({ name: 'not-already-installed', passed: true });
+    // 4. Verify required capabilities are installed
+    if (cap.requires && cap.requires.length > 0) {
+        const missing = cap.requires.filter(r => !projectManifest.capabilities.includes(r));
+        if (missing.length > 0) {
+            checks.push({
+                name: 'requires-satisfied',
+                passed: false,
+                message: `Missing required capabilities: ${missing.join(', ')}. Install them first with: ${missing.map(m => `boop add ${m}`).join(', then ')}`,
+            });
+            throw new PreflightError('Pre-flight failed', checks);
+        }
+        checks.push({ name: 'requires-satisfied', passed: true });
+    }
+    // 5. Enumerate files that would be copied — check for conflicts
+    // Resolve from package (scaffold/ and skills/) or source tree (files/ and skills/)
+    const pkgDir = (0, capability_1.getPackageDir)(capabilityName);
+    const pkgJsonPath = pkgDir ? path.join(pkgDir, 'package.json') : null;
+    const pkgJson = pkgJsonPath && fs.existsSync(pkgJsonPath)
+        ? JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'))
+        : null;
+    const boopkit = pkgJson?.boopkit;
+    const capDir = boopkit
+        ? pkgDir
+        : path.join(boopRoot, 'capabilities', capabilityName);
+    const filesToCopy = [];
+    const fileConflicts = [];
+    // Skills files
+    const skillsDir = boopkit?.skillsDir
+        ? path.join(capDir, boopkit.skillsDir)
+        : path.join(capDir, 'skills');
+    if (fs.existsSync(skillsDir)) {
+        for (const entry of fs.readdirSync(skillsDir)) {
+            const destPath = path.join(targetDir, 'skills', entry);
+            const relPath = path.join('skills', entry);
+            filesToCopy.push(relPath);
+            if (fs.existsSync(destPath)) {
+                fileConflicts.push(relPath);
+            }
+        }
+    }
+    // Capability files from scaffold/ (package) or files/ (source tree)
+    if (cap.files) {
+        const filesDir = boopkit?.scaffoldDir
+            ? path.join(capDir, boopkit.scaffoldDir)
+            : path.join(capDir, 'files');
+        if (fs.existsSync(filesDir)) {
+            enumerateDir(filesDir, targetDir, filesToCopy, fileConflicts);
+        }
+    }
+    // File conflicts are warnings (skip behavior), not failures
+    if (fileConflicts.length > 0) {
+        checks.push({
+            name: 'no-file-conflicts',
+            passed: true,
+            message: `${fileConflicts.length} existing file(s) will be skipped: ${fileConflicts.join(', ')}`,
+        });
+    }
+    else {
+        checks.push({ name: 'no-file-conflicts', passed: true });
+    }
+    // 5. Validate hook markers exist in app.ts or server.ts (if capability has hooks)
+    if (cap.hooks && cap.hooks.length > 0) {
+        const appPath = path.join(targetDir, 'src', 'app.ts');
+        const serverPath = path.join(targetDir, 'src', 'server.ts');
+        // New structure uses app.ts; legacy uses server.ts
+        const hookFile = fs.existsSync(appPath) ? appPath : serverPath;
+        const hookFileName = fs.existsSync(appPath) ? 'app.ts' : 'server.ts';
+        if (fs.existsSync(hookFile)) {
+            const content = fs.readFileSync(hookFile, 'utf-8');
+            const phases = new Set(cap.hooks.map(h => h.phase));
+            const missingMarkers = [];
+            for (const phase of phases) {
+                const marker = `// @boopkit:${phase}`;
+                if (!content.includes(marker)) {
+                    missingMarkers.push(phase);
+                }
+            }
+            if (missingMarkers.length > 0) {
+                checks.push({
+                    name: 'has-hook-markers',
+                    passed: false,
+                    message: `Missing markers in ${hookFileName}: ${missingMarkers.join(', ')}`,
+                });
+            }
+            else {
+                checks.push({ name: 'has-hook-markers', passed: true });
+            }
+            // Check if already wired (idempotency)
+            const capAnnotation = `@boopkit/cap-${capabilityName}`;
+            if (content.includes(capAnnotation)) {
+                checks.push({
+                    name: 'hooks-not-duplicate',
+                    passed: true,
+                    message: `Hooks for ${capabilityName} already present in ${hookFileName} — will skip injection`,
+                });
+            }
+        }
+        else {
+            checks.push({
+                name: 'has-hook-markers',
+                passed: false,
+                message: 'Neither app.ts nor server.ts found — hooks cannot be injected',
+            });
+        }
+    }
+    // 6. Check for script conflicts
+    if (cap.scripts) {
+        const pkgPath = path.join(targetDir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const existingScripts = pkg.scripts || {};
+            const conflicts = [];
+            for (const scriptName of Object.keys(cap.scripts)) {
+                if (scriptName in existingScripts) {
+                    conflicts.push(scriptName);
+                }
+            }
+            if (conflicts.length > 0) {
+                checks.push({
+                    name: 'script-conflicts',
+                    passed: true,
+                    message: `Existing scripts will be preserved: ${conflicts.join(', ')}`,
+                });
+            }
+            else {
+                checks.push({ name: 'script-conflicts', passed: true });
+            }
+        }
+    }
+    // --- Abort if any check failed ---
+    const failedChecks = checks.filter(c => !c.passed);
+    if (failedChecks.length > 0) {
+        throw new PreflightError(`Pre-flight failed: ${failedChecks.map(c => c.message).join('; ')}`, checks);
+    }
+    // --- Build task manifest ---
+    // Task: copy files
+    if (filesToCopy.length > 0) {
+        tasks.push({
+            op: 'copy-files',
+            source: capDir,
+            target: targetDir,
+            detail: `Copy ${filesToCopy.length} file(s) from ${capabilityName}`,
+            status: 'pending',
+            data: { files: filesToCopy, conflicts: fileConflicts },
+        });
+    }
+    // Task: merge dependencies
+    if (cap.dependencies?.length || cap.devDependencies?.length) {
+        tasks.push({
+            op: 'merge-deps',
+            source: capabilityName,
+            target: path.join(targetDir, 'package.json'),
+            detail: `Merge ${[...(cap.dependencies || []), ...(cap.devDependencies || [])].join(', ')}`,
+            status: 'pending',
+            data: { dependencies: cap.dependencies, devDependencies: cap.devDependencies },
+        });
+    }
+    // Task: merge scripts
+    if (cap.scripts && Object.keys(cap.scripts).length > 0) {
+        tasks.push({
+            op: 'merge-scripts',
+            source: capabilityName,
+            target: path.join(targetDir, 'package.json'),
+            detail: `Add scripts: ${Object.keys(cap.scripts).join(', ')}`,
+            status: 'pending',
+            data: { scripts: cap.scripts },
+        });
+    }
+    // Task: link package
+    if (cap.package) {
+        const pkgName = cap.package.replace(/^@boopkit\//, '');
+        const isAdopted = projectManifest.adopted?.includes(pkgName);
+        if (isAdopted) {
+            warnings.push(`Skipping package link for ${cap.package} — package is adopted (source already in project)`);
+        }
+        else {
+            tasks.push({
+                op: 'link-package',
+                source: path.join(boopRoot, 'packages', pkgName),
+                target: path.join(targetDir, 'package.json'),
+                detail: `Add ${cap.package} as semver dependency`,
+                status: 'pending',
+                data: { packageName: cap.package },
+            });
+        }
+    }
+    // Task: set env vars
+    const hasEnv = cap.env && cap.env.length > 0;
+    if (hasEnv) {
+        tasks.push({
+            op: 'set-env',
+            source: capabilityName,
+            target: path.join(targetDir, '.env'),
+            detail: `Set env vars: ${cap.env.map(e => e.name).join(', ')}`,
+            status: 'pending',
+            data: {
+                entries: cap.env.map(e => ({
+                    name: e.name,
+                    description: e.description,
+                    default: e.default,
+                    capability: capabilityName,
+                })),
+                projectName: projectManifest.name,
+            },
+        });
+        // Also need dotenv dependency
+        tasks.push({
+            op: 'merge-deps',
+            source: 'dotenv',
+            target: path.join(targetDir, 'package.json'),
+            detail: 'Add dotenv dependency (required for env vars)',
+            status: 'pending',
+            data: { dependencies: ['dotenv@^16'] },
+        });
+    }
+    // Task: inject hooks
+    if (cap.hooks && cap.hooks.length > 0) {
+        const hasAppTs = fs.existsSync(path.join(targetDir, 'src', 'app.ts'));
+        tasks.push({
+            op: 'inject-hook',
+            source: capabilityName,
+            target: path.join(targetDir, 'src', hasAppTs ? 'app.ts' : 'server.ts'),
+            detail: `Inject ${cap.hooks.length} hook(s) into ${hasAppTs ? 'app.ts/server.ts' : 'server.ts'}`,
+            status: 'pending',
+            data: { hooks: cap.hooks, needsEnv: !!hasEnv },
+        });
+    }
+    // Task: inject CSS
+    const cssFiles = filesToCopy.filter(f => f.startsWith('styles/') && f.endsWith('.css') && f !== 'styles/styles.css');
+    if (cssFiles.length > 0) {
+        const cssCapMap = {};
+        for (const f of cssFiles) {
+            cssCapMap[path.basename(f)] = capabilityName;
+        }
+        tasks.push({
+            op: 'inject-css',
+            source: capabilityName,
+            target: path.join(targetDir, 'styles', 'styles.css'),
+            detail: `Inject CSS imports for ${cssFiles.join(', ')}`,
+            status: 'pending',
+            data: { cssCapMap },
+        });
+    }
+    // Task: regenerate skills index
+    tasks.push({
+        op: 'generate-skills-index',
+        source: capabilityName,
+        target: path.join(targetDir, 'skills', 'index.md'),
+        detail: 'Regenerate skills/index.md',
+        status: 'pending',
+    });
+    // Task: update manifest
+    tasks.push({
+        op: 'update-manifest',
+        source: capabilityName,
+        target: path.join(targetDir, '.boop', 'config.json'),
+        detail: `Add ${capabilityName} to project manifest`,
+        status: 'pending',
+        data: { hasEnv: !!hasEnv, envVars: cap.env },
+    });
+    // Task: npm install
+    tasks.push({
+        op: 'run-command',
+        target: targetDir,
+        detail: 'npm install',
+        status: 'pending',
+        data: { command: 'npm install' },
+    });
+    // Task: rebuild CSS if we injected styles and the project has tailwind:build
+    const hasInjectCss = tasks.some(t => t.op === 'inject-css');
+    if (hasInjectCss) {
+        const pkgJsonPath = path.join(targetDir, 'package.json');
+        const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        if (pkgJson.scripts?.['tailwind:build']) {
+            tasks.push({
+                op: 'run-command',
+                target: targetDir,
+                detail: 'Rebuild CSS',
+                status: 'pending',
+                data: { command: 'npm run tailwind:build' },
+            });
+        }
+    }
+    const manifest = {
+        capability: capabilityName,
+        targetDir,
+        timestamp: new Date().toISOString(),
+        preflight: { passed: true, checks },
+        tasks,
+    };
+    return { manifest, cap, projectManifest, filesToCopy, warnings };
+}
+/**
+ * Recursively enumerate files in srcDir and check for conflicts in destDir.
+ * Pure read — does not write.
+ */
+function enumerateDir(srcDir, destBase, filesToCopy, fileConflicts, baseDir) {
+    const root = baseDir ?? srcDir;
+    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(srcDir, entry.name);
+        if (entry.isDirectory()) {
+            enumerateDir(srcPath, destBase, filesToCopy, fileConflicts, root);
+        }
+        else {
+            const rel = path.relative(root, srcPath);
+            const destPath = path.join(destBase, rel);
+            filesToCopy.push(rel);
+            if (fs.existsSync(destPath)) {
+                fileConflicts.push(rel);
+            }
+        }
+    }
+}

package/dist/lib/profile.d.ts

@@ -0,0 +1,11 @@
+import { ProfileMetadata } from './config';
+/**
+ * List all profiles by scanning the profiles/ directory.
+ * Returns metadata for each profile that has a valid profile.md.
+ */
+export declare function listProfiles(): ProfileMetadata[];
+/**
+ * Get a single profile's metadata by name.
+ * Returns null if the profile directory or profile.md doesn't exist.
+ */
+export declare function getProfile(name: string): ProfileMetadata | null;

package/dist/lib/profile.js

@@ -0,0 +1,73 @@
+"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.listProfiles = listProfiles;
+exports.getProfile = getProfile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+/**
+ * List all profiles by scanning the profiles/ directory.
+ * Returns metadata for each profile that has a valid profile.md.
+ */
+function listProfiles() {
+    const profilesDir = path.join((0, config_1.getBoopRoot)(), 'profiles');
+    if (!fs.existsSync(profilesDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(profilesDir, { withFileTypes: true });
+    const profiles = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const profile = getProfile(entry.name);
+        if (profile) {
+            profiles.push(profile);
+        }
+    }
+    return profiles;
+}
+/**
+ * Get a single profile's metadata by name.
+ * Returns null if the profile directory or profile.md doesn't exist.
+ */
+function getProfile(name) {
+    const profileMd = path.join((0, config_1.getBoopRoot)(), 'profiles', name, 'profile.md');
+    const parsed = (0, config_1.parseFrontmatter)(profileMd);
+    if (!parsed) {
+        return null;
+    }
+    return parsed.data;
+}

package/dist/lib/project.d.ts

@@ -0,0 +1,36 @@
+export interface CapabilityConfig {
+    env?: Record<string, {
+        required?: string;
+        set: boolean;
+    }>;
+}
+export interface CapabilityMeta {
+    installedAt: string;
+    version?: string;
+    fileHashes: Record<string, string>;
+}
+export interface BoopManifest {
+    name: string;
+    profile: string;
+    boopVersion: string;
+    capabilities: string[];
+    capabilityConfig?: Record<string, CapabilityConfig>;
+    capabilityMeta?: Record<string, CapabilityMeta>;
+    adopted?: string[];
+    createdAt: string;
+}
+/**
+ * Read and parse the .boop/config.json manifest from a directory.
+ * Returns null if the file does not exist.
+ * Throws if the file exists but contains invalid JSON.
+ */
+export declare function readProjectManifest(dir: string): BoopManifest | null;
+/**
+ * Write a .boop/config.json manifest to a directory.
+ * Creates the .boop/ directory if it does not exist.
+ */
+export declare function writeProjectManifest(dir: string, manifest: BoopManifest): void;
+/**
+ * Check if a directory contains a boop project (.boop/config.json exists).
+ */
+export declare function isBoopProject(dir: string): boolean;

package/dist/lib/project.js

@@ -0,0 +1,71 @@
+"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.readProjectManifest = readProjectManifest;
+exports.writeProjectManifest = writeProjectManifest;
+exports.isBoopProject = isBoopProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Read and parse the .boop/config.json manifest from a directory.
+ * Returns null if the file does not exist.
+ * Throws if the file exists but contains invalid JSON.
+ */
+function readProjectManifest(dir) {
+    const manifestPath = path.join(dir, '.boop', 'config.json');
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(manifestPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Write a .boop/config.json manifest to a directory.
+ * Creates the .boop/ directory if it does not exist.
+ */
+function writeProjectManifest(dir, manifest) {
+    const boopDir = path.join(dir, '.boop');
+    if (!fs.existsSync(boopDir)) {
+        fs.mkdirSync(boopDir, { recursive: true });
+    }
+    const manifestPath = path.join(boopDir, 'config.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Check if a directory contains a boop project (.boop/config.json exists).
+ */
+function isBoopProject(dir) {
+    return fs.existsSync(path.join(dir, '.boop', 'config.json'));
+}

package/dist/lib/project.test.d.ts

@@ -0,0 +1 @@
+export {};