@damper/cli 0.9.1 → 0.9.3

package/dist/commands/start.js

@@ -1,10 +1,10 @@
 import * as fs from 'node:fs';
 import pc from 'picocolors';
 import { createDamperApi } from '../services/damper-api.js';
-import { createWorktree, getMainProjectRoot } from '../services/worktree.js';
+import { createWorktree, getMainProjectRoot, removeWorktreeDir } from '../services/worktree.js';
 import { bootstrapContext, refreshContext } from '../services/context-bootstrap.js';
 import { pickTask } from '../ui/task-picker.js';
-import { launchClaude, postTaskFlow, isClaudeInstalled, isDamperMcpConfigured, configureDamperMcp } from '../services/claude.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';
@@ -77,23 +77,39 @@ export async function startCommand(options) {
         }
     }
     else {
-        // Interactive task picker
-        const result = await pickTask({
-            api,
-            worktrees,
-            typeFilter: options.type,
-            statusFilter: options.status,
-        });
-        if (!result) {
-            process.exit(0);
-        }
-        taskId = result.task.id;
-        taskTitle = result.task.title;
-        isResume = result.isResume;
-        isNewTask = result.isNewTask || false;
-        forceTakeover = result.forceTakeover || options.force || false;
-        if (result.worktree) {
-            worktreePath = result.worktree.path;
+        // 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,
+            });
+            if (!result) {
+                process.exit(0);
+            }
+            if (result.action === 'review') {
+                await handleReviewAndComplete({
+                    api,
+                    apiKey,
+                    task: result.task,
+                    worktree: result.worktree,
+                    projectRoot,
+                });
+                continue;
+            }
+            // action is 'start' or 'resume' — break into normal flow
+            taskId = result.task.id;
+            taskTitle = result.task.title;
+            isResume = result.isResume;
+            isNewTask = result.isNewTask || false;
+            forceTakeover = result.forceTakeover || options.force || false;
+            if (result.worktree) {
+                worktreePath = result.worktree.path;
+            }
+            break;
         }
     }
     if (isResume && worktreePath) {
@@ -194,3 +210,103 @@ export async function startCommand(options) {
         isNewTask,
     });
 }
+/**
+ * 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 { 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}`));
+    // Lock the task
+    console.log(pc.dim('\nLocking task in Damper...'));
+    try {
+        await api.startTask(taskId, true);
+        console.log(pc.green('✓ Task locked'));
+    }
+    catch (err) {
+        const error = err;
+        console.log(pc.red(`Failed to lock task: ${error.message}`));
+        return;
+    }
+    // Launch Claude for review
+    console.log(pc.dim('\nLaunching Claude for review...\n'));
+    await launchClaudeForReview({ cwd, apiKey, taskId });
+    console.log(pc.dim('\n─────────────────────────────────────────\n'));
+    // Check task status after Claude exits
+    let taskStatus;
+    try {
+        const updatedTask = await api.getTask(taskId);
+        taskStatus = updatedTask.status;
+    }
+    catch {
+        console.log(pc.yellow('Could not fetch task status from Damper.'));
+    }
+    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;
+            try {
+                const { stdout } = await execa('git', ['log', '@{u}..HEAD', '--oneline'], { cwd, 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;
+                }
+            }
+            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?',
+                default: true,
+            });
+            if (shouldCleanup) {
+                try {
+                    await removeWorktreeDir(cwd, projectRoot);
+                    console.log(pc.green('✓ Worktree and branch removed'));
+                }
+                catch (err) {
+                    const error = err;
+                    console.log(pc.red(`Failed to remove worktree: ${error.message}`));
+                }
+            }
+        }
+    }
+    else {
+        // Not completed — release the lock
+        console.log(pc.yellow(`Task #${shortIdRaw(taskId)} not completed (status: ${taskStatus || 'unknown'})`));
+        try {
+            await api.abandonTask(taskId, 'Review session ended without completion');
+            console.log(pc.dim('Task lock released.'));
+        }
+        catch {
+            // Ignore — task may already be unlocked
+        }
+    }
+    console.log();
+}

package/dist/services/claude.d.ts

@@ -47,6 +47,14 @@ export declare function postTaskFlow(options: {
     projectRoot: string;
     isNewTask?: boolean;
 }): Promise<void>;
+/**
+ * Launch Claude to review and complete a task
+ */
+export declare function launchClaudeForReview(options: {
+    cwd: string;
+    apiKey: string;
+    taskId: string;
+}): Promise<void>;
 /**
  * Check if Claude Code CLI is installed
  */

package/dist/services/claude.js

