@boopkit/cli 0.1.0

package/dist/lib/project.test.js

@@ -0,0 +1,118 @@
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const project_1 = require("../lib/project");
+describe('readProjectManifest', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'boop-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('reads a valid .boop.json manifest', () => {
+        const manifest = {
+            name: 'my-saas',
+            profile: 'web-app',
+            boopVersion: '0.1.0',
+            capabilities: ['database', 'api', 'web'],
+            createdAt: '2026-03-19T00:00:00Z',
+        };
+        fs.writeFileSync(path.join(tmpDir, '.boop.json'), JSON.stringify(manifest));
+        const result = (0, project_1.readProjectManifest)(tmpDir);
+        expect(result).toEqual(manifest);
+    });
+    it('returns null when .boop.json does not exist', () => {
+        const result = (0, project_1.readProjectManifest)(tmpDir);
+        expect(result).toBeNull();
+    });
+    it('throws on invalid JSON', () => {
+        fs.writeFileSync(path.join(tmpDir, '.boop.json'), '{ not valid json }');
+        expect(() => (0, project_1.readProjectManifest)(tmpDir)).toThrow();
+    });
+});
+describe('writeProjectManifest', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'boop-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('writes a manifest that can be read back', () => {
+        const manifest = {
+            name: 'round-trip',
+            profile: 'web-app',
+            boopVersion: '0.1.0',
+            capabilities: ['api', 'database'],
+            createdAt: '2026-03-20T00:00:00Z',
+        };
+        (0, project_1.writeProjectManifest)(tmpDir, manifest);
+        const result = (0, project_1.readProjectManifest)(tmpDir);
+        expect(result).toEqual(manifest);
+    });
+    it('writes formatted JSON with trailing newline', () => {
+        const manifest = {
+            name: 'test',
+            profile: 'web-app',
+            boopVersion: '0.1.0',
+            capabilities: [],
+            createdAt: '2026-03-20T00:00:00Z',
+        };
+        (0, project_1.writeProjectManifest)(tmpDir, manifest);
+        const raw = fs.readFileSync(path.join(tmpDir, '.boop.json'), 'utf-8');
+        expect(raw).toContain('\n'); // formatted, not single-line
+        expect(raw.endsWith('\n')).toBe(true);
+    });
+});
+describe('isBoopProject', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'boop-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns true when .boop.json exists', () => {
+        fs.writeFileSync(path.join(tmpDir, '.boop.json'), '{}');
+        expect((0, project_1.isBoopProject)(tmpDir)).toBe(true);
+    });
+    it('returns false when .boop.json does not exist', () => {
+        expect((0, project_1.isBoopProject)(tmpDir)).toBe(false);
+    });
+});

package/dist/lib/rewire.d.ts

@@ -0,0 +1,19 @@
+import { CapabilityHook } from './config';
+export interface RewireOptions {
+    needsEnv?: boolean;
+}
+export interface RewireResult {
+    missingMarkers: string[];
+}
+/**
+ * Rewire an existing server.ts by finding `// @boopkit:<phase>` markers
+ * and inserting capability hook code above them.
+ *
+ * - Inserted code gets `@boopkit/cap-<name>` annotations
+ * - Markers are preserved after insertion for future `boop add` calls
+ * - Missing markers produce a warning to stderr with manual insertion guidance
+ * - Already-inserted code (same capability annotation) is skipped to prevent duplicates
+ */
+export declare function rewireServerFile(serverPath: string, capabilityName: string, hooks: CapabilityHook[], options?: RewireOptions & {
+    skipBackup?: boolean;
+}): RewireResult;

package/dist/lib/rewire.js

