dev-prism 0.2.0 → 0.3.0

package/README.md

@@ -17,10 +17,13 @@ All Docker configuration lives in `docker-compose.session.yml` in your project -
 
 ## Features
 
-- **Git worktrees** for isolated working directories
+- **Git worktrees** for isolated working directories (or in-place mode)
 - **Docker Compose** handles all container orchestration
-- **Unique ports** per session (calculated from session ID)
+- **Unique ports** per session (calculated from session ID, displayed as clickable URLs)
+- **Auto-assign** session IDs or choose your own
+- **SQLite tracking** — all sessions stored in a local database
 - **Two modes**: Docker (apps in containers) or Native (apps run locally)
+- **Claude Code integration** built-in (`dev-prism claude`)
 - **Portable**: Works with any project
 
 ## Installation
@@ -36,17 +39,27 @@ pnpm add -D dev-prism
 ### Create a session
 
 ```bash
-# Docker mode (default) - apps run in containers
+# Auto-assign session ID
+dev-prism create
+
+# Explicit session ID
 dev-prism create 001
 
+# Custom branch name
+dev-prism create --branch feature/my-feature
+
 # Native mode - only infrastructure in Docker, apps run via pnpm dev
-dev-prism create 001 --mode=native
+dev-prism create --mode native
+
+# Exclude specific apps from Docker
+dev-prism create --without web,widget
 
 # In-place mode - use current directory instead of creating worktree
-dev-prism create 001 --in-place
-```
+dev-prism create --in-place
 
-**Note:** In-place sessions are not shown in `dev-prism list` (which only lists worktree-based sessions). Use `dev-prism info` from within an in-place session directory to see its details.
+# Stream logs after creation instead of detaching
+dev-prism create --no-detach
+```
 
 ### List sessions
 
@@ -74,11 +87,20 @@ dev-prism stop-all   # Stop all sessions
 dev-prism logs 001
 ```
 
-### Destroy a session
+### Cleanup
 
 ```bash
 dev-prism destroy 001     # Destroy specific session
 dev-prism destroy --all   # Destroy all sessions
+dev-prism prune           # Remove all stopped sessions
+dev-prism prune -y        # Skip confirmation
+```
+
+### Claude Code integration
+
+```bash
+dev-prism claude          # Install Claude Code skill + CLAUDE.md
+dev-prism claude --force  # Overwrite existing files
 ```
 
 ## Port Allocation
@@ -171,9 +193,11 @@ services:
 
 ## How It Works
 
-1. **Create session**: `dev-prism create 001`
-   - Creates git worktree at `../project-sessions/session-001`
+1. **Create session**: `dev-prism create`
+   - Auto-assigns next available session ID (or use explicit ID)
+   - Creates git worktree at `../project-sessions/session-001` (or uses current dir with `--in-place`)
    - Generates `.env.session` with calculated ports
+   - Records session in local SQLite database
    - Runs `docker compose --env-file .env.session up -d`
    - Runs setup commands
 
@@ -182,6 +206,8 @@ services:
 3. **Docker mode** (`--profile apps`): All services including apps run in containers
 4. **Native mode**: Only infrastructure runs; apps use `pnpm dev` with `.env.session`
 
