@damper/cli 0.9.20 → 0.10.0

package/dist/commands/release.js

@@ -1,8 +1,7 @@
 import { confirm, select } from '@inquirer/prompts';
 import pc from 'picocolors';
 import { createDamperApi } from '../services/damper-api.js';
-import { getWorktrees, removeWorktree } from '../services/state.js';
-import { removeWorktreeDir, getGitRoot } from '../services/worktree.js';
+import { getGitRoot } from '../services/git.js';
 import { getApiKey } from '../services/config.js';
 import { shortId, shortIdRaw, getTypeIcon, getPriorityIcon, formatEffort } from '../ui/format.js';
 export async function releaseCommand() {
@@ -37,33 +36,26 @@ export async function releaseCommand() {
     console.log(pc.bold(`\nProject: ${project}`));
     console.log(pc.dim('Select a task to release back to planned status.\n'));
     // Build choices
-    const worktrees = getWorktrees();
     const choices = tasks.map(task => {
-        const worktree = worktrees.find(w => w.taskId === task.id);
         const priorityIcon = getPriorityIcon(task.priority);
         const typeIcon = getTypeIcon(task.type);
         const id = shortId(task.id);
         const effort = formatEffort(task.effort);
         const lockedInfo = task.lockedBy ? pc.dim(` (locked by ${task.lockedBy})`) : '';
-        const worktreeInfo = worktree ? pc.dim(` [has worktree]`) : '';
         return {
-            name: `${priorityIcon}${typeIcon} ${id}  ${task.title}${effort ? `  ${effort}` : ''}${lockedInfo}${worktreeInfo}`,
-            value: { task, worktree },
+            name: `${priorityIcon}${typeIcon} ${id}  ${task.title}${effort ? `  ${effort}` : ''}${lockedInfo}`,
+            value: task,
         };
     });
-    const selected = await select({
+    const task = await select({
         message: 'Select task to release:',
         choices,
     });
-    const { task, worktree } = selected;
     // Confirm
     console.log();
     console.log(pc.yellow(`This will:`));
     console.log(pc.dim(`  • Release the lock on task #${shortIdRaw(task.id)}`));
     console.log(pc.dim(`  • Set task status back to "planned"`));
-    if (worktree) {
-        console.log(pc.dim(`  • Optionally remove the worktree`));
-    }
     console.log();
     const shouldRelease = await confirm({
         message: 'Release this task?',
@@ -83,23 +75,5 @@ export async function releaseCommand() {
         console.log(pc.red(`\nFailed to release task: ${error.message}\n`));
         return;
     }
-    // Offer to remove worktree if exists
-    if (worktree) {
-        const shouldRemoveWorktree = await confirm({
-            message: 'Remove the worktree and branch?',
-            default: false,
-        });
-        if (shouldRemoveWorktree) {
-            try {
-                await removeWorktreeDir(worktree.path, worktree.projectRoot);
-                console.log(pc.green('✓ Worktree and branch removed'));
-            }
-            catch (err) {
-                const error = err;
-                console.log(pc.yellow(`Could not remove worktree: ${error.message}`));
-                removeWorktree(task.id); // At least clean up state
-            }
-        }
-    }
     console.log();
 }

package/dist/commands/setup.js

@@ -55,17 +55,9 @@ export async function setupCommand(options = {}) {
     if (!projectRoot) {
         console.log(pc.yellow('\n⚠️  Not in a git repository'));
         console.log(pc.dim('  Run this command from within a project to configure it.\n'));
-        // Still offer to set up global MCP if not configured
+        // Can't set up MCP without API key (HTTP transport needs it in headers)
         if (!mcpConfigured) {
-            const shouldSetupMcp = await confirm({
-                message: 'Set up Damper MCP globally (without API key)?',
-                default: true,
-            });
-            if (shouldSetupMcp) {
-                configureDamperMcp();
-                console.log(pc.green('\n✓ Damper MCP configured globally'));
-                console.log(pc.dim('  Run setup again from a project directory to add an API key.\n'));
-            }
+            console.log(pc.dim('\n  Run setup from a project directory to configure MCP with an API key.\n'));
         }
         return;
     }
@@ -142,7 +134,7 @@ export async function setupCommand(options = {}) {
     console.log(pc.green(`✓ Saved API key to ${getProjectConfigPath(projectRoot)}`));
     // Set up global MCP if not configured
     if (!mcpConfigured) {
-        configureDamperMcp();
+        configureDamperMcp(apiKey);
         console.log(pc.green('✓ Configured Damper MCP globally'));
     }
     // Remind about .gitignore

package/dist/commands/start.js

@@ -1,11 +1,8 @@
-import * as fs from 'node:fs';
 import pc from 'picocolors';
 import { createDamperApi } from '../services/damper-api.js';
-import { createWorktree, getMainProjectRoot, removeWorktreeDir } from '../services/worktree.js';
-import { bootstrapContext, refreshContext } from '../services/context-bootstrap.js';
+import { getGitRoot } from '../services/git.js';
 import { pickTask } from '../ui/task-picker.js';
 import { launchClaude, launchClaudeForReview, postTaskFlow, isClaudeInstalled, isDamperMcpConfigured, configureDamperMcp } from '../services/claude.js';
-import { getWorktreesForProject, cleanupStaleWorktrees } from '../services/state.js';
 import { getApiKey, isProjectConfigured, getProjectConfigPath } from '../services/config.js';
 import { shortIdRaw } from '../ui/format.js';
 export async function startCommand(options) {
@@ -16,10 +13,10 @@ export async function startCommand(options) {
         console.log(pc.dim('Install it with: npm install -g @anthropic-ai/claude-code\n'));
         process.exit(1);
     }
-    // Get project root (main repo, not a worktree)
+    // Get project root
     let projectRoot;
     try {
-        projectRoot = await getMainProjectRoot(process.cwd());
+        projectRoot = await getGitRoot(process.cwd());
     }
     catch {
         console.log(pc.red('\nError: Not in a git repository.'));
@@ -39,37 +36,27 @@ export async function startCommand(options) {
         }
         process.exit(1);
     }
-    // Ensure MCP is configured globally (without key - key comes from env)
+    // Ensure MCP is configured globally
     if (!isDamperMcpConfigured()) {
         console.log(pc.dim('Configuring Damper MCP...'));
-        configureDamperMcp();
+        configureDamperMcp(apiKey);
         console.log(pc.green('✓ Damper MCP configured'));
     }
     // Create API client with the project's key
     const api = createDamperApi(apiKey);
-    // Clean up stale worktrees
-    const stale = cleanupStaleWorktrees();
-    if (stale.length > 0) {
-        console.log(pc.dim(`Cleaned up ${stale.length} stale worktree reference(s)`));
-    }
-    // Get existing worktrees for this project
-    const worktrees = getWorktreesForProject(projectRoot);
     let taskId;
     let taskTitle;
     let isResume = false;
     let isNewTask = false;
-    let worktreePath;
     let forceTakeover = options.force || false;
     if (options.taskId) {
         // Direct task selection
         taskId = options.taskId;
         const task = await api.getTask(taskId);
         taskTitle = task.title;
-        // Check if we have an existing worktree for this task
-        const existingWorktree = worktrees.find(w => w.taskId === taskId);
-        if (existingWorktree && fs.existsSync(existingWorktree.path)) {
+        // Check if task is already in progress (resume)
+        if (task.status === 'in_progress') {
             isResume = true;
-            worktreePath = existingWorktree.path;
             console.log(pc.cyan(`\nResuming task #${shortIdRaw(taskId)}: ${taskTitle}`));
         }
         else {
@@ -79,11 +66,8 @@ export async function startCommand(options) {
     else {
         // Interactive task picker with review loop
         while (true) {
-            // Re-fetch worktrees each iteration (handles cleanup between reviews)
-            const currentWorktrees = getWorktreesForProject(projectRoot);
             const result = await pickTask({
                 api,
-                worktrees: currentWorktrees,
                 typeFilter: options.type,
                 statusFilter: options.status,
             });
@@ -95,7 +79,6 @@ export async function startCommand(options) {
                     api,
                     apiKey,
                     task: result.task,
-                    worktree: result.worktree,
                     projectRoot,
                 });
                 continue;
@@ -106,16 +89,10 @@ export async function startCommand(options) {
             isResume = result.isResume;
             isNewTask = result.isNewTask || false;
             forceTakeover = result.forceTakeover || options.force || false;
-            if (result.worktree) {
-                worktreePath = result.worktree.path;
-            }
             break;
         }
     }
-    if (isResume && worktreePath) {
-        // Resume existing worktree
-        console.log(pc.green(`\n✓ Resuming: #${shortIdRaw(taskId)} ${taskTitle}`));
-        console.log(pc.dim(`  Worktree: ${worktreePath}`));
+    if (isResume) {
         // Re-lock the task if it was previously released
         const task = await api.getTask(taskId);
         if (task.status !== 'in_progress' || !task.lockedBy) {
@@ -134,23 +111,12 @@ export async function startCommand(options) {
                 throw err;
             }
         }
-        // Refresh context with latest from Damper
-        console.log(pc.dim('\nRefreshing context from Damper...'));
-        await refreshContext({
-            api,
-            taskId,
-            worktreePath,
-            yolo: options.yolo,
-        });
-        console.log(pc.green('✓ Updated TASK_CONTEXT.md with latest notes'));
     }
     else {
         // New task - lock it first
         console.log(pc.dim('\nLocking task in Damper...'));
-        let completionChecklist;
         try {
-            const startResult = await api.startTask(taskId, forceTakeover);
-            completionChecklist = startResult.completionChecklist;
+            await api.startTask(taskId, forceTakeover);
             console.log(pc.green(forceTakeover ? '✓ Task lock taken over' : '✓ Task locked'));
         }
         catch (err) {
@@ -162,39 +128,10 @@ export async function startCommand(options) {
             }
             throw err;
         }
-        // Create worktree
-        console.log(pc.dim('\nSetting up worktree...'));
-        const worktreeResult = await createWorktree({
-            taskId,
-            taskTitle,
-            projectRoot,
-            apiKey,
-        });
-        worktreePath = worktreeResult.path;
-        if (worktreeResult.isNew) {
-            console.log(pc.green(`✓ Created worktree: ${worktreePath}`));
-            console.log(pc.dim(`  Branch: ${worktreeResult.branch}`));
-        }
-        else {
-            console.log(pc.green(`✓ Using existing worktree: ${worktreePath}`));
-        }
-        // Bootstrap context
-        console.log(pc.dim('\nBootstrapping context from Damper...'));
-        const bootstrapResult = await bootstrapContext({
-            api,
-            taskId,
-            worktreePath,
-            yolo: options.yolo,
-            completionChecklist,
-        });
-        console.log(pc.green(`✓ Created ${bootstrapResult.taskContextPath}`));
-        if (bootstrapResult.claudeMdUpdated) {
-            console.log(pc.green('✓ Updated CLAUDE.md with task section'));
-        }
     }
-    // Launch Claude with project's API key
+    // Launch Claude in project root
     const result = await launchClaude({
-        cwd: worktreePath,
+        cwd: projectRoot,
         taskId,
         taskTitle,
         apiKey,
@@ -214,14 +151,12 @@ export async function startCommand(options) {
  * Review a task and attempt to complete it via Claude, then return to the picker.
  */
 async function handleReviewAndComplete(options) {
-    const { api, apiKey, task, worktree, projectRoot } = options;
+    const { api, apiKey, task, projectRoot } = options;
     const { confirm } = await import('@inquirer/prompts');
     const { execa } = await import('execa');
     const taskId = task.id;
-    const cwd = worktree?.path || projectRoot;
-    const hasWorktree = !!worktree;
     console.log(pc.cyan(`\nReviewing task #${shortIdRaw(taskId)}: ${task.title}`));
-    console.log(pc.dim(`Directory: ${cwd}`));
+    console.log(pc.dim(`Directory: ${projectRoot}`));
     // Lock the task
     console.log(pc.dim('\nLocking task in Damper...'));
     try {
@@ -235,7 +170,7 @@ async function handleReviewAndComplete(options) {
     }
     // Launch Claude for review
     console.log(pc.dim('\nLaunching Claude for review...\n'));
-    await launchClaudeForReview({ cwd, apiKey, taskId });
+    await launchClaudeForReview({ cwd: projectRoot, apiKey, taskId });
     console.log(pc.dim('\n─────────────────────────────────────────\n'));
     // Check task status after Claude exits
     let taskStatus;
@@ -248,51 +183,34 @@ async function handleReviewAndComplete(options) {
     }
     if (taskStatus === 'done') {
         console.log(pc.green(`✓ Task #${shortIdRaw(taskId)} completed!`));
-        if (hasWorktree) {
-            // Check for unpushed commits and offer to push + cleanup
-            let hasUnpushed = false;
+        // Check for unpushed commits and offer to push
+        let hasUnpushed = false;
+        try {
+            const { stdout } = await execa('git', ['log', '@{u}..HEAD', '--oneline'], { cwd: projectRoot, stdio: 'pipe' });
+            hasUnpushed = stdout.trim().length > 0;
+        }
+        catch {
             try {
-                const { stdout } = await execa('git', ['log', '@{u}..HEAD', '--oneline'], { cwd, stdio: 'pipe' });
+                const { stdout } = await execa('git', ['log', 'origin/main..HEAD', '--oneline'], { cwd: projectRoot, stdio: 'pipe' });
                 hasUnpushed = stdout.trim().length > 0;
             }
             catch {
-                try {
-                    const { stdout } = await execa('git', ['log', 'origin/main..HEAD', '--oneline'], { cwd, stdio: 'pipe' });
-                    hasUnpushed = stdout.trim().length > 0;
-                }
-                catch {
-                    // Assume there might be commits
-                    hasUnpushed = true;
-                }
+                hasUnpushed = true;
             }
-            if (hasUnpushed) {
-                const shouldPush = await confirm({
-                    message: 'Push unpushed commits?',
-                    default: true,
-                });
-                if (shouldPush) {
-                    try {
-                        const { stdout: branch } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, stdio: 'pipe' });
-                        await execa('git', ['push', '-u', 'origin', branch.trim()], { cwd, stdio: 'inherit' });
-                        console.log(pc.green('✓ Pushed to remote'));
-                    }
-                    catch {
-                        console.log(pc.red('Failed to push. You can push manually.'));
-                    }
-                }
-            }
-            const shouldCleanup = await confirm({
-                message: 'Remove worktree and branch?',
+        }
+        if (hasUnpushed) {
+            const shouldPush = await confirm({
+                message: 'Push unpushed commits?',
                 default: true,
             });
-            if (shouldCleanup) {
+            if (shouldPush) {
                 try {
-                    await removeWorktreeDir(cwd, projectRoot);
-                    console.log(pc.green('✓ Worktree and branch removed'));
+                    const { stdout: branch } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: projectRoot, stdio: 'pipe' });
+                    await execa('git', ['push', '-u', 'origin', branch.trim()], { cwd: projectRoot, stdio: 'inherit' });
+                    console.log(pc.green('✓ Pushed to remote'));
                 }
-                catch (err) {
-                    const error = err;
-                    console.log(pc.red(`Failed to remove worktree: ${error.message}`));
+                catch {
+                    console.log(pc.red('Failed to push. You can push manually.'));
                 }
             }
         }

package/dist/index.js

@@ -1,8 +1,6 @@
 #!/usr/bin/env node
 import pc from 'picocolors';
 import { startCommand } from './commands/start.js';
-import { statusCommand } from './commands/status.js';
-import { cleanupCommand } from './commands/cleanup.js';
 import { setupCommand } from './commands/setup.js';
 import { releaseCommand } from './commands/release.js';
 import { createRequire } from 'node:module';
@@ -15,8 +13,6 @@ ${pc.bold('@damper/cli')} - Agent orchestration for Damper tasks
 ${pc.bold('Usage:')}
   npx @damper/cli                    Start working on a task (interactive picker)
   npx @damper/cli setup              Configure Damper MCP and API key
-  npx @damper/cli status             Show all in-progress worktrees
-  npx @damper/cli cleanup            Remove worktrees (completed, abandoned, or in-progress)
   npx @damper/cli release            Release a task back to planned status
 
 ${pc.bold('Options:')}
@@ -37,15 +33,13 @@ ${pc.bold('Examples:')}
   npx @damper/cli                    # Interactive task picker
   npx @damper/cli --task 42          # Start specific task
   npx @damper/cli --type bug         # Show only bugs
-  npx @damper/cli status             # List all worktrees
-  npx @damper/cli cleanup            # Clean up completed tasks
 
 ${pc.bold('Workflow:')}
   1. CLI picks task from Damper roadmap
-  2. Creates isolated git worktree
-  3. Bootstraps context (TASK_CONTEXT.md)
-  4. Launches Claude Code
-  5. Claude handles task lifecycle via MCP
+  2. Locks task via Damper API
+  3. Launches Claude Code with MCP context
+  4. Claude handles task lifecycle via MCP
+  5. Post-task: push, PR, merge, changelog
 
 ${pc.dim('More info: https://usedamper.com/docs/cli')}
 `);
@@ -114,12 +108,6 @@ async function main() {
             case 'setup':
                 await setupCommand(setupOptions);
                 break;
-            case 'status':
-                await statusCommand();
-                break;
-            case 'cleanup':
-                await cleanupCommand();
-                break;
             case 'release':
                 await releaseCommand();
                 break;

package/dist/services/claude.d.ts

@@ -1,7 +1,7 @@
-interface McpServerConfig {
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
+interface McpServerConfigHttp {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
 }
 /**
  * Check if Damper MCP is configured in Claude settings
@@ -13,15 +13,14 @@ export declare function isDamperMcpConfigured(): boolean;
  */
 export declare function getConfiguredApiKey(): string | undefined;
 /**
- * Get the recommended MCP configuration
- * Note: API key is passed via environment when launching Claude, not stored in config
+ * Get the recommended MCP configuration (hosted Streamable HTTP)
  */
-export declare function getDamperMcpConfig(): McpServerConfig;
+export declare function getDamperMcpConfig(apiKey?: string): McpServerConfigHttp;
 /**
  * Configure Damper MCP in Claude settings (global)
- * Note: API key is NOT stored here - it's passed via environment when launching Claude
+ * With HTTP transport, the API key is stored in the config headers.
  */
-export declare function configureDamperMcp(): void;
+export declare function configureDamperMcp(apiKey?: string): void;
 /**
  * Launch Claude Code in a directory
  */