@khanhcan148/mk 0.1.0

package/README.md

@@ -0,0 +1,266 @@
+# Claude Code Skills, Agents & Workflows
+
+[![CI](https://github.com/khanhtran148/mk-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/khanhtran148/mk-kit/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@khanhcan148/mk)](https://www.npmjs.com/package/@khanhcan148/mk)
+
+**Built by** TRAN Le Khanh — developer and AI tooling author.
+
+Modular packages that extend Claude Code with specialized knowledge, workflows, and tool integrations.
+
+**Quick Navigation:** [Quick Reference](docs/QUICK-REFERENCE.md) | [Common Workflows](docs/COMMON-WORKFLOWS.md) | [Skill Index](docs/SKILL-INDEX.md)
+
+## Quick Start
+
+### CLI Installation (Recommended)
+
+```bash
+# Install globally
+npm install -g @khanhcan148/mk
+
+# Install kit to current project (./.claude/)
+mk init
+
+# Install kit globally (~/.claude/ — available in all projects)
+mk init --global
+
+# Preview what would be installed without writing files
+mk init --dry-run
+```
+
+### CLI Commands
+
+```
+mk init              Install kit files to current project (./.claude/)
+mk init --global     Install kit globally (~/.claude/)
+mk init --dry-run    Preview what would be installed
+mk update            Update kit files (preserves your edits by default)
+mk update --force    Update and overwrite user-modified files
+mk remove            Remove all kit files tracked by manifest
+mk --version         Show installed CLI version
+mk --help            Show help
+```
+
+### Manual Installation (Alternative)
+
+```bash
+# Clone the repository
+git clone https://github.com/khanhtran148/mk-kit.git
+cd mk-kit
+```
+
+**Project-level usage** (skills available in one project):
+```bash
+cp -r .claude /path/to/your/project/
+```
+
+**Global-level usage** (skills available across all projects):
+```bash
+cp -r .claude ~/.claude/
+```
+
+### Usage
+
+```bash
+# Use a workflow command
+/mk-init          # Bootstrap new project
+/mk-brainstorm    # Explore options, debate trade-offs
+/mk-plan          # Create implementation plan
+/mk-implement     # End-to-end feature delivery
+/mk-test          # Run tests and validate
+/mk-review        # Code quality review
+/mk-debug         # Debug issues
+/mk-security      # Security scan and audit
+/mk-db            # Database operations
+/mk-docs          # Generate documentation
+/mk-git           # Git operations
+```
+
+## Structure
+
+```
+├── .claude/
+│   ├── agents/      # 29 agents (5 primary + 24 utility: implementers, quality, docs, specialized, concerns)
+│   ├── skills/      # 53 skill packages (SKILL.md + scripts/references/assets)
+│   │   ├── mk-*/    # 14 workflow commands (/mk-brainstorm, /mk-selftest, etc.)
+│   │   └── ...      # Domain skills (frontend, backend, testing, etc.)
+│   └── workflows/   # Development protocols
+├── bin/             # CLI entry point (mk command)
+├── src/             # CLI source code
+├── docs/            # Project documentation
+│   └── plans/       # Implementation plans (created during development)
+├── package.json     # npm package metadata
+├── CLAUDE.md        # Claude Code guidance
+└── README.md        # This file
+```
+
+## Primary Workflow
+
+Orchestration is handled by `/mk-*` skills which spawn utility agents as needed. See [Common Workflows](docs/COMMON-WORKFLOWS.md) for practical examples.
+
+**Architecture:**
+
+```
+User → /mk-* command (skill) → spawns utility agents → agents use knowledge skills
+```
+
+**Sequential chaining:**
+```
+/mk-plan → /mk-implement → /mk-test → /mk-review
+```
+
+**Entry point commands:**
+
+| Command | Purpose |
+|---------|---------|
+| `/mk-init` | Full project bootstrap from conception to deployment; includes brownfield detection (Phase 0 gate) and adoption workflow (B1-B4.5 stages) |
+| `/mk-brainstorm` | Ideation, requirements exploration, structured debate (analyzer opus agent); use `--domain` flag to extract and document domain knowledge |
+| `/mk-research` | Deep multi-source research on technical topics |
+| `/mk-plan` | Create implementation plans with phases and tasks (opus) |
+| `/mk-design` | UI/UX wireframes, design systems, mockups |
+| `/mk-implement` | End-to-end feature delivery (sonnet) |
+| `/mk-test` | Run tests, analyze coverage, validate builds |
+| `/mk-review` | Code review for quality, security, performance |
+| `/mk-debug` | Debugging workflow: investigate, diagnose, fix, verify |
+| `/mk-security` | Security-first workflow: dependency scan, secrets detection |
+| `/mk-db` | Database operations: diagnose, optimize, design, migrate |
+| `/mk-docs` | Generate and update project documentation |
+| `/mk-git` | Git operations: branch, commit, push, PR, merge |
+| `/mk-selftest` | Run self-validation checks on kit agents, skills, docs, and workflows |
+
+## Primary Agents
+
+Invoked directly via `/mk-*` skills:
+
+| Agent | Purpose | Model |
+|-------|---------|-------|
+| **analyzer** | Deep research, decision matrix, architecture diagrams, adversarial debate (Phases 5-8 of /mk-brainstorm) | opus |
+| **planner** | Implementation planning with phases, tasks, dependencies | opus |
+| **implementer** | End-to-end feature implementation | sonnet |
+| **database-admin** | Database operations: diagnose, optimize, design, migrate | sonnet |
+| **git-manager** | Git operations: commit, push, PR, merge | haiku |
+
+## Utility Agents
+
+Spawned by primary agents for domain-specific work:
+
+**Implementation & Quality (8)**
+| Agent | Purpose |
+|-------|---------|
+| **backend-implementer** | API and domain logic implementation |
+| **frontend-implementer** | UI components, consuming API contract |
+| **tester** | Test execution and validation |
+| **debugger** | Issue investigation and diagnosis |
+| **refactorer** | Refactoring with TFD-first safety workflow |
+
+**Docs & Project Management (3)**
+| Agent | Purpose |
+|-------|---------|
+| **project-manager** | Progress tracking, roadmap updates |
+| **docs-manager** | Documentation maintenance |
+| **journal-writer** | Technical difficulty documentation |
+
+**Research & Design (3)**
+| Agent | Purpose |
+|-------|---------|
+| **researcher** | Technical research |
+| **ui-ux-designer** | Frontend design |
+| **copywriter** | Marketing copy and content |
+
+**Utilities & Search (2)**
+| Agent | Purpose |
+|-------|---------|
+| **scout** | Codebase file search (internal) |
+| **scout-external** | Codebase search via external tools |
+| **mcp-manager** | MCP server integrations |
+
+**Parallel Concern Review Agents (10)**
+| Agent | Purpose |
+|-------|---------|
+| **quality-reviewer** | Code quality, readability, maintainability (mk-review concern) |
+| **security-reviewer** | Security vulnerabilities, threat analysis (mk-review concern) |
+| **performance-reviewer** | Performance profiling, optimization opportunities (mk-review concern) |
+| **tfd-reviewer** | Test-first development verification (mk-review concern) |
+| **dep-scanner** | Dependency vulnerability scanning (mk-security concern) |
+| **secret-scanner** | Secrets and credential detection (mk-security concern) |
+| **code-security-reviewer** | Code-level security analysis (mk-security concern) |
+| **infra-reviewer** | Infrastructure security review (mk-security concern) |
+| **log-analyzer** | Log analysis and diagnostics (mk-debug concern) |
+| **hypothesis-generator** | Root cause hypothesis generation (mk-debug concern) |
+
+[Full agent details →](.claude/agents/README.md)
+
+## Skills
+
+See [Skill Index](docs/SKILL-INDEX.md) for a complete categorized list of all skills.
+
+Each skill contains:
+- `SKILL.md` (required) - Instructions (<100 lines)
+- `scripts/` (optional) - Executable code with tests
+- `references/` (optional) - Documentation chunks
+- `assets/` (optional) - Templates, images
+
+```bash
+# Initialize new skill
+.claude/skills/skill-creator/scripts/init_skill.py <skill-name> --path <output-directory>
+
+# Package for distribution
+.claude/skills/skill-creator/scripts/package_skill.py <path/to/skill-folder>
+```
+
+## Documentation
+
+| Document | Description |
+|----------|-------------|
+| [Skill Index](docs/SKILL-INDEX.md) | Categorized list of all skills and workflows |
+| [mk-* Workflows & Agents](docs/mk-workflow-agents.md) | How each /mk-* command works and which agents it uses |
+| [Project Overview & PDR](docs/project-overview-pdr.md) | Requirements, constraints, success metrics |
+| [Project Roadmap](docs/project-roadmap.md) | Phases, milestones, and risk register |
+| [Changelog](docs/changelog.md) | Version history and release notes |
+| [Code Standards](docs/code-standards.md) | Conventions, naming, quality gates |
+| [System Architecture](docs/system-architecture.md) | Component diagrams, data flow |
+| [Product Domain Glossary](docs/product-domain-glossary.md) | Core domain concepts, terminology, and ecosystem definitions |
+| [Quick Reference](docs/QUICK-REFERENCE.md) | Common commands and quick lookup |
+| [Common Workflows](docs/COMMON-WORKFLOWS.md) | Practical workflow examples |
+
+## Core Principles
+
+- **YAGNI** - Don't add functionality until necessary
+- **KISS** - Prefer simple solutions
+- **DRY** - Extract common patterns
+- **SOLID** - For OOP/enterprise projects
+
+## Key Constraints
+
+- SKILL.md must be under 100 lines
+- Referenced markdown files also under 100 lines
+- Scripts must include tests
+- **Cross-platform compatibility (Windows + macOS/Linux) is mandatory**: Scripts use Python or Node.js only — no bash/shell scripts
+- Token efficiency - minimize context usage
+
+## Compatibility
+
+This skill kit works in both Claude Code CLI and VSCode GitHub Copilot (1.108+).
+
+## Cross-Platform Compatibility
+
+This kit is designed to work on Windows, macOS, and Linux:
+
+- **Scripts**: All executable scripts use Python or Node.js (no bash/shell scripts)
+- **Claude Code Bash tool**: Provides a Unix-like shell on all platforms, including Windows — git commands and other Bash tool invocations work everywhere
+- **External tool installs**: Reference files include install instructions for macOS (`brew`), Ubuntu/Debian (`apt-get`), and Windows (`winget`/`choco`) where applicable
+- **Agent fallbacks**: Agents using CLI-only tools (TodoWrite, BashOutput, MultiEdit) document VSCode Copilot fallback behavior inline
+
+| Feature | Claude Code CLI | VSCode Copilot (1.108+) |
+|---------|----------------|------------------------|
+| Skills (SKILL.md) | Full support | Full support |
+| Agents (.md) | Full support | Full support |
+| CLAUDE.md | Full support | Full support |
+| Model field | Shorthand (opus/sonnet/haiku) | Shorthand (recommended) |
+| Task tool | Native Task() syntax | Natural language delegation* |
+| color | Supported | Ignored (harmless) |
+| MCP tools | Full support | Limited |
+| AskUserQuestion | Native UI | Natural language fallback |
+
+*VSCode Copilot users: Use natural language to invoke agents (e.g., "Use the planner agent to create a plan"). The explicit Task() syntax is Claude Code CLI-specific.
+
+**CLI-only tools**: TodoWrite, BashOutput, KillShell, MultiEdit are Claude Code-specific. Agents gracefully fall back to standard tools (Write, Bash, sequential Edit) when these are unavailable.

package/bin/mk.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { initAction } from '../src/commands/init.js';
+import { updateAction } from '../src/commands/update.js';
+import { removeAction } from '../src/commands/remove.js';
+import { loginAction, logoutAction, statusAction } from '../src/commands/auth.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+
+program
+  .name('mk')
+  .description('Install and manage MyClaudeKit (.claude/) in your projects')
+  .version(pkg.version);
+
+program.command('init')
+  .description('Install .claude/ kit files to current project or globally')
+  .option('--global', 'Install to ~/.claude/ for all projects')
+  .option('--dry-run', 'Print planned changes without writing files')
+  .action((options) => initAction(options));
+
+program.command('update')
+  .description('Update kit files to the latest version, preserving user modifications')
+  .option('--force', 'Overwrite user-modified files without warning')
+  .option('--global', 'Update global installation in ~/.claude/')
+  .action((options) => updateAction(options));
+
+program.command('remove')
+  .description('Remove all kit files tracked by the manifest')
+  .option('--global', 'Remove global installation from ~/.claude/')
+  .action((options) => removeAction(options));
+
+// Auth command group
+const auth = program.command('auth')
+  .description('Manage GitHub authentication for kit downloads');
+
+auth.command('login')
+  .description('Authenticate with GitHub via OAuth Device Flow')
+  .option('--token <token>', 'Use a Personal Access Token instead of device flow')
+  .action((options) => loginAction(options));
+
+auth.command('logout')
+  .description('Remove stored GitHub authentication token')
+  .action(() => logoutAction());
+
+auth.command('status')
+  .description('Show current authentication status')
+  .action(() => statusAction());
+
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@khanhcan148/mk",
+  "version": "0.1.0",
+  "description": "CLI to install and manage MyClaudeKit (.claude/) in your projects",
+  "type": "module",
+  "bin": {
+    "mk": "./bin/mk.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test test/lib/*.test.js test/commands/*.test.js test/integration/*.test.js",
+    "lint": "node --check src/**/*.js bin/**/*.js 2>/dev/null || true",
+    "selftest": "python3 .claude/skills/mk-selftest/scripts/validate_kit.py"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "fs-extra": "^11.0.0",
+    "chalk": "^5.0.0"
+  },
+  "devDependencies": {},
+  "keywords": ["claude", "claude-code", "skills", "agents", "cli"],
+  "author": "khanhcan148",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/khanhtran148/mk-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/khanhtran148/mk-kit/issues"
+  },
+  "homepage": "https://github.com/khanhtran148/mk-kit#readme"
+}

package/src/commands/auth.js

@@ -0,0 +1,143 @@
+import chalk from 'chalk';
+import {
+  resolveToken as _resolveToken,
+  tokenSource as _tokenSource,
+  validateToken as _validateToken,
+  checkRepoAccess as _checkRepoAccess,
+  startDeviceFlow as _startDeviceFlow
+} from '../lib/auth.js';
+import { writeToken as _writeToken, deleteToken as _deleteToken, readStoredToken as _readStoredToken } from '../lib/config.js';
+
+// ---------------------------------------------------------------------------
+// loginAction
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle 'mk auth login'.
+ * Options: { token?: string } — if token provided, store it as PAT
+ *
+ * @param {{ token?: string }} options
+ * @param {object} [deps] - Injected dependencies (for testing)
+ */
+export async function loginAction(options = {}, deps = {}) {
+  const {
+    resolveToken = _resolveToken,
+    validateToken = _validateToken,
+    startDeviceFlow = (opts) => _startDeviceFlow(opts),
+    writeToken = _writeToken,
+    readStoredToken = _readStoredToken
+  } = deps;
+
+  // PAT mode: --token flag provided
+  if (options.token) {
+    process.stdout.write('Validating token...\n');
+    const validation = await validateToken(options.token);
+    if (!validation.valid) {
+      process.stderr.write(chalk.red('Error: Token is invalid or has expired. Please check and try again.\n'));
+      return;
+    }
+    writeToken(options.token);
+    process.stdout.write(chalk.green(`Authenticated as ${validation.username}\n`));
+    return;
+  }
+
+  // Check if already authenticated
+  const existing = resolveToken({ readStored: readStoredToken });
+  if (existing) {
+    const validation = await validateToken(existing);
+    if (validation.valid) {
+      process.stdout.write(chalk.green(`Already authenticated as ${validation.username}\n`));
+      return;
+    }
+    // Token invalid — clear it and re-auth
+    process.stdout.write(chalk.yellow('Stored token is no longer valid. Re-authenticating...\n'));
+  }
+
+  // Device flow
+  process.stdout.write('Starting GitHub OAuth Device Flow...\n');
+  let newToken;
+  try {
+    newToken = await startDeviceFlow({
+      display: ({ userCode, verificationUri, expiresIn }) => {
+        process.stdout.write('\n');
+        process.stdout.write(chalk.bold('To authenticate, visit:  ') + chalk.cyan(verificationUri) + '\n');
+        process.stdout.write(chalk.bold('And enter the code:      ') + chalk.yellow(userCode) + '\n');
+        process.stdout.write(`(Code expires in ${Math.round(expiresIn / 60)} minutes)\n\n`);
+        process.stdout.write('Waiting for authorization...\n');
+      },
+      writeStored: writeToken
+    });
+  } catch (err) {
+    process.stderr.write(chalk.red(`Error: ${err.message}\n`));
+    return;
+  }
+
+  const validation = await validateToken(newToken);
+  if (validation.valid) {
+    process.stdout.write(chalk.green(`\nAuthenticated as ${validation.username}\n`));
+  } else {
+    process.stdout.write(chalk.green('\nAuthentication successful.\n'));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// logoutAction
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle 'mk auth logout'.
+ *
+ * @param {object} [deps] - Injected dependencies (for testing)
+ */
+export async function logoutAction(deps = {}) {
+  const { deleteToken = _deleteToken } = deps;
+  deleteToken();
+  process.stdout.write(chalk.green('Logged out. Stored token removed.\n'));
+}
+
+// ---------------------------------------------------------------------------
+// statusAction
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle 'mk auth status'.
+ *
+ * @param {object} [deps] - Injected dependencies (for testing)
+ */
+export async function statusAction(deps = {}) {
+  const {
+    resolveToken = _resolveToken,
+    tokenSource = _tokenSource,
+    validateToken = _validateToken,
+    checkRepoAccess = _checkRepoAccess,
+    readStoredToken = _readStoredToken
+  } = deps;
+
+  const token = resolveToken({ readStored: readStoredToken });
+
+  if (!token) {
+    process.stdout.write(chalk.yellow('Not authenticated. Run \'mk auth login\' to authenticate.\n'));
+    return;
+  }
+
+  const source = tokenSource(token, { readStored: readStoredToken });
+  process.stdout.write(`Token source: ${source}\n`);
+
+  const validation = await validateToken(token);
+  if (!validation.valid) {
+    process.stdout.write(chalk.red('Token: invalid or expired\n'));
+    process.stdout.write(chalk.yellow('Run \'mk auth login\' to re-authenticate.\n'));
+    return;
+  }
+
+  process.stdout.write(chalk.green(`Logged in as: ${validation.username}\n`));
+  process.stdout.write('Token: valid\n');
+
+  const access = await checkRepoAccess(token);
+  if (access.accessible) {
+    process.stdout.write(chalk.green('Repo access: granted\n'));
+  } else {
+    process.stdout.write(chalk.red('Repo access: denied\n'));
+    process.stdout.write('Contact the repository owner for collaborator access.\n');
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,144 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { copyKitFiles } from '../lib/copy.js';
+import { writeManifest } from '../lib/manifest.js';
+import { computeChecksum } from '../lib/checksum.js';
+import { resolveTargetDir, resolveManifestPath } from '../lib/paths.js';
+import { MANIFEST_FILENAME } from '../lib/constants.js';
+import { resolveTokenOrLogin } from '../lib/auth.js';
+import { writeToken, readStoredToken } from '../lib/config.js';
+import { downloadAndExtractKit, cleanupTempDir } from '../lib/download.js';
+
+/**
+ * Run the init command.
+ *
+ * @param {{
+ *   sourceDir?: string,
+ *   targetDir?: string,
+ *   manifestPath?: string,
+ *   scope?: 'project'|'global',
+ *   dryRun?: boolean
+ * }} params
+ * @returns {Promise<{ files: Array, totalSize: number }>}
+ */
+export async function runInit(params = {}) {
+  const {
+    sourceDir = resolveSourceDir(),
+    targetDir = resolveTargetDir({ global: false }),
+    manifestPath = resolveManifestPath({ global: false }),
+    scope = 'project',
+    dryRun = false
+  } = params;
+
+  // Guard: abort if already installed
+  if (existsSync(manifestPath)) {
+    throw new Error(
+      `Already installed. Use 'mk update' to update kit files. (Manifest found at: ${manifestPath})`
+    );
+  }
+
+  // Copy files (dry-run or real)
+  const fileList = copyKitFiles(sourceDir, targetDir, { dryRun });
+
+  if (dryRun) {
+    return { files: fileList, totalSize: fileList.reduce((s, f) => s + f.size, 0), dryRun: true };
+  }
+
+  // Compute checksums and build manifest files map
+  // fileURLToPath handles Windows drive-letter prefix correctly (avoids leading /C:/ from .pathname)
+  const pkg = JSON.parse(readFileSync(
+    fileURLToPath(new URL('../../package.json', import.meta.url)),
+    'utf8'
+  ));
+
+  const files = {};
+  for (const entry of fileList) {
+    if (existsSync(entry.absolutePath)) {
+      const checksum = computeChecksum(entry.absolutePath);
+      files[entry.relativePath] = { checksum, size: entry.size };
+    }
+  }
+
+  // Write manifest
+  writeManifest(manifestPath, files, pkg.version, scope);
+
+  const totalSize = fileList.reduce((s, f) => s + f.size, 0);
+  return { files: fileList, totalSize, fileCount: fileList.length };
+}
+
+/**
+ * CLI action handler for 'mk init'.
+ * Downloads kit from GitHub and installs .claude/ to target directory.
+ *
+ * @param {{ global: boolean, dryRun: boolean }} options
+ * @param {object} [deps] - Injected dependencies (for testing)
+ */
+export async function initAction(options = {}, deps = {}) {
+  const {
+    resolveTokenOrLogin: resolveAndLogin = resolveTokenOrLogin,
+    downloadAndExtractKit: download = downloadAndExtractKit,
+    cleanupTempDir: cleanup = cleanupTempDir,
+    writeToken: storeToken = writeToken,
+    readStoredToken: readToken = readStoredToken
+  } = deps;
+
+  const targetDir = resolveTargetDir(options);
+  const manifestPath = resolveManifestPath(options);
+  const scope = options.global ? 'global' : 'project';
+
+  // Pre-flight: warn if target exists with files
+  if (existsSync(targetDir)) {
+    process.stdout.write(
+      chalk.yellow(`Warning: ${targetDir} already exists. Kit files will be added to existing structure.\n`)
+    );
+  }
+
+  if (options.dryRun) {
+    process.stdout.write(chalk.cyan('Dry run — no files will be written.\n\n'));
+  }
+
+  let tempDir = null;
+  try {
+    // Authenticate and download kit from GitHub
+    process.stdout.write('Authenticating with GitHub...\n');
+    const token = await resolveAndLogin({
+      readStored: readToken,
+      writeStored: storeToken,
+      display: ({ userCode, verificationUri, expiresIn }) => {
+        process.stdout.write('\n');
+        process.stdout.write(chalk.bold('To authenticate, visit:  ') + chalk.cyan(verificationUri) + '\n');
+        process.stdout.write(chalk.bold('And enter the code:      ') + chalk.yellow(userCode) + '\n');
+        process.stdout.write(`(Code expires in ${Math.round(expiresIn / 60)} minutes)\n\n`);
+        process.stdout.write('Waiting for authorization...\n');
+      }
+    });
+
+    process.stdout.write('Downloading kit from GitHub...\n');
+    tempDir = await download(token);
+    const sourceDir = join(tempDir, '.claude');
+
+    const result = await runInit({ sourceDir, targetDir, manifestPath, scope, dryRun: options.dryRun });
+
+    if (options.dryRun) {
+      process.stdout.write(`Would install ${result.files.length} files:\n`);
+      for (const f of result.files) {
+        process.stdout.write(`  ${f.relativePath}\n`);
+      }
+    } else {
+      const sizeKB = Math.round(result.totalSize / 1024);
+      process.stdout.write(
+        chalk.green(`Installed ${result.fileCount} files (${sizeKB} KB) to ${targetDir}\n`)
+      );
+      process.stdout.write(`Manifest written to: ${manifestPath}\n`);
+    }
+  } catch (err) {
+    process.stderr.write(chalk.red(`Error: ${err.message}\n`));
+    process.exit(1);
+  } finally {
+    if (tempDir) {
+      cleanup(tempDir);
+    }
+  }
+}