+All session state is tracked in a SQLite database (`~/.dev-prism/sessions.db`), making both worktree and in-place sessions first-class citizens across all commands.
+
 ## Generated Files
 
 ```
@@ -207,4 +233,4 @@ To use in another project:
 1. Install: `pnpm add -D dev-prism`
 2. Create `session.config.mjs` with port offsets
 3. Create `docker-compose.session.yml` with `${VAR}` placeholders
-4. Run `dev-prism create 001`
+4. Run `dev-prism create`

package/bin/dev-prism.js

@@ -5,13 +5,19 @@ import { createSession } from '../dist/commands/create.js';
 import { destroySession } from '../dist/commands/destroy.js';
 import { listSessions } from '../dist/commands/list.js';
 import { installClaude } from '../dist/commands/claude.js';
+import { showInfo } from '../dist/commands/info.js';
+import { startSession } from '../dist/commands/start.js';
+import { stopSession } from '../dist/commands/stop.js';
+import { stopAllSessions } from '../dist/commands/stop-all.js';
+import { pruneSessions } from '../dist/commands/prune.js';
+import { streamLogs } from '../dist/commands/logs.js';
 
 const program = new Command();
 
 program
   .name('dev-prism')
   .description('CLI tool for managing isolated parallel development sessions')
-  .version('0.1.0');
+  .version('0.3.0');
 
 program
   .command('create [sessionId]')
@@ -53,52 +59,7 @@ program
   .command('info')
   .description('Show session info for current directory (useful for --in-place sessions)')
   .action(async () => {
-    const cwd = process.cwd();
-    const chalk = (await import('chalk')).default;
-    const { existsSync, readFileSync } = await import('node:fs');
-    const { resolve } = await import('node:path');
-    const docker = await import('../dist/lib/docker.js');
-
-    const envFile = resolve(cwd, '.env.session');
-    if (!existsSync(envFile)) {
-      console.log(chalk.yellow('No .env.session found in current directory.'));
-      console.log(chalk.gray('Run `dev-prism create --in-place` to create a session here.'));
-      process.exit(1);
-    }
-
-    // Parse .env.session
-    const envContent = readFileSync(envFile, 'utf-8');
-    const env = {};
-    for (const line of envContent.split('\n')) {
-      const match = line.match(/^([^=]+)=(.*)$/);
-      if (match) {
-        env[match[1]] = match[2];
-      }
-    }
-
-    const sessionId = env.SESSION_ID || 'unknown';
-    const running = await docker.isRunning({ cwd });
-
-    console.log(chalk.blue(`\nSession ${sessionId}`));
-    console.log(chalk.gray(`Directory: ${cwd}`));
-    console.log(running ? chalk.green('Status: running') : chalk.yellow('Status: stopped'));
-
-    console.log(chalk.gray('\nPorts:'));
-    for (const [key, value] of Object.entries(env)) {
-      if (key.includes('PORT')) {
-        console.log(chalk.gray(`  ${key}: ${value}`));
-      }
-    }
-
-    console.log(chalk.gray('\nURLs:'));
-    for (const [key, value] of Object.entries(env)) {
-      if (key.includes('APP') || key.includes('WEB') || key.includes('WIDGET')) {
-        if (key.includes('PORT')) {
-          console.log(chalk.cyan(`  ${key.replace('_PORT', '')}: http://localhost:${value}`));
-        }
-      }
-    }
-    console.log('');
+    await showInfo(process.cwd());
   });
 
 program
@@ -108,19 +69,10 @@ program
   .option('-W, --without <apps>', 'Exclude apps (comma-separated: app,web,widget)', (val) => val.split(','))
   .action(async (sessionId, options) => {
     const projectRoot = process.cwd();
-    const { loadConfig, getSessionDir } = await import('../dist/lib/config.js');
-    const docker = await import('../dist/lib/docker.js');
-
-    const config = await loadConfig(projectRoot);
-    const sessionDir = getSessionDir(config, projectRoot, sessionId);
-    let profiles;
-    if (options.mode === 'docker') {
-      const allApps = config.apps ?? [];
-      const excludeApps = options.without ?? [];
-      profiles = allApps.filter((app) => !excludeApps.includes(app));
-    }
-
-    await docker.up({ cwd: sessionDir, profiles });
+    await startSession(projectRoot, sessionId, {
+      mode: options.mode,
+      without: options.without,
+    });
   });
 
 program
@@ -128,18 +80,7 @@ program
   .description('Stop Docker services for a session (without destroying)')
   .action(async (sessionId) => {
     const projectRoot = process.cwd();
-    const { loadConfig, getSessionDir } = await import('../dist/lib/config.js');
-    const { execa } = await import('execa');
-
-    const config = await loadConfig(projectRoot);
-    const sessionDir = getSessionDir(config, projectRoot, sessionId);
-
-    // Use stop instead of down to preserve volumes
-    await execa(
-      'docker',
-      ['compose', '-f', 'docker-compose.session.yml', '--env-file', '.env.session', 'stop'],
-      { cwd: sessionDir, stdio: 'inherit' }
-    );
+    await stopSession(projectRoot, sessionId);
   });
 
 program