@@ -441,6 +441,34 @@ export async function postTaskFlow(options) {
     }
     console.log();
 }
+/**
+ * Launch Claude to review and complete a task
+ */
+export async function launchClaudeForReview(options) {
+    const { cwd, apiKey, taskId } = options;
+    const prompt = [
+        `Review task #${taskId} and determine if it is ready to be marked as complete.`,
+        '',
+        'Steps:',
+        '1. Read TASK_CONTEXT.md (if it exists) to understand the requirements',
+        '2. Check git log and git diff main...HEAD to review what was done',
+        '3. Run the project tests (use `bun run test` from the monorepo root, NEVER `bun test`)',
+        '4. Check the completion checklist via get_project_settings MCP tool',
+        '5. If everything looks good, call complete_task via MCP with a summary and confirmations',
+        '6. If NOT ready, explain what is missing or broken — do NOT call complete_task',
+        '',
+        'IMPORTANT: Do NOT make any code changes. This is a review-only session.',
+    ].join('\n');
+    await new Promise((resolve) => {
+        const child = spawn('claude', [prompt], {
+            cwd,
+            stdio: 'inherit',
+            env: { ...process.env, DAMPER_API_KEY: apiKey },
+        });
+        child.on('error', () => resolve());
+        child.on('close', () => resolve());
+    });
+}
 /**
  * Launch Claude to resolve merge conflicts
  */

package/dist/templates/CLAUDE_APPEND.md.js

@@ -24,10 +24,11 @@ ${planSection}
 - \`.claude/settings.local.json\`
 
 **Your responsibilities (via Damper MCP):**
-1. Use \`add_commit\` after each git commit
-2. Use \`add_note\` ONLY for non-obvious approach decisions (e.g. "Decision: chose X because Y")
-3. When done: call \`complete_task\` with a one-line summary
-4. If stopping early: call \`abandon_task\` with what remains and blockers
+1. **Do NOT commit or complete tasks without explicit user confirmation** - Always ask the user before running \`git commit\` or calling \`complete_task\`
+2. Use \`add_commit\` after each git commit
+3. Use \`add_note\` ONLY for non-obvious approach decisions (e.g. "Decision: chose X because Y")
+4. When user confirms: call \`complete_task\` with a one-line summary
+5. If stopping early: call \`abandon_task\` with what remains and blockers
 
 The CLI just bootstrapped this environment - YOU handle the task lifecycle.
 `.trim();

package/dist/templates/TASK_CONTEXT.md.js

@@ -44,7 +44,8 @@ export function generateTaskContext(options) {
     lines.push('- Generated this TASK_CONTEXT.md from Damper API');
     lines.push('- Configured Damper MCP tools for task lifecycle');
     lines.push('');
-    lines.push('**Cleanup:** When done, call `complete_task` or `abandon_task`. The user will run');
+    lines.push('**Cleanup:** Ask the user for confirmation before committing or completing the task.');
+    lines.push('Once confirmed, call `complete_task` or `abandon_task`. The user will run');
     lines.push('`npx @damper/cli cleanup` to remove the worktree and branch - you don\'t need to');
     lines.push('provide manual cleanup instructions.');
     lines.push('');

package/dist/ui/task-picker.d.ts

@@ -12,6 +12,7 @@ interface TaskPickerResult {
     isResume: boolean;
     forceTakeover?: boolean;
     isNewTask?: boolean;
+    action: 'start' | 'resume' | 'review';
 }
 export declare function pickTask(options: TaskPickerOptions): Promise<TaskPickerResult | null>;
 export {};

package/dist/ui/task-picker.js

@@ -1,4 +1,4 @@
-import { select, confirm, input, Separator } from '@inquirer/prompts';
+import { search, select, confirm, input, Separator } from '@inquirer/prompts';
 import pc from 'picocolors';
 import { shortId, shortIdRaw, getTypeIcon, getPriorityIcon, formatEffort, formatProgressCompact, formatDueDate, sectionHeader, relativeTime, getTerminalWidth, padEnd, padStart, } from './format.js';
 // Layout constants (terminal column widths)
@@ -168,40 +168,6 @@ export async function pickTask(options) {
     ];
     const layout = getMetaLayout(allDisplayTasks, getTerminalWidth());
     const titleWidth = getTitleWidth(layout);
-    const choices = [];
-    if (inProgressChoices.length > 0) {
-        choices.push(new Separator(`\n${sectionHeader(`In Progress (${inProgressChoices.length})`)}`));
-        for (const choice of inProgressChoices) {
-            choices.push({
-                name: formatTaskChoice(choice, titleWidth, layout),
-                value: choice,
-            });
-        }
-    }
-    if (availableChoices.length > 0) {
-        choices.push(new Separator(`\n${sectionHeader(`Available (${availableChoices.length})`)}`));
-        for (const choice of availableChoices) {
-            choices.push({
-                name: formatTaskChoice(choice, titleWidth, layout),
-                value: choice,
-            });
-        }
-    }
-    if (lockedChoices.length > 0) {
-        choices.push(new Separator(`\n${sectionHeader(`Locked (${lockedChoices.length})`)}`));
-        for (const choice of lockedChoices) {
-            choices.push({
-                name: formatTaskChoice(choice, titleWidth, layout),
-                value: choice,
-            });
-        }
-    }
-    // Always show "Create new task" option
-    choices.push(new Separator(''));
-    choices.push({
-        name: pc.green('+ Create new task'),
-        value: { type: 'create_new' },
-    });
     if (inProgressChoices.length === 0 && availableChoices.length === 0 && lockedChoices.length === 0) {
         console.log(pc.yellow('\nNo existing tasks found.'));
         if (typeFilter) {
@@ -209,19 +175,58 @@ export async function pickTask(options) {
         }
     }
     console.log(pc.bold(`\nProject: ${project}`));
-    const selected = await select({
-        message: 'Select a task to work on:',
-        choices: choices,
+    // Build choices with search filtering support
+    const buildChoices = (term) => {
+        const lowerTerm = term?.toLowerCase().trim() || '';
+        const matches = (task) => !lowerTerm || task.title.toLowerCase().includes(lowerTerm) || task.id.includes(lowerTerm);
+        const filtered = [];
+        const filteredInProgress = inProgressChoices.filter(c => matches(c.task));
+        if (filteredInProgress.length > 0) {
+            filtered.push(new Separator(`\n${sectionHeader(`In Progress (${filteredInProgress.length})`)}`));
+            for (const choice of filteredInProgress) {
+                filtered.push({ name: formatTaskChoice(choice, titleWidth, layout), value: choice });
+            }
+        }
+        const filteredAvailable = availableChoices.filter(c => matches(c.task));
+        if (filteredAvailable.length > 0) {
+            filtered.push(new Separator(`\n${sectionHeader(`Available (${filteredAvailable.length})`)}`));
+            for (const choice of filteredAvailable) {
+                filtered.push({ name: formatTaskChoice(choice, titleWidth, layout), value: choice });
+            }
+        }
+        const filteredLocked = lockedChoices.filter(c => matches(c.task));
+        if (filteredLocked.length > 0) {
+            filtered.push(new Separator(`\n${sectionHeader(`Locked (${filteredLocked.length})`)}`));
+            for (const choice of filteredLocked) {
+                filtered.push({ name: formatTaskChoice(choice, titleWidth, layout), value: choice });
+            }
+        }
+        // Always show "Create new task"
+        filtered.push(new Separator(''));
+        filtered.push({ name: pc.green('+ Create new task'), value: { type: 'create_new' } });
+        return filtered;
+    };
+    const selected = await search({
+        message: 'Select a task (type to filter):',
+        source: (term) => buildChoices(term),
         pageSize: 20,
     });
     if (selected.type === 'create_new') {
         return handleCreateNewTask(api);
     }
     if (selected.type === 'in_progress') {
+        const action = await select({
+            message: `#${shortIdRaw(selected.task.id)} ${selected.task.title}`,
+            choices: [
+                { name: 'Resume working', value: 'resume' },
+                { name: 'Review & complete', value: 'review' },
+            ],
+        });
         return {
             task: selected.task,
             worktree: selected.worktree,
             isResume: true,
+            action,
         };
     }
     if (selected.type === 'locked') {
@@ -240,11 +245,20 @@ export async function pickTask(options) {
             task: selected.task,
             isResume: false,
             forceTakeover: true,
+            action: 'start',
         };
     }
+    const action = await select({
+        message: `#${shortIdRaw(selected.task.id)} ${selected.task.title}`,
+        choices: [
+            { name: 'Start working', value: 'start' },
+            { name: 'Quick complete', value: 'review' },
+        ],
+    });
     return {
         task: selected.task,
         isResume: false,
+        action,
     };
 }
 async function handleCreateNewTask(api) {
@@ -275,5 +289,6 @@ async function handleCreateNewTask(api) {
         task,
         isResume: false,
         isNewTask: true,
+        action: 'start',
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damper/cli",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "CLI tool for orchestrating Damper task workflows with Claude Code",
   "author": "Damper <hello@usedamper.com>",
   "repository": {