@damper/cli 0.3.5 → 0.4.1

package/dist/commands/start.js

@@ -4,7 +4,7 @@ import { createDamperApi } from '../services/damper-api.js';
 import { createWorktree, getGitRoot } from '../services/worktree.js';
 import { bootstrapContext, refreshContext } from '../services/context-bootstrap.js';
 import { pickTask } from '../ui/task-picker.js';
-import { launchClaude, isClaudeInstalled, isDamperMcpConfigured, configureDamperMcp } from '../services/claude.js';
+import { launchClaude, postTaskFlow, isClaudeInstalled, isDamperMcpConfigured, configureDamperMcp } from '../services/claude.js';
 import { getWorktreesForProject, cleanupStaleWorktrees } from '../services/state.js';
 import { getApiKey, isProjectConfigured, getProjectConfigPath } from '../services/config.js';
 export async function startCommand(options) {
@@ -148,11 +148,18 @@ export async function startCommand(options) {
         }
     }
     // Launch Claude with project's API key
-    await launchClaude({
+    const result = await launchClaude({
         cwd: worktreePath,
         taskId,
         taskTitle,
         apiKey,
         yolo: options.yolo,
     });
+    // Post-task flow: push, PR, cleanup
+    await postTaskFlow({
+        cwd: result.cwd,
+        taskId: result.taskId,
+        apiKey: result.apiKey,
+        projectRoot,
+    });
 }

package/dist/index.js

@@ -4,7 +4,7 @@ import { startCommand } from './commands/start.js';
 import { statusCommand } from './commands/status.js';
 import { cleanupCommand } from './commands/cleanup.js';
 import { setupCommand } from './commands/setup.js';
-const VERSION = '0.3.5';
+const VERSION = '0.4.1';
 function showHelp() {
     console.log(`
 ${pc.bold('@damper/cli')} - Agent orchestration for Damper tasks

package/dist/services/claude.d.ts

@@ -31,6 +31,19 @@ export declare function launchClaude(options: {
     taskTitle: string;
     apiKey: string;
     yolo?: boolean;
+}): Promise<{
+    cwd: string;
+    taskId: string;
+    apiKey: string;
+}>;
+/**
+ * Post-task actions after Claude exits
+ */
+export declare function postTaskFlow(options: {
+    cwd: string;
+    taskId: string;
+    apiKey: string;
+    projectRoot: string;
 }): Promise<void>;
 /**
  * Check if Claude Code CLI is installed

package/dist/services/claude.js

@@ -162,7 +162,154 @@ Once approved, switch to implementation and start logging your work.
             console.log(pc.dim('Install it with: npm install -g @anthropic-ai/claude-code\n'));
             process.exit(1);
         }
-        throw err;
+        // Claude exited with error - still continue to post-task flow
+    }
+    // Post-task flow
+    console.log(pc.dim('\n─────────────────────────────────────────'));
+    console.log(pc.bold('\nClaude session ended.\n'));
+    return { cwd, taskId, apiKey };
+}
+/**
+ * Post-task actions after Claude exits
+ */
+export async function postTaskFlow(options) {
+    const { cwd, taskId, apiKey, projectRoot } = options;
+    const { confirm, select } = await import('@inquirer/prompts');
+    const { createDamperApi } = await import('./damper-api.js');
+    const { removeWorktreeDir } = await import('./worktree.js');
+    const { removeWorktree } = await import('./state.js');
+    // Check task status from Damper
+    let taskStatus;
+    let taskTitle;
+    try {
+        const api = createDamperApi(apiKey);
+        const task = await api.getTask(taskId);
+        taskStatus = task.status;
+        taskTitle = task.title;
+    }
+    catch {
+        console.log(pc.yellow('Could not fetch task status from Damper.'));
+    }
+    // Check git status
+    let hasUnpushedCommits = false;
+    let hasUncommittedChanges = false;
+    let currentBranch = '';
+    try {
+        const { execa } = await import('execa');
+        // Get current branch
+        const { stdout: branch } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, stdio: 'pipe' });
+        currentBranch = branch.trim();
+        // Check for uncommitted changes
+        const { stdout: status } = await execa('git', ['status', '--porcelain'], { cwd, stdio: 'pipe' });
+        hasUncommittedChanges = status.trim().length > 0;
+        // Check for unpushed commits
+        try {
+            const { stdout: unpushed } = await execa('git', ['log', '@{u}..HEAD', '--oneline'], { cwd, stdio: 'pipe' });
+            hasUnpushedCommits = unpushed.trim().length > 0;
+        }
+        catch {
+            // No upstream branch - assume all commits are unpushed
+            const { stdout: commits } = await execa('git', ['log', 'main..HEAD', '--oneline'], { cwd, stdio: 'pipe' });
+            hasUnpushedCommits = commits.trim().length > 0;
+        }
+    }
+    catch {
+        // Ignore git errors
+    }
+    // Show status
+    if (taskStatus) {
+        const statusColor = taskStatus === 'done' ? pc.green : taskStatus === 'in_progress' ? pc.yellow : pc.dim;
+        console.log(`Task status: ${statusColor(taskStatus)}`);
+    }
+    if (currentBranch) {
+        console.log(`Branch: ${pc.cyan(currentBranch)}`);
+    }
+    if (hasUncommittedChanges) {
+        console.log(pc.yellow('⚠ Uncommitted changes detected'));
+    }
+    if (hasUnpushedCommits) {
+        console.log(pc.yellow('⚠ Unpushed commits detected'));
+    }
+    console.log();
+    // Offer actions based on state
+    if (hasUncommittedChanges) {
+        console.log(pc.dim('You have uncommitted changes. Commit them before pushing.\n'));
+    }
+    if (hasUnpushedCommits && !hasUncommittedChanges) {
+        const { select } = await import('@inquirer/prompts');
+        const mergeAction = await select({
+            message: 'How do you want to merge your changes?',
+            choices: [
+                { name: 'Create a pull request', value: 'pr' },
+                { name: 'Merge directly to main', value: 'merge' },
+                { name: 'Just push (decide later)', value: 'push' },
+                { name: 'Skip (keep local)', value: 'skip' },
+            ],
+        });
+        if (mergeAction === 'skip') {
+            console.log(pc.dim('Keeping changes local.\n'));
+        }
+        else if (mergeAction === 'merge') {
+            // Merge directly to main
+            try {
+                const { execa } = await import('execa');
+                console.log(pc.dim('Switching to main and merging...'));
+                // Fetch latest main
+                await execa('git', ['fetch', 'origin', 'main'], { cwd, stdio: 'pipe' });
+                // Checkout main in the main project root (not worktree)
+                await execa('git', ['checkout', 'main'], { cwd: projectRoot, stdio: 'pipe' });
+                // Merge the feature branch
+                await execa('git', ['merge', currentBranch, '--no-edit'], { cwd: projectRoot, stdio: 'inherit' });
+                // Push main
+                await execa('git', ['push', 'origin', 'main'], { cwd: projectRoot, stdio: 'inherit' });
+                console.log(pc.green('✓ Merged to main and pushed\n'));
+            }
+            catch (err) {
+                console.log(pc.red('Failed to merge. You may need to resolve conflicts manually.\n'));
+            }
+        }
+        else {
+            // Push first (needed for both 'pr' and 'push')
+            try {
+                const { execa } = await import('execa');
+                await execa('git', ['push', '-u', 'origin', currentBranch], { cwd, stdio: 'inherit' });
+                console.log(pc.green('✓ Pushed to remote\n'));
+                // Create PR if requested
+                if (mergeAction === 'pr') {
+                    try {
+                        await execa('gh', ['pr', 'create', '--fill'], { cwd, stdio: 'inherit' });
+                    }
+                    catch {
+                        console.log(pc.yellow('Could not create PR. You can create it manually on GitHub.\n'));
+                    }
+                }
+            }
+            catch {
+                console.log(pc.red('Failed to push. You can push manually.\n'));
+            }
+        }
+    }
+    // Offer cleanup if task is done or abandoned
+    if (taskStatus === 'done' || taskStatus === 'planned') {
+        const statusText = taskStatus === 'done' ? 'completed' : 'not started/abandoned';
+        const shouldCleanup = await confirm({
+            message: `Task is ${statusText}. Remove worktree and branch?`,
+            default: taskStatus === 'done',
+        });
+        if (shouldCleanup) {
+            try {
+                await removeWorktreeDir(cwd, projectRoot);
+                console.log(pc.green('✓ Worktree and branch removed\n'));
+            }
+            catch (err) {
+                const error = err;
+                console.log(pc.red(`Failed to remove worktree: ${error.message}\n`));
+            }
+        }
+    }
+    else if (taskStatus === 'in_progress') {
+        console.log(pc.dim('Task is still in progress. Run `npx @damper/cli` to resume later.'));
+        console.log(pc.dim('Run `npx @damper/cli cleanup` when ready to remove the worktree.\n'));
     }
 }
 /**

package/package.json

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