@@ -150,30 +91,11 @@ program
   .option('-n, --tail <lines>', 'Number of lines to show from the end', '50')
   .action(async (sessionId, options) => {
     const projectRoot = process.cwd();
-    const { loadConfig, getSessionDir } = await import('../dist/lib/config.js');
-    const { execa } = await import('execa');
-
-    const config = await loadConfig(projectRoot);
-    const sessionDir = getSessionDir(config, projectRoot, sessionId);
-    let profileFlags = [];
-    if (options.mode === 'docker') {
-      const allApps = config.apps ?? [];
-      const excludeApps = options.without ?? [];
-      const profiles = allApps.filter((app) => !excludeApps.includes(app));
-      profileFlags = profiles.flatMap((p) => ['--profile', p]);
-    }
-
-    const args = [
-      'compose',
-      '-f', 'docker-compose.session.yml',
-      '--env-file', '.env.session',
-      ...profileFlags,
-      'logs',
-      '-f',
-      '--tail', options.tail,
-    ];
-
-    await execa('docker', args, { cwd: sessionDir, stdio: 'inherit' });
+    await streamLogs(projectRoot, sessionId, {
+      mode: options.mode,
+      without: options.without,
+      tail: options.tail,
+    });
   });
 
 program
@@ -181,62 +103,7 @@ program
   .description('Stop all running sessions (preserves data)')
   .action(async () => {
     const projectRoot = process.cwd();
-    const chalk = (await import('chalk')).default;
-    const { loadConfig, getSessionDir } = await import('../dist/lib/config.js');
-    const { getSessionWorktrees } = await import('../dist/lib/worktree.js');
-    const docker = await import('../dist/lib/docker.js');
-    const { existsSync } = await import('node:fs');
-    const { resolve } = await import('node:path');
-
-    const config = await loadConfig(projectRoot);
-    const sessions = await getSessionWorktrees(projectRoot);
-
-    if (sessions.length === 0) {
-      console.log(chalk.gray('No sessions found.'));
-      return;
-    }
-
-    // Find running sessions
-    const runningSessions = [];
-    for (const session of sessions) {
-      const envFile = resolve(session.path, '.env.session');
-      if (existsSync(envFile)) {
-        const running = await docker.isRunning({ cwd: session.path });
-        if (running) {
-          runningSessions.push(session);
-        }
-      }
-    }
-
-    if (runningSessions.length === 0) {
-      console.log(chalk.gray('No running sessions found.'));
-      return;
-    }
-
-    console.log(chalk.blue(`Stopping ${runningSessions.length} running session(s)...\n`));
-
-    // Get all app profiles and service names to ensure we stop everything
-    const allApps = config.apps ?? [];
-    const profileFlags = allApps.flatMap((p) => ['--profile', p]);
-    // Explicitly list all services to stop (infrastructure + apps)
-    const allServices = ['postgres', 'mailpit', ...allApps];
-
-    const { execa } = await import('execa');
-    for (const session of runningSessions) {
-      console.log(chalk.gray(`  Stopping session ${session.sessionId}...`));
-      try {
-        await execa(
-          'docker',
-          ['compose', '-f', 'docker-compose.session.yml', '--env-file', '.env.session', ...profileFlags, 'stop', ...allServices],
-          { cwd: session.path, stdio: 'pipe' }
-        );
-        console.log(chalk.green(`  Session ${session.sessionId} stopped.`));
-      } catch (error) {
-        console.log(chalk.yellow(`  Warning: Could not stop session ${session.sessionId}`));
-      }
-    }
-
-    console.log(chalk.green(`\nStopped ${runningSessions.length} session(s).`));
+    await stopAllSessions(projectRoot);
   });
 
 program
@@ -245,87 +112,7 @@ program
   .option('-y, --yes', 'Skip confirmation prompt')
   .action(async (options) => {
     const projectRoot = process.cwd();
-    const chalk = (await import('chalk')).default;
-    const { loadConfig } = await import('../dist/lib/config.js');
-    const { getSessionWorktrees, removeWorktree } = await import('../dist/lib/worktree.js');
-    const docker = await import('../dist/lib/docker.js');
-    const { existsSync } = await import('node:fs');
-    const { resolve } = await import('node:path');
-    const readline = await import('node:readline');
-
-    const config = await loadConfig(projectRoot);
-    const sessions = await getSessionWorktrees(projectRoot);
-
-    if (sessions.length === 0) {
-      console.log(chalk.gray('No sessions found.'));
-      return;
-    }
-
-    // Find stopped sessions
-    const stoppedSessions = [];
-    for (const session of sessions) {
-      const envFile = resolve(session.path, '.env.session');
-      let running = false;
-      if (existsSync(envFile)) {
-        running = await docker.isRunning({ cwd: session.path });
-      }
-      if (!running) {
-        stoppedSessions.push(session);
-      }
-    }
-
-    if (stoppedSessions.length === 0) {
-      console.log(chalk.gray('No stopped sessions to prune.'));
-      return;
-    }
-
-    console.log(chalk.yellow(`\nFound ${stoppedSessions.length} stopped session(s) to prune:`));
-    for (const session of stoppedSessions) {
-      console.log(chalk.gray(`  - Session ${session.sessionId} (${session.branch})`));
-    }
-    console.log('');
-
-    // Confirm unless --yes flag provided
-    if (!options.yes) {
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      const answer = await new Promise((resolve) => {
-        rl.question(chalk.red('Are you sure you want to delete these sessions? This cannot be undone. [y/N] '), resolve);
-      });
-      rl.close();
-
-      if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
-        console.log(chalk.gray('Cancelled.'));
-        return;
-      }
-    }
-
-    console.log(chalk.blue('\nPruning stopped sessions...\n'));
-
-    for (const session of stoppedSessions) {
-      console.log(chalk.gray(`  Removing session ${session.sessionId}...`));
-      try {
-        // Clean up any docker resources
-        const envFile = resolve(session.path, '.env.session');
-        if (existsSync(envFile)) {
-          try {
-            await docker.down({ cwd: session.path });
-          } catch {
-            // Ignore errors - containers might already be removed
-          }
-        }
-        // Remove worktree and branch
-        await removeWorktree(projectRoot, session.path, session.branch);
-        console.log(chalk.green(`  Session ${session.sessionId} removed.`));
-      } catch (error) {
-        console.log(chalk.yellow(`  Warning: Could not fully remove session ${session.sessionId}`));
-      }
-    }
-
-    console.log(chalk.green(`\nPruned ${stoppedSessions.length} session(s).`));
+    await pruneSessions(projectRoot, { yes: options.yes });
   });
 
 program

package/dist/chunk-3ATDGV4Y.js

@@ -0,0 +1,22 @@
+// src/lib/ports.ts
+function calculatePorts(config, sessionId) {
+  const sessionNum = parseInt(sessionId, 10);
+  const basePort = config.portBase + sessionNum * 100;
+  const ports = {};
+  for (const [name, offset] of Object.entries(config.ports)) {
+    ports[name] = basePort + offset;
+  }
+  return ports;
+}
+function formatPortsTable(ports) {
+  const lines = [];
+  for (const [name, port] of Object.entries(ports)) {
+    lines.push(`  ${name}: http://localhost:${port}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  calculatePorts,
+  formatPortsTable
+};

package/dist/chunk-3MSC3CGG.js

@@ -0,0 +1,78 @@
+import {
+  removeWorktree
+} from "./chunk-Y3GR6XK7.js";
+import {
+  down
+} from "./chunk-GBN67HYD.js";
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-6YMQTISJ.js";
+
+// src/commands/destroy.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+async function destroySession(projectRoot, sessionId, options) {
+  const config = await loadConfig(projectRoot);
+  const store = new SessionStore();
+  try {
+    if (options.all) {
+      console.log(chalk.blue("Destroying all sessions..."));
+      const sessions = store.listByProject(projectRoot);
+      if (sessions.length === 0) {
+        console.log(chalk.gray("No sessions found."));
+        return;
+      }
+      for (const session2 of sessions) {
+        await destroySingleSession(projectRoot, session2.session_id, session2.session_dir, session2.branch, session2.in_place === 1);
+        store.markDestroyed(projectRoot, session2.session_id);
+      }
+      console.log(chalk.green(`
+Destroyed ${sessions.length} session(s).`));
+      return;
+    }
+    if (!sessionId) {
+      console.error(chalk.red("Error: Session ID required. Use --all to destroy all sessions."));
+      process.exit(1);
+    }
+    if (!/^\d{3}$/.test(sessionId)) {
+      console.error(chalk.red("Error: Session ID must be exactly 3 digits (001-999)"));
+      process.exit(1);
+    }
+    const session = store.findSession(projectRoot, sessionId);
+    if (!session) {
+      console.error(chalk.red(`Error: Session ${sessionId} not found.`));
+      process.exit(1);
+    }
+    await destroySingleSession(projectRoot, sessionId, session.session_dir, session.branch, session.in_place === 1);
+    store.markDestroyed(projectRoot, sessionId);
+    console.log(chalk.green(`
+Session ${sessionId} destroyed.`));
+  } finally {
+    store.close();
+  }
+}
+async function destroySingleSession(projectRoot, sessionId, sessionDir, branchName, inPlace) {
+  console.log(chalk.blue(`
+Destroying session ${sessionId}...`));
+  const envFile = resolve(sessionDir, ".env.session");
+  if (existsSync(envFile)) {
+    console.log(chalk.gray("  Stopping Docker containers..."));
+    try {
+      await down({ cwd: sessionDir });
+    } catch {
+    }
+  }
+  if (!inPlace) {
+    console.log(chalk.gray("  Removing git worktree..."));
+    await removeWorktree(projectRoot, sessionDir, branchName);
+  }
+  console.log(chalk.green(`  Session ${sessionId} destroyed.`));
+}
+
+export {
+  destroySession
+};

package/dist/chunk-6YMQTISJ.js

@@ -0,0 +1,84 @@
+// src/lib/store.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id    TEXT NOT NULL,
+  project_root  TEXT NOT NULL,
+  session_dir   TEXT NOT NULL,
+  branch        TEXT NOT NULL DEFAULT '',
+  mode          TEXT NOT NULL DEFAULT 'docker',
+  in_place      INTEGER NOT NULL DEFAULT 0,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  destroyed_at  TEXT,
+  UNIQUE(session_id, project_root)
+);
+`;
+function defaultDbPath() {
+  return join(homedir(), ".dev-prism", "sessions.db");
+}
+var SessionStore = class {
+  db;
+  constructor(dbPath) {
+    const path = dbPath ?? defaultDbPath();
+    if (path !== ":memory:") {
+      const dir = dirname(path);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 3000");
+    this.db.exec(SCHEMA);
+  }
+  insert(row) {
+    const stmt = this.db.prepare(`
+      INSERT INTO sessions (session_id, project_root, session_dir, branch, mode, in_place)
+      VALUES (@session_id, @project_root, @session_dir, @branch, @mode, @in_place)
+    `);
+    const info = stmt.run({
+      session_id: row.sessionId,
+      project_root: row.projectRoot,
+      session_dir: row.sessionDir,
+      branch: row.branch ?? "",
+      mode: row.mode ?? "docker",
+      in_place: row.inPlace ? 1 : 0
+    });
+    return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(info.lastInsertRowid);
+  }
+  listByProject(projectRoot) {
+    return this.db.prepare("SELECT * FROM sessions WHERE project_root = ? AND destroyed_at IS NULL ORDER BY session_id").all(projectRoot);
+  }
+  listAll() {
+    return this.db.prepare("SELECT * FROM sessions WHERE destroyed_at IS NULL ORDER BY project_root, session_id").all();
+  }
+  findSession(projectRoot, sessionId) {
+    return this.db.prepare("SELECT * FROM sessions WHERE project_root = ? AND session_id = ? AND destroyed_at IS NULL").get(projectRoot, sessionId);
+  }
+  findByDir(sessionDir) {
+    return this.db.prepare("SELECT * FROM sessions WHERE session_dir = ? AND destroyed_at IS NULL").get(sessionDir);
+  }
+  getUsedSessionIds(projectRoot) {
+    const rows = this.db.prepare("SELECT session_id FROM sessions WHERE project_root = ? AND destroyed_at IS NULL").all(projectRoot);
+    return new Set(rows.map((r) => r.session_id));
+  }
+  markDestroyed(projectRoot, sessionId) {
+    const info = this.db.prepare("UPDATE sessions SET destroyed_at = datetime('now') WHERE project_root = ? AND session_id = ? AND destroyed_at IS NULL").run(projectRoot, sessionId);
+    return info.changes > 0;
+  }
+  remove(projectRoot, sessionId) {
+    const info = this.db.prepare("DELETE FROM sessions WHERE project_root = ? AND session_id = ?").run(projectRoot, sessionId);
+    return info.changes > 0;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+export {
+  SessionStore
+};

package/dist/chunk-7YGOMAJG.js

@@ -0,0 +1,106 @@
+// src/commands/claude.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+var SKILL_CONTENT = `---
+allowed-tools: Bash(dev-prism *)
+description: Manage isolated development sessions (create, list, start, stop, destroy)
+---
+
+# Dev Session Manager
+
+Manage isolated parallel development sessions using git worktrees and Docker.
+
+## Parse Intent from: $ARGUMENTS
+
+- "create" / "new" -> dev-prism create
+- "list" / "status" -> dev-prism list
+- "start <id>" -> dev-prism start <id>
+- "stop <id>" -> dev-prism stop <id>
+- "destroy <id>" -> dev-prism destroy <id>
+- "logs <id>" -> dev-prism logs <id>
+- "stop all" -> dev-prism stop-all
+- "prune" -> dev-prism prune
+
+## Commands
+
+Run from the project root (where session.config.mjs exists).
+
+After running commands, explain:
+1. What happened
+2. Relevant ports/paths
+3. Next steps
+
+Warn before destructive operations (destroy, prune).
+`;
+var CLAUDE_MD_SECTION = `
+## Dev Sessions
+
+Isolated parallel development sessions using git worktrees and Docker.
+
+### Commands
+\`\`\`bash
+dev-prism create [id]      # Create session (auto-assigns ID)
+dev-prism list             # Show all sessions with status
+dev-prism start <id>       # Start stopped session
+dev-prism stop <id>        # Stop session (preserves data)
+dev-prism stop-all         # Stop all running sessions
+dev-prism destroy <id>     # Remove session completely
+dev-prism logs <id>        # Stream Docker logs
+dev-prism prune            # Remove stopped sessions
+\`\`\`
+
+### Port Allocation
+Port = 47000 + (sessionId \xD7 100) + offset
+
+| Service | Offset | Session 001 |
+|---------|--------|-------------|
+| APP     | 0      | 47100       |
+| WEB     | 1      | 47101       |
+| POSTGRES| 10     | 47110       |
+
+### AI Notes
+- In sessions, use DATABASE_URL from \`.env.session\`
+- Run \`dev-prism list\` to discover ports
+- Commands run from project root, not session worktrees
+`;
+async function installClaude(projectRoot, options) {
+  const skillDir = join(projectRoot, ".claude", "commands");
+  const skillPath = join(skillDir, "session.md");
+  const claudeMdPath = join(projectRoot, "CLAUDE.md");
+  if (existsSync(skillPath) && !options.force) {
+    console.log(chalk.yellow(`Skill already exists: ${skillPath}`));
+    console.log(chalk.gray("Use --force to overwrite"));
+  } else {
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(skillPath, SKILL_CONTENT);
+    console.log(chalk.green(`Created: ${skillPath}`));
+  }
+  const marker = "## Dev Sessions";
+  if (existsSync(claudeMdPath)) {
+    const content = readFileSync(claudeMdPath, "utf-8");
+    if (content.includes(marker)) {
+      if (options.force) {
+        const beforeSection = content.split(marker)[0];
+        writeFileSync(claudeMdPath, beforeSection.trimEnd() + CLAUDE_MD_SECTION);
+        console.log(chalk.green(`Updated: ${claudeMdPath}`));
+      } else {
+        console.log(chalk.yellow("CLAUDE.md already has Dev Sessions section"));
+        console.log(chalk.gray("Use --force to overwrite"));
+      }
+    } else {
+      appendFileSync(claudeMdPath, CLAUDE_MD_SECTION);
+      console.log(chalk.green(`Updated: ${claudeMdPath}`));
+    }
+  } else {
+    writeFileSync(claudeMdPath, `# Project
+${CLAUDE_MD_SECTION}`);
+    console.log(chalk.green(`Created: ${claudeMdPath}`));
+  }
+  console.log(chalk.blue("\nClaude Code integration installed!"));
+  console.log(chalk.gray("Use /session in Claude Code to manage sessions."));
+}
+
+export {
+  installClaude
+};