@@ -0,0 +1,222 @@
+"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.rewireServerFile = rewireServerFile;
+const fs = __importStar(require("fs"));
+const safe_io_1 = require("./safe-io");
+/**
+ * Rewire an existing server.ts by finding `// @boopkit:<phase>` markers
+ * and inserting capability hook code above them.
+ *
+ * - Inserted code gets `@boopkit/cap-<name>` annotations
+ * - Markers are preserved after insertion for future `boop add` calls
+ * - Missing markers produce a warning to stderr with manual insertion guidance
+ * - Already-inserted code (same capability annotation) is skipped to prevent duplicates
+ */
+function rewireServerFile(serverPath, capabilityName, hooks, options = {}) {
+    const content = fs.readFileSync(serverPath, 'utf-8');
+    const capAnnotation = `@boopkit/cap-${capabilityName}`;
+    const alreadyPresent = content.includes(capAnnotation);
+    // Skip if this capability's hooks are already wired
+    if (alreadyPresent) {
+        return { missingMarkers: [] };
+    }
+    const missingMarkers = [];
+    let result = content;
+    // Group hooks by phase
+    const byPhase = new Map();
+    for (const hook of hooks) {
+        if (!byPhase.has(hook.phase)) {
+            byPhase.set(hook.phase, []);
+        }
+        byPhase.get(hook.phase).push(hook);
+    }
+    // Handle env import
+    if (options.needsEnv && !result.includes("dotenv/config")) {
+        const envMarker = '// @boopkit:env';
+        if (result.includes(envMarker)) {
+            result = insertAboveMarker(result, envMarker, "import 'dotenv/config';");
+        }
+        else {
+            missingMarkers.push('env');
+            reportMissing('env', "import 'dotenv/config';");
+        }
+    }
+    // Process each phase
+    for (const [phase, phaseHooks] of byPhase) {
+        const marker = `// @boopkit:${phase}`;
+        if (!result.includes(marker)) {
+            missingMarkers.push(phase);
+            const code = renderHooksForPhase(phase, capabilityName, phaseHooks);
+            reportMissing(phase, code);
+            continue;
+        }
+        if (phase === 'imports') {
+            const code = renderHooksForPhase(phase, capabilityName, phaseHooks);
+            result = insertAboveMarker(result, marker, code);
+        }
+        else {
+            result = insertOrderedHooks(result, marker, capabilityName, phaseHooks);
+        }
+    }
+    if (!options.skipBackup)
+        (0, safe_io_1.createBackup)(serverPath);
+    fs.writeFileSync(serverPath, result, 'utf-8');
+    return { missingMarkers };
+}
+function renderHooksForPhase(phase, capName, hooks) {
+    if (phase === 'imports') {
+        return renderImportHooks(capName, hooks);
+    }
+    return renderOrderedHooks(capName, hooks);
+}
+function renderImportHooks(capName, hooks) {
+    // Group all imports under a single annotation comment
+    const lines = [];
+    const descriptions = hooks.map(h => h.description).filter(Boolean);
+    const desc = descriptions.length > 0 ? ` ${descriptions[0]}` : '';
+    lines.push(`/** @boopkit/cap-${capName}${desc} */`);
+    for (const hook of hooks) {
+        lines.push(hook.code);
+    }
+    return lines.join('\n');
+}
+function renderOrderedHooks(capName, hooks) {
+    return hooks.map(hook => {
+        const order = hook.order ?? 50;
+        const desc = hook.description ? ` ${hook.description}` : '';
+        const comment = `/** @boopkit/cap-${capName} [${order}]${desc} */`;
+        return `${comment}\n${hook.code}`;
+    }).join('\n\n');
+}
+/**
+ * Insert code above a marker line, preserving the marker's indentation.
+ */
+function insertAboveMarker(content, marker, code) {
+    const lines = content.split('\n');
+    const markerIdx = lines.findIndex(l => l.trim() === marker);
+    if (markerIdx === -1)
+        return content;
+    const markerLine = lines[markerIdx];
+    const indent = markerLine.match(/^(\s*)/)?.[1] ?? '';
+    // Indent each line of the inserted code to match marker indentation
+    const indentedCode = code.split('\n').map(l => l.length > 0 ? indent + l : l).join('\n');
+    lines.splice(markerIdx, 0, indentedCode, '');
+    return lines.join('\n');
+}
+/**
+ * Parse the order number from a hook annotation comment like:
+ *   /** @boopkit/cap-name [42] description *​/
+ */
+function parseOrderFromAnnotation(line) {
+    const match = line.match(/\[(\d+)\]/);
+    return match ? parseInt(match[1], 10) : 50;
+}
+/**
+ * Parse existing hook blocks above a marker line.
+ * Returns the blocks with their order numbers and the line index where the hook zone starts.
+ */
+function parseHookZone(lines, markerIdx) {
+    const blocks = [];
+    let i = markerIdx - 1;
+    let zoneStart = markerIdx;
+    // Skip blank lines above the marker
+    while (i >= 0 && lines[i].trim() === '')
+        i--;
+    while (i >= 0) {
+        const blockEnd = i;
+        let annotationIdx = i;
+        let foundAnnotation = false;
+        // Scan backwards from current line to find the annotation comment
+        while (annotationIdx >= 0) {
+            if (lines[annotationIdx].trim().startsWith('/**') && lines[annotationIdx].includes('@boopkit/cap-')) {
+                foundAnnotation = true;
+                break;
+            }
+            if (lines[annotationIdx].trim() === '')
+                break;
+            annotationIdx--;
+        }
+        if (!foundAnnotation)
+            break;
+        const blockLines = lines.slice(annotationIdx, blockEnd + 1);
+        const order = parseOrderFromAnnotation(lines[annotationIdx]);
+        blocks.unshift({ order, text: blockLines.join('\n') });
+        zoneStart = annotationIdx;
+        i = annotationIdx - 1;
+        // Skip blank lines between blocks
+        while (i >= 0 && lines[i].trim() === '')
+            i--;
+    }
+    return { blocks, zoneStart };
+}
+/**
+ * Insert hooks into a phase zone in order-sorted position.
+ * Parses existing hook blocks above the marker, merges with new hooks,
+ * sorts by order, and rewrites the zone.
+ */
+function insertOrderedHooks(content, marker, capName, hooks) {
+    const lines = content.split('\n');
+    const markerIdx = lines.findIndex(l => l.trim() === marker);
+    if (markerIdx === -1)
+        return content;
+    const markerLine = lines[markerIdx];
+    const indent = markerLine.match(/^(\s*)/)?.[1] ?? '';
+    // Parse existing hook blocks above the marker
+    const { blocks: existingBlocks, zoneStart } = parseHookZone(lines, markerIdx);
+    // Create new hook blocks with proper indentation
+    const newBlocks = hooks.map(hook => {
+        const order = hook.order ?? 50;
+        const desc = hook.description ? ` ${hook.description}` : '';
+        const comment = `${indent}/** @boopkit/cap-${capName} [${order}]${desc} */`;
+        const code = hook.code.split('\n').map(l => l.length > 0 ? indent + l : l).join('\n');
+        return { order, text: `${comment}\n${code}` };
+    });
+    // Merge and sort by order
+    const allBlocks = [...existingBlocks, ...newBlocks];
+    allBlocks.sort((a, b) => a.order - b.order);
+    // Build the replacement for the zone
+    const zoneContent = allBlocks.map(b => b.text).join('\n\n');
+    // Reconstruct: everything before zone + sorted blocks + blank line + marker + rest
+    const before = lines.slice(0, zoneStart);
+    const after = lines.slice(markerIdx);
+    return [...before, zoneContent, '', ...after].join('\n');
+}
+function reportMissing(phase, code) {
+    const marker = `// @boopkit:${phase}`;
+    process.stderr.write(`Warning: marker "${marker}" not found in server.ts.\n` +
+        `Add the marker and insert the following code above it:\n` +
+        `${code}\n\n`);
+}

package/dist/lib/safe-io.d.ts

@@ -0,0 +1,66 @@
+export type ConflictStrategy = 'skip' | 'backup' | 'overwrite' | 'abort';
+export interface SafeWriteOptions {
+    /** What to do when the target file already exists. Default: 'abort'. */
+    onConflict?: ConflictStrategy;
+}
+export interface SafeCopyOptions {
+    /** What to do when the target file already exists. Default: 'skip'. */
+    onConflict?: ConflictStrategy;
+}
+export interface SafeWriteResult {
+    /** Whether the write actually happened. */
+    written: boolean;
+    /** Path to backup file if one was created. */
+    backupPath?: string;
+    /** If skipped, the reason why. */
+    skipped?: string;
+}
+export interface SafeCopyResult {
+    /** Whether the copy actually happened. */
+    copied: boolean;
+    /** Path to backup file if one was created. */
+    backupPath?: string;
+    /** If skipped, the reason why. */
+    skipped?: string;
+}
+/**
+ * Write a file with conflict-awareness.
+ *
+ * - 'skip': don't write if file exists; return skipped result
+ * - 'backup': create .bak before overwriting
+ * - 'overwrite': write unconditionally (current behavior)
+ * - 'abort': throw if file exists
+ *
+ * If the file does not exist, writes unconditionally regardless of strategy.
+ */
+export declare function safeWriteFile(filePath: string, content: string, options?: SafeWriteOptions): SafeWriteResult;
+/**
+ * Copy a file with conflict-awareness.
+ *
+ * - 'skip': don't copy if dest exists
+ * - 'backup': create .bak of dest before overwriting
+ * - 'overwrite': copy unconditionally
+ * - 'abort': throw if dest exists
+ */
+export declare function safeCopyFile(srcPath: string, destPath: string, options?: SafeCopyOptions): SafeCopyResult;
+export interface SafeCopyDirResult {
+    copied: string[];
+    skipped: string[];
+    backups: string[];
+}
+/**
+ * Recursively copy a directory with per-file conflict handling.
+ */
+export declare function safeCopyDir(srcDir: string, destDir: string, options?: SafeCopyOptions): SafeCopyDirResult;
+/**
+ * Create a .bak backup of a file. Returns the backup path.
+ * Overwrites any existing .bak for the same file.
+ */
+export declare function createBackup(filePath: string): string;
+/**
+ * Error thrown when a file operation encounters an unexpected existing file.
+ */
+export declare class FileConflictError extends Error {
+    readonly filePath: string;
+    constructor(filePath: string, message: string);
+}

package/dist/lib/safe-io.js

@@ -0,0 +1,167 @@
+"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.FileConflictError = void 0;
+exports.safeWriteFile = safeWriteFile;
+exports.safeCopyFile = safeCopyFile;
+exports.safeCopyDir = safeCopyDir;
+exports.createBackup = createBackup;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Write a file with conflict-awareness.
+ *
+ * - 'skip': don't write if file exists; return skipped result
+ * - 'backup': create .bak before overwriting
+ * - 'overwrite': write unconditionally (current behavior)
+ * - 'abort': throw if file exists
+ *
+ * If the file does not exist, writes unconditionally regardless of strategy.
+ */
+function safeWriteFile(filePath, content, options = {}) {
+    const strategy = options.onConflict ?? 'abort';
+    const exists = fs.existsSync(filePath);
+    if (exists) {
+        switch (strategy) {
+            case 'abort':
+                throw new FileConflictError(filePath, 'File already exists');
+            case 'skip':
+                return { written: false, skipped: `File already exists: ${filePath}` };
+            case 'backup': {
+                const backupPath = createBackup(filePath);
+                fs.writeFileSync(filePath, content, 'utf-8');
+                return { written: true, backupPath };
+            }
+            case 'overwrite':
+                fs.writeFileSync(filePath, content, 'utf-8');
+                return { written: true };
+        }
+    }
+    // File doesn't exist — ensure directory exists and write
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return { written: true };
+}
+/**
+ * Copy a file with conflict-awareness.
+ *
+ * - 'skip': don't copy if dest exists
+ * - 'backup': create .bak of dest before overwriting
+ * - 'overwrite': copy unconditionally
+ * - 'abort': throw if dest exists
+ */
+function safeCopyFile(srcPath, destPath, options = {}) {
+    const strategy = options.onConflict ?? 'skip';
+    const exists = fs.existsSync(destPath);
+    if (exists) {
+        switch (strategy) {
+            case 'abort':
+                throw new FileConflictError(destPath, 'File already exists');
+            case 'skip':
+                return { copied: false, skipped: `File already exists: ${destPath}` };
+            case 'backup': {
+                const backupPath = createBackup(destPath);
+                fs.copyFileSync(srcPath, destPath);
+                return { copied: true, backupPath };
+            }
+            case 'overwrite':
+                fs.copyFileSync(srcPath, destPath);
+                return { copied: true };
+        }
+    }
+    // Dest doesn't exist — ensure directory exists and copy
+    const dir = path.dirname(destPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.copyFileSync(srcPath, destPath);
+    return { copied: true };
+}
+/**
+ * Recursively copy a directory with per-file conflict handling.
+ */
+function safeCopyDir(srcDir, destDir, options = {}) {
+    const result = { copied: [], skipped: [], backups: [] };
+    function processDir(src, dest) {
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                processDir(srcPath, destPath);
+            }
+            else {
+                const copyResult = safeCopyFile(srcPath, destPath, options);
+                if (copyResult.copied) {
+                    result.copied.push(destPath);
+                    if (copyResult.backupPath) {
+                        result.backups.push(copyResult.backupPath);
+                    }
+                }
+                else if (copyResult.skipped) {
+                    result.skipped.push(destPath);
+                }
+            }
+        }
+    }
+    processDir(srcDir, destDir);
+    return result;
+}
+/**
+ * Create a .bak backup of a file. Returns the backup path.
+ * Overwrites any existing .bak for the same file.
+ */
+function createBackup(filePath) {
+    const backupPath = filePath + '.bak';
+    fs.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+/**
+ * Error thrown when a file operation encounters an unexpected existing file.
+ */
+class FileConflictError extends Error {
+    constructor(filePath, message) {
+        super(`${message}: ${filePath}`);
+        this.name = 'FileConflictError';
+        this.filePath = filePath;
+    }
+}
+exports.FileConflictError = FileConflictError;

package/dist/lib/scaffold.d.ts

@@ -0,0 +1,87 @@
+import { CapabilityHook } from './config';
+export interface TemplateVariables {
+    projectName: string;
+    port: number;
+    scripts: Record<string, string>;
+    nodeVersion: string;
+    hookImports?: string;
+    hookInit?: string;
+    hookPreRoutes?: string;
+    hookPostRoutes?: string;
+}
+/**
+ * Render a single Handlebars template string with variables.
+ *
+ * TRUST BOUNDARY: noEscape is intentional — template variables (hook code,
+ * import statements, etc.) contain raw code that must not be HTML-escaped.
+ * This is safe as long as all capability manifests are first-party/trusted.
+ * If third-party capabilities are ever supported, hook code from manifests
+ * must be sanitized or sandboxed before reaching this function. See also
+ * collectHooks(), which passes manifest hook code through as-is.
+ */
+export declare function renderTemplate(templateContent: string, variables: TemplateVariables): string;
+/**
+ * Copy and render all kernel templates into a target directory.
+ * Creates directories as needed. Does not overwrite existing files
+ * unless overwrite is true.
+ */
+export declare function scaffoldKernel(targetDir: string, variables: TemplateVariables, overwrite?: boolean): string[];
+/**
+ * Compute SHA-256 hash of a file's content.
+ */
+export declare function hashFile(filePath: string): string;
+/**
+ * Copy capability-specific files into a target project directory.
+ * Tries package resolution first (scaffold/ and skills/ dirs), falls back to source tree.
+ * Returns list of copied file paths relative to targetDir, and file hashes.
+ */
+export declare function copyCapabilityFiles(targetDir: string, capabilityName: string): string[];
+/**
+ * Merge dependencies into an existing package.json.
+ * Does not overwrite existing dependency versions.
+ */
+/**
+ * Parse a dependency string like "express" or "@prisma/client@^6" into name + version.
+ */
+/**
+ * Read the version from a @boopkit/ package's package.json and return ^version.
+ * Falls back to '*' if the package.json cannot be read.
+ */
+export declare function getBoopkitVersion(packageName: string): string;
+export declare function mergePackageJson(targetDir: string, dependencies?: string[], devDependencies?: string[], packages?: Record<string, string>, options?: {
+    skipBackup?: boolean;
+}): void;
+export interface HookVariables {
+    hookImports: string;
+    hookInit: string;
+    hookPreRoutes: string;
+    hookPostRoutes: string;
+}
+/**
+ * Scan the styles/ directory for CSS partials and inject @import lines
+ * into styles/styles.css after the last existing @import line.
+ */
+export declare function injectCssImports(targetDir: string, cssCapMap?: Record<string, string>, options?: {
+    skipBackup?: boolean;
+}): void;
+interface CapabilityHookEntry {
+    name: string;
+    hooks: CapabilityHook[];
+}
+/**
+ * Collect hooks from installed capabilities, group by phase, sort by order,
+ * and render into strings suitable for injection into server.ts.hbs.
+ *
+ * TRUST BOUNDARY: Hook code from capability manifests is injected verbatim
+ * into the generated server file — no escaping, validation, or sandboxing.
+ * This is safe while all capabilities are first-party. Before supporting
+ * third-party capabilities, hook code must be validated or sandboxed to
+ * prevent arbitrary code injection into scaffolded projects.
+ */
+export declare function collectHooks(capabilities: CapabilityHookEntry[]): HookVariables;
+/**
+ * Generate skills/index.md from the .skill.md files present in the project.
+ * Overwrites any existing index.md.
+ */
+export declare function generateSkillsIndex(targetDir: string): void;
+export {};