@damper/cli 0.9.2 → 0.9.4

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/services/damper-api.d.ts

@@ -105,6 +105,17 @@ export declare class DamperApi {
         quarter?: string;
         sort?: 'importance' | 'newest' | 'votes';
         limit?: number;
+        offset?: number;
+    }): Promise<{
+        project: string;
+        tasks: Task[];
+        total: number;
+    }>;
+    listAllTasks(filters?: {
+        status?: 'planned' | 'in_progress' | 'done' | 'all';
+        type?: 'bug' | 'feature' | 'improvement' | 'task';
+        quarter?: string;
+        sort?: 'importance' | 'newest' | 'votes';
     }): Promise<{
         project: string;
         tasks: Task[];

package/dist/services/damper-api.js

@@ -40,9 +40,23 @@ export class DamperApi {
             params.set('sort', filters.sort);
         if (filters?.limit)
             params.set('limit', String(filters.limit));
+        if (filters?.offset)
+            params.set('offset', String(filters.offset));
         const query = params.toString();
         const data = await this.request('GET', `/api/agent/tasks${query ? `?${query}` : ''}`);
-        return { project: data.project.name, tasks: data.tasks };
+        return { project: data.project.name, tasks: data.tasks, total: data.total };
+    }
+    async listAllTasks(filters) {
+        const pageSize = 100;
+        const first = await this.listTasks({ ...filters, limit: pageSize });
+        const allTasks = [...first.tasks];
+        while (allTasks.length < first.total) {
+            const page = await this.listTasks({ ...filters, limit: pageSize, offset: allTasks.length });
+            allTasks.push(...page.tasks);
+            if (page.tasks.length === 0)
+                break; // safety: avoid infinite loop
+        }
+        return { project: first.project, tasks: allTasks };
     }
     async getTask(taskId) {
         return this.request('GET', `/api/agent/tasks/${taskId}`);

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)
@@ -118,12 +118,11 @@ function formatTaskChoice(choice, titleWidth, layout) {
 }
 export async function pickTask(options) {
     const { api, worktrees, typeFilter, statusFilter } = options;
-    // Fetch tasks from Damper
-    const { tasks, project } = await api.listTasks({
+    // Fetch all tasks from Damper (paginated)
+    const { tasks, project } = await api.listAllTasks({
         status: statusFilter || 'all',
         type: typeFilter,
         sort: 'importance',
-        limit: 100,
     });
     // Filter out completed tasks unless specifically requested
     const availableTasks = tasks.filter(t => statusFilter === 'done' || statusFilter === 'all' ||
@@ -168,40 +167,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 +174,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 +244,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 +288,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.2",
+  "version": "0.9.4",
   "description": "CLI tool for orchestrating Damper task workflows with Claude Code",
   "author": "Damper <hello@usedamper.com>",
   "repository": {