@boopkit/cli 0.1.0

package/README.md

@@ -0,0 +1,65 @@
+# boop
+
+CLI tool to scaffold new projects from reusable profiles and capabilities. Get a running web app with proven architecture, conventions, and AI agent skills — in one command.
+
+## Install
+
+```bash
+npm install -g @boopkit/cli@beta
+```
+
+Or use directly:
+
+```bash
+npx @boopkit/cli@beta init myapp
+```
+
+## Quick Start
+
+```bash
+boop init my-app
+cd my-app
+npm run dev
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `boop list profiles` | List available profiles |
+| `boop init <name>` | Create a new project from a profile (default profile is `web-app`) |
+| `boop status` | Show current project status |
+| `boop caps` | List available capabilities (alias for `boop list capabilities`) |
+| `boop add <capability>` | Add a capability to an existing project |
+
+## What You Get
+
+`boop init` scaffolds a full-stack web application with:
+
+- **Express** server with Handlebars views and Tailwind CSS
+- **REST API** with controllers, routes, and middleware
+- **TypeScript** with strict mode and path aliases
+- **Jest** testing setup with TDD workflow
+- **Multi-process architecture** (web, worker, scheduler)
+- **Heroku deployment** via Procfile
+- **AI agent skills** for development, testing, design, and project management
+
+Capabilities are additive. Start simple, add complexity when you need it:
+
+```bash
+boop add users-and-accounts # Adds user authentication and account management features
+boop add email # Adds email sending capabilities with templates 
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+npm run test
+npm run dev -- init test-project   # Run from source
+```
+
+## License
+
+Private

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const status_1 = require("./commands/status");
+const init_1 = require("./commands/init");
+const list_1 = require("./commands/list");
+const add_1 = require("./commands/add");
+const adopt_1 = require("./commands/adopt");
+const update_1 = require("./commands/update");
+const loop_1 = require("./commands/loop");
+const program = new commander_1.Command();
+program
+    .name('boop')
+    .description('Scaffold new projects from boop profiles and capabilities')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Create a new project from a boop profile')
+    .argument('<name>', 'Project name')
+    .option('-p, --profile <profile>', 'Profile to use', 'web-app')
+    .option('--no-install', 'Skip npm install')
+    .action(init_1.runInit);
+program
+    .command('list')
+    .description('List available profiles or capabilities')
+    .argument('<type>', 'What to list: profiles or capabilities')
+    .action(list_1.runList);
+program
+    .command('status')
+    .description('Show current boop project status')
+    .option('--json', 'Output status as JSON')
+    .action(status_1.runStatus);
+program
+    .command('caps')
+    .description('List available capabilities (shortcut for "list capabilities")')
+    .action(() => (0, list_1.runList)('capabilities'));
+program
+    .command('add')
+    .description('Add a capability to an existing boop project')
+    .argument('[capability]', 'Capability to add')
+    .option('--no-install', 'Skip npm install')
+    .option('--json', 'Output structured JSON')
+    .option('--dry-run', 'Show what would be done without making changes')
+    .addHelpText('after', '\nRun `boop list capabilities` to see available options.')
+    .action(add_1.runAdd);
+program
+    .command('update')
+    .description('Update scaffold files from capability packages')
+    .argument('[capability]', 'Capability to update (all if omitted)')
+    .option('--dry-run', 'Show what would change without writing')
+    .option('--force', 'Overwrite locally modified files (creates .bak backup)')
+    .option('--restore', 'Restore locally deleted scaffold files')
+    .option('--prune', 'Remove deprecated scaffold files from disk (creates .bak backup)')
+    .option('--json', 'Output structured JSON')
+    .action(update_1.runUpdate);
+program
+    .command('adopt')
+    .description('Copy package source into the project for full ownership')
+    .argument('[capability]', 'Capability whose package to adopt')
+    .option('--no-install', 'Skip npm install')
+    .option('--json', 'Output structured JSON')
+    .action(adopt_1.runAdopt);
+program
+    .command('loop')
+    .description('Continuously process ready beads issues via Claude Code sessions')
+    .option('--prefix <prefix>', 'Issue ID prefix to filter by')
+    .option('--work <path>', 'Spec file for planning phase')
+    .option('--flow <path>', 'Workflow file for planning phase')
+    .option('--run', 'Actually execute (dry-run by default)')
+    .option('--max <n>', 'Stop after N issues')
+    .option('--budget <amount>', 'Budget cap per issue in USD (default: 5.00)')
+    .option('--resume-limit <n>', 'Max resume attempts per issue (default: 3)')
+    .option('--poll', 'Keep polling when no ready issues found')
+    .option('--poll-interval <seconds>', 'Seconds between polls (default: 60)')
+    .option('--model <model>', 'Claude model to use (default: claude-opus-4-6)')
+    .option('--per-issue-branch', 'Create a separate branch per issue')
+    .option('--no-branch', 'Skip branch creation entirely')
+    .option('--features', 'Include feature-type issues (excluded by default)')
+    .option('--no-skip-perms', 'Do not skip permission prompts')
+    .option('--bare', 'Force API key auth (--bare mode); skips OAuth/keychain, uses ANTHROPIC_API_KEY strictly')
+    .option('--json', 'Output summary as JSON')
+    .addHelpText('after', '\nBy default runs in dry-run mode. Add --run to execute.')
+    .action(loop_1.runLoop);
+program.parse(process.argv);

package/dist/commands/add.d.ts

@@ -0,0 +1,6 @@
+export interface AddOptions {
+    install?: boolean;
+    json?: boolean;
+    dryRun?: boolean;
+}
+export declare function runAdd(capabilityName: string | undefined, options: AddOptions): void;

package/dist/commands/add.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAdd = runAdd;
+const preflight_1 = require("../lib/preflight");
+const execute_1 = require("../lib/execute");
+const interpolate_1 = require("../lib/interpolate");
+const list_1 = require("./list");
+function runAdd(capabilityName, options) {
+    // 0. Validate capability argument is provided
+    if (!capabilityName) {
+        console.error(`\x1b[31mERR\x1b[0m Missing capability argument.\n`);
+        (0, list_1.printGroupedCapabilities)();
+        console.error(`Usage: boop add <capability>`);
+        process.exitCode = 1;
+        return;
+    }
+    const targetDir = process.cwd();
+    // --- Phase 1: Pre-flight (read-only) ---
+    let plan;
+    try {
+        plan = (0, preflight_1.planAdd)(targetDir, capabilityName);
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            console.error(`\x1b[31mERR\x1b[0m .boop/config.json is corrupt (invalid JSON). Delete it and run \`boop init\` to recreate.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (err instanceof preflight_1.PreflightError) {
+            console.error(`\x1b[31mERR\x1b[0m Pre-flight failed:\n`);
+            for (const check of err.checks) {
+                const icon = check.passed ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+                const msg = check.message ? ` — ${check.message}` : '';
+                console.error(`  ${icon} ${check.name}${msg}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        throw err;
+    }
+    const { manifest, cap, projectManifest, filesToCopy, warnings } = plan;
+    // Emit any warnings from pre-flight
+    for (const w of warnings) {
+        console.error(w);
+    }
+    // --- Dry run: print manifest and exit ---
+    if (options.dryRun) {
+        if (options.json) {
+            console.log(JSON.stringify(manifest, null, 2));
+        }
+        else {
+            console.log((0, execute_1.formatManifest)(manifest));
+        }
+        return;
+    }
+    // --- Phase 2: Execute from manifest ---
+    const result = (0, execute_1.executeManifest)(manifest, { install: options.install });
+    // Save audit log
+    try {
+        (0, execute_1.saveManifestLog)(manifest);
+    }
+    catch {
+        // Non-fatal — log dir might not be writable
+    }
+    if (!result.success) {
+        console.error(`\nWarning: ${result.failed.length} task(s) failed during execution.`);
+    }
+    // --- Output ---
+    const fileEntries = filesToCopy.map(f => ({ path: f }));
+    const skillEntries = [];
+    if (cap.skills) {
+        for (const s of cap.skills) {
+            skillEntries.push({ path: `skills/${s}` });
+        }
+    }
+    const hasEnv = cap.env && cap.env.length > 0;
+    const nextSteps = [];
+    if (hasEnv) {
+        for (const e of cap.env) {
+            const example = e.default ? ` (e.g. ${(0, interpolate_1.interpolate)(e.default, { projectName: projectManifest.name })})` : '';
+            nextSteps.push({ text: `Set ${e.name} in .env${example}` });
+        }
+    }
+    if (cap.scripts) {
+        const scriptNames = Object.keys(cap.scripts);
+        if (scriptNames.length > 0) {
+            const first = scriptNames[0];
+            const desc = cap.scripts[first].description;
+            nextSteps.push({ text: `Run \`npm run ${first}\` — ${desc}` });
+        }
+    }
+    nextSteps.push({ text: 'Run `npm run dev` to start developing' });
+    if (options.json) {
+        console.log(JSON.stringify({
+            capability: capabilityName,
+            project: projectManifest.name,
+            files: fileEntries,
+            skills: skillEntries,
+            nextSteps,
+            manifest: {
+                tasks: manifest.tasks.length,
+                completed: result.completed.length,
+                failed: result.failed.length,
+                skipped: result.skipped.length,
+            },
+        }, null, 2));
+        return;
+    }
+    // Determine which files were skipped due to conflicts
+    const conflictCheck = manifest.preflight.checks.find(c => c.name === 'no-file-conflicts');
+    const skippedFiles = new Set();
+    const copyTask = manifest.tasks.find(t => t.op === 'copy-files');
+    if (copyTask?.data) {
+        const conflicts = copyTask.data.conflicts || [];
+        for (const f of conflicts)
+            skippedFiles.add(f);
+    }
+    // Human-readable output
+    console.log(`\n${'─'.repeat(40)}`);
+    console.log(`Added capability "${capabilityName}" to ${projectManifest.name}\n`);
+    if (fileEntries.length > 0) {
+        console.log('Files:');
+        for (const f of fileEntries) {
+            if (skippedFiles.has(f.path)) {
+                console.log(`  ◐ ${f.path} (skipped — already exists)`);
+            }
+            else {
+                console.log(`  ✓ ${f.path}`);
+            }
+        }
+    }
+    if (skillEntries.length > 0) {
+        console.log('\nSkills available:');
+        for (const s of skillEntries) {
+            console.log(`  ${s.path}`);
+        }
+    }
+    // Show capability-specific post-install guidance if available
+    if (cap.postInstall) {
+        const pi = cap.postInstall;
+        const vars = { projectName: projectManifest.name, capabilityName };
+        if (pi.prerequisites && pi.prerequisites.length > 0) {
+            console.log('\nPrerequisites:');
+            for (const prereq of pi.prerequisites) {
+                console.log(`  - ${(0, interpolate_1.interpolate)(prereq, vars)}`);
+            }
+        }
+        if (pi.steps && pi.steps.length > 0) {
+            console.log('\nSetup steps:');
+            for (let i = 0; i < pi.steps.length; i++) {
+                console.log(`  ${i + 1}. ${(0, interpolate_1.interpolate)(pi.steps[i], vars)}`);
+            }
+        }
+        if (pi.verify) {
+            console.log('\nVerify with:');
+            console.log(`  ${(0, interpolate_1.interpolate)(pi.verify, vars)}`);
+        }
+    }
+    else {
+        console.log('\nNext steps:');
+        for (let i = 0; i < nextSteps.length; i++) {
+            console.log(`  ${i + 1}. ${nextSteps[i].text}`);
+        }
+    }
+    if (hasEnv) {
+        console.log(`\nEnvironment variables:`);
+        for (const e of cap.env) {
+            const required = e.required ? ` (required at ${e.required})` : '';
+            console.log(`  ${e.name}${required}`);
+        }
+    }
+    console.log(`\nRun \`boop status\` to check configuration.`);
+}

package/dist/commands/adopt.d.ts

@@ -0,0 +1,5 @@
+export interface AdoptOptions {
+    install?: boolean;
+    json?: boolean;
+}
+export declare function runAdopt(capabilityName: string | undefined, options: AdoptOptions): void;

package/dist/commands/adopt.js

@@ -0,0 +1,286 @@
+"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.runAdopt = runAdopt;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const capability_1 = require("../lib/capability");
+const project_1 = require("../lib/project");
+const safe_io_1 = require("../lib/safe-io");
+function runAdopt(capabilityName, options) {
+    // 0. Validate capability argument
+    if (!capabilityName) {
+        console.error(`\x1b[31mERR\x1b[0m Missing capability argument.\n`);
+        console.error('Usage: boop adopt <capability>');
+        process.exitCode = 1;
+        return;
+    }
+    const targetDir = process.cwd();
+    const shouldInstall = options.install !== false;
+    // 1. Validate we're in a boop project
+    let manifest;
+    try {
+        manifest = (0, project_1.readProjectManifest)(targetDir);
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            console.error('Error: .boop/config.json is corrupt (invalid JSON). Delete it and run `boop init` to recreate.');
+            process.exitCode = 1;
+            return;
+        }
+        throw err;
+    }
+    if (!manifest) {
+        console.error('Not a boop project (no .boop/config.json found). Run `boop init` to create one.');
+        process.exitCode = 1;
+        return;
+    }
+    // 2. Validate capability is installed
+    if (!manifest.capabilities.includes(capabilityName)) {
+        console.error(`Error: Capability "${capabilityName}" is not installed. Run \`boop add ${capabilityName}\` first.`);
+        process.exitCode = 1;
+        return;
+    }
+    // 3. Resolve capability and verify it has a package
+    const cap = (0, capability_1.getCapability)(capabilityName);
+    if (!cap) {
+        console.error(`Error: Capability "${capabilityName}" not found.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!cap.package) {
+        console.error(`Error: Capability "${capabilityName}" has no package to adopt.`);
+        process.exitCode = 1;
+        return;
+    }
+    const pkgName = cap.package.replace(/^@boopkit\//, '');
+    const pkgDir = path.join((0, config_1.getBoopRoot)(), 'packages', pkgName);
+    // Check already adopted
+    if (manifest.adopted && manifest.adopted.includes(pkgName)) {
+        console.error(`Error: Package "${cap.package}" is already adopted.`);
+        process.exitCode = 1;
+        return;
+    }
+    // 4. Warn if other installed packages depend on the package being adopted
+    warnDependentPackages(targetDir, cap.package, pkgName);
+    // 5. Copy package src/ → src/adopted/<pkgName>/
+    const srcDir = path.join(pkgDir, 'src');
+    const adoptedSrcDir = path.join(targetDir, 'src', 'adopted', pkgName);
+    const copiedSrc = [];
+    if (fs.existsSync(srcDir)) {
+        (0, safe_io_1.safeCopyDir)(srcDir, adoptedSrcDir, { onConflict: 'skip' });
+        copiedSrc.push(...listFilesRecursive(adoptedSrcDir).map(f => path.relative(targetDir, f)));
+    }
+    // 5. Copy package styles/ → styles/adopted/<pkgName>/
+    const stylesDir = path.join(pkgDir, 'styles');
+    const adoptedStylesDir = path.join(targetDir, 'styles', 'adopted', pkgName);
+    const copiedStyles = [];
+    if (fs.existsSync(stylesDir)) {
+        (0, safe_io_1.safeCopyDir)(stylesDir, adoptedStylesDir, { onConflict: 'skip' });
+        copiedStyles.push(...listFilesRecursive(adoptedStylesDir).map(f => path.relative(targetDir, f)));
+    }
+    // 6. Rewrite .ts imports
+    rewriteTsImports(targetDir, cap.package, pkgName);
+    // 7. Rewrite .css imports
+    rewriteCssImports(targetDir, cap.package, pkgName);
+    // 8. Remove package dependency from package.json
+    const pkgJsonPath = path.join(targetDir, 'package.json');
+    if (fs.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        if (pkg.dependencies && pkg.dependencies[cap.package]) {
+            delete pkg.dependencies[cap.package];
+            (0, safe_io_1.createBackup)(pkgJsonPath);
+            fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+        }
+    }
+    // 9. Update manifest
+    if (!manifest.adopted)
+        manifest.adopted = [];
+    manifest.adopted.push(pkgName);
+    (0, project_1.writeProjectManifest)(targetDir, manifest);
+    // 10. Run npm install
+    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.');
+        }
+    }
+    // 11. Output
+    if (options.json) {
+        console.log(JSON.stringify({
+            capability: capabilityName,
+            package: cap.package,
+            adopted: {
+                src: copiedSrc,
+                styles: copiedStyles,
+            },
+        }, null, 2));
+        return;
+    }
+    console.log(`\n${'─'.repeat(40)}`);
+    console.log(`Adopted "${cap.package}" into ${manifest.name}\n`);
+    if (copiedSrc.length > 0) {
+        console.log('Source files copied:');
+        for (const f of copiedSrc) {
+            console.log(`  ${f}`);
+        }
+    }
+    if (copiedStyles.length > 0) {
+        console.log('\nStyle files copied:');
+        for (const f of copiedStyles) {
+            console.log(`  ${f}`);
+        }
+    }
+    console.log('\nImports rewritten from package to local paths.');
+    console.log(`Package "${cap.package}" removed from dependencies.`);
+    console.log(`\nYou now own this code — edit freely in src/adopted/${pkgName}/`);
+}
+function listFilesRecursive(dir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...listFilesRecursive(fullPath));
+        }
+        else {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+function rewriteTsImports(targetDir, packageName, pkgName) {
+    const srcDir = path.join(targetDir, 'src');
+    if (!fs.existsSync(srcDir))
+        return;
+    const tsFiles = findFilesWithExt(srcDir, ['.ts', '.tsx']);
+    for (const file of tsFiles) {
+        let content = fs.readFileSync(file, 'utf-8');
+        if (!content.includes(packageName))
+            continue;
+        const fileDir = path.dirname(file);
+        const adoptedDir = path.join(srcDir, 'adopted', pkgName);
+        let relativePath = path.relative(fileDir, adoptedDir);
+        if (!relativePath.startsWith('.')) {
+            relativePath = './' + relativePath;
+        }
+        // Rewrite bare package imports: from '@boopkit/cap-foo' → from './adopted/cap-foo'
+        content = content.replace(new RegExp(`from\\s+['"]${escapeRegex(packageName)}['"]`, 'g'), `from '${relativePath}'`);
+        // Rewrite deep imports: from '@boopkit/cap-foo/something' → from './adopted/cap-foo/something'
+        content = content.replace(new RegExp(`from\\s+['"]${escapeRegex(packageName)}/([^'"]+)['"]`, 'g'), `from '${relativePath}/$1'`);
+        (0, safe_io_1.createBackup)(file);
+        fs.writeFileSync(file, content, 'utf-8');
+    }
+}
+function rewriteCssImports(targetDir, packageName, pkgName) {
+    const stylesDir = path.join(targetDir, 'styles');
+    if (!fs.existsSync(stylesDir))
+        return;
+    const cssFiles = findFilesWithExt(stylesDir, ['.css']);
+    for (const file of cssFiles) {
+        let content = fs.readFileSync(file, 'utf-8');
+        if (!content.includes(packageName))
+            continue;
+        const fileDir = path.dirname(file);
+        const adoptedDir = path.join(stylesDir, 'adopted', pkgName);
+        let relativePath = path.relative(fileDir, adoptedDir);
+        if (!relativePath.startsWith('.')) {
+            relativePath = './' + relativePath;
+        }
+        // Rewrite @import "@boopkit/cap-foo/styles/x.css" → @import "./adopted/cap-foo/x.css"
+        content = content.replace(new RegExp(`@import\\s+["']${escapeRegex(packageName)}/styles/([^"']+)["']`, 'g'), `@import "${relativePath}/$1"`);
+        // Rewrite any remaining package references in @import
+        content = content.replace(new RegExp(`@import\\s+["']${escapeRegex(packageName)}/([^"']+)["']`, 'g'), `@import "${relativePath}/$1"`);
+        (0, safe_io_1.createBackup)(file);
+        fs.writeFileSync(file, content, 'utf-8');
+    }
+}
+function findFilesWithExt(dir, extensions) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...findFilesWithExt(fullPath, extensions));
+        }
+        else if (extensions.some(ext => entry.name.endsWith(ext))) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function warnDependentPackages(targetDir, adoptedPackage, adoptedPkgName) {
+    const pkgJsonPath = path.join(targetDir, 'package.json');
+    if (!fs.existsSync(pkgJsonPath))
+        return;
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+    const deps = pkg.dependencies || {};
+    const dependents = [];
+    for (const [depName, depValue] of Object.entries(deps)) {
+        if (!depName.startsWith('@boopkit/') || depName === adoptedPackage)
+            continue;
+        // Resolve the package dir from the file: link
+        const depStr = depValue;
+        let pkgDir;
+        if (depStr.startsWith('file:')) {
+            pkgDir = path.resolve(targetDir, depStr.slice(5));
+        }
+        else {
+            const shortName = depName.replace(/^@boopkit\//, '');
+            pkgDir = path.join((0, config_1.getBoopRoot)(), 'packages', shortName);
+        }
+        const depPkgJsonPath = path.join(pkgDir, 'package.json');
+        if (!fs.existsSync(depPkgJsonPath))
+            continue;
+        const depPkg = JSON.parse(fs.readFileSync(depPkgJsonPath, 'utf-8'));
+        const allDeps = {
+            ...depPkg.dependencies,
+            ...depPkg.peerDependencies,
+        };
+        if (allDeps[adoptedPackage]) {
+            dependents.push(depName);
+        }
+    }
+    if (dependents.length > 0) {
+        console.error(`Warning: The following installed packages depend on ${adoptedPackage}: ${dependents.join(', ')}. ` +
+            `They will continue using the node_modules copy if available.`);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+export interface InitOptions {
+    profile?: string;
+    install?: boolean;
+}
+export declare function runInit(name: string, options: InitOptions): void;