@damper/cli 0.1.0

package/dist/services/state.js

@@ -0,0 +1,77 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const STATE_DIR = path.join(os.homedir(), '.damper');
+const WORKTREES_FILE = path.join(STATE_DIR, 'worktrees.json');
+function ensureStateDir() {
+    if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+    }
+}
+function readState() {
+    ensureStateDir();
+    if (!fs.existsSync(WORKTREES_FILE)) {
+        return { worktrees: [] };
+    }
+    try {
+        const content = fs.readFileSync(WORKTREES_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { worktrees: [] };
+    }
+}
+function writeState(state) {
+    ensureStateDir();
+    fs.writeFileSync(WORKTREES_FILE, JSON.stringify(state, null, 2));
+}
+export function getWorktrees() {
+    return readState().worktrees;
+}
+export function getWorktreeByTaskId(taskId) {
+    return readState().worktrees.find(w => w.taskId === taskId);
+}
+export function getWorktreeByPath(worktreePath) {
+    const normalized = path.resolve(worktreePath);
+    return readState().worktrees.find(w => path.resolve(w.path) === normalized);
+}
+export function addWorktree(worktree) {
+    const state = readState();
+    // Remove any existing entry for this task or path
+    state.worktrees = state.worktrees.filter(w => w.taskId !== worktree.taskId && path.resolve(w.path) !== path.resolve(worktree.path));
+    state.worktrees.push(worktree);
+    writeState(state);
+}
+export function removeWorktree(taskId) {
+    const state = readState();
+    state.worktrees = state.worktrees.filter(w => w.taskId !== taskId);
+    writeState(state);
+}
+export function removeWorktreeByPath(worktreePath) {
+    const normalized = path.resolve(worktreePath);
+    const state = readState();
+    state.worktrees = state.worktrees.filter(w => path.resolve(w.path) !== normalized);
+    writeState(state);
+}
+export function cleanupStaleWorktrees() {
+    const state = readState();
+    const validWorktrees = [];
+    const staleWorktrees = [];
+    for (const w of state.worktrees) {
+        if (fs.existsSync(w.path)) {
+            validWorktrees.push(w);
+        }
+        else {
+            staleWorktrees.push(w);
+        }
+    }
+    if (staleWorktrees.length > 0) {
+        state.worktrees = validWorktrees;
+        writeState(state);
+    }
+    return staleWorktrees;
+}
+export function getWorktreesForProject(projectRoot) {
+    const normalized = path.resolve(projectRoot);
+    return readState().worktrees.filter(w => path.resolve(w.projectRoot) === normalized);
+}

package/dist/services/worktree.d.ts

@@ -0,0 +1,34 @@
+export interface WorktreeOptions {
+    taskId: string;
+    taskTitle: string;
+    projectRoot: string;
+}
+export interface WorktreeResult {
+    path: string;
+    branch: string;
+    isNew: boolean;
+}
+/**
+ * Create a new git worktree for a task
+ */
+export declare function createWorktree(options: WorktreeOptions): Promise<WorktreeResult>;
+/**
+ * Remove a git worktree
+ */
+export declare function removeWorktreeDir(worktreePath: string, projectRoot: string): Promise<void>;
+/**
+ * List all git worktrees for a project
+ */
+export declare function listWorktrees(projectRoot: string): Promise<Array<{
+    path: string;
+    branch: string;
+    head: string;
+}>>;
+/**
+ * Check if a path is inside a git worktree
+ */
+export declare function isInWorktree(dir: string): Promise<boolean>;
+/**
+ * Get the git root directory
+ */
+export declare function getGitRoot(dir: string): Promise<string>;

package/dist/services/worktree.js

@@ -0,0 +1,289 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { addWorktree, removeWorktree, getWorktreeByTaskId } from './state.js';
+/**
+ * Convert a task title to a safe slug for branch/directory names
+ */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 50);
+}
+/**
+ * Get the project name from package.json or directory name
+ */
+function getProjectName(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            if (pkg.name) {
+                // Strip scope if present
+                return pkg.name.replace(/^@[^/]+\//, '');
+            }
+        }
+        catch {
+            // Fall through to directory name
+        }
+    }
+    return path.basename(projectRoot);
+}
+/**
+ * Detect monorepo structure by looking for workspaces in package.json
+ */
+function detectMonorepoPackages(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return [];
+    }
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const workspaces = pkg.workspaces || [];
+        const packages = [];
+        for (const pattern of workspaces) {
+            // Simple glob expansion for common patterns
+            if (pattern.includes('*')) {
+                const base = pattern.replace(/\/\*$/, '').replace(/\*$/, '');
+                const basePath = path.join(projectRoot, base);
+                if (fs.existsSync(basePath) && fs.statSync(basePath).isDirectory()) {
+                    const dirs = fs.readdirSync(basePath).filter(d => {
+                        const fullPath = path.join(basePath, d);
+                        return fs.statSync(fullPath).isDirectory() &&
+                            fs.existsSync(path.join(fullPath, 'package.json'));
+                    });
+                    packages.push(...dirs.map(d => path.join(base, d)));
+                }
+            }
+            else {
+                // Direct path
+                const pkgPath = path.join(projectRoot, pattern);
+                if (fs.existsSync(path.join(pkgPath, 'package.json'))) {
+                    packages.push(pattern);
+                }
+            }
+        }
+        return packages;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find all node_modules directories to symlink
+ */
+function findNodeModulesDirs(projectRoot) {
+    const dirs = [];
+    // Root node_modules
+    const rootModules = path.join(projectRoot, 'node_modules');
+    if (fs.existsSync(rootModules)) {
+        dirs.push('node_modules');
+    }
+    // Monorepo package node_modules
+    const packages = detectMonorepoPackages(projectRoot);
+    for (const pkg of packages) {
+        const pkgModules = path.join(projectRoot, pkg, 'node_modules');
+        if (fs.existsSync(pkgModules)) {
+            dirs.push(path.join(pkg, 'node_modules'));
+        }
+    }
+    return dirs;
+}
+/**
+ * Find all .env files to copy
+ */
+function findEnvFiles(projectRoot) {
+    const envFiles = [];
+    // Root .env files
+    const rootEnvFiles = ['.env', '.env.local', '.env.development'];
+    for (const envFile of rootEnvFiles) {
+        if (fs.existsSync(path.join(projectRoot, envFile))) {
+            envFiles.push(envFile);
+        }
+    }
+    // Monorepo package .env files
+    const packages = detectMonorepoPackages(projectRoot);
+    for (const pkg of packages) {
+        for (const envFile of rootEnvFiles) {
+            const envPath = path.join(pkg, envFile);
+            if (fs.existsSync(path.join(projectRoot, envPath))) {
+                envFiles.push(envPath);
+            }
+        }
+    }
+    // Common server locations
+    const serverDirs = ['server', 'api', 'backend', 'packages/server'];
+    for (const serverDir of serverDirs) {
+        for (const envFile of rootEnvFiles) {
+            const envPath = path.join(serverDir, envFile);
+            if (fs.existsSync(path.join(projectRoot, envPath)) && !envFiles.includes(envPath)) {
+                envFiles.push(envPath);
+            }
+        }
+    }
+    return envFiles;
+}
+/**
+ * Create a new git worktree for a task
+ */
+export async function createWorktree(options) {
+    const { taskId, taskTitle, projectRoot } = options;
+    // Check if worktree already exists for this task
+    const existing = getWorktreeByTaskId(taskId);
+    if (existing && fs.existsSync(existing.path)) {
+        return {
+            path: existing.path,
+            branch: existing.branch,
+            isNew: false,
+        };
+    }
+    const projectName = getProjectName(projectRoot);
+    const slug = slugify(taskTitle);
+    const worktreePath = path.resolve(projectRoot, '..', `${projectName}-${slug}`);
+    const branchName = `feature/${slug}`;
+    // Create worktree
+    console.log(pc.dim(`Creating worktree at ${worktreePath}...`));
+    await execa('git', ['worktree', 'add', worktreePath, '-b', branchName], {
+        cwd: projectRoot,
+        stdio: 'pipe',
+    });
+    // Symlink node_modules
+    const nodeModulesDirs = findNodeModulesDirs(projectRoot);
+    for (const dir of nodeModulesDirs) {
+        const source = path.join(projectRoot, dir);
+        const target = path.join(worktreePath, dir);
+        // Ensure parent directory exists
+        const targetDir = path.dirname(target);
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+        console.log(pc.dim(`Linking ${dir}...`));
+        await fs.promises.symlink(source, target, 'junction');
+    }
+    // Copy .env files
+    const envFiles = findEnvFiles(projectRoot);
+    for (const envFile of envFiles) {
+        const source = path.join(projectRoot, envFile);
+        const target = path.join(worktreePath, envFile);
+        // Ensure parent directory exists
+        const targetDir = path.dirname(target);
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+        console.log(pc.dim(`Copying ${envFile}...`));
+        await fs.promises.copyFile(source, target);
+    }
+    // Save to state
+    const worktreeState = {
+        taskId,
+        path: worktreePath,
+        branch: branchName,
+        projectRoot,
+        createdAt: new Date().toISOString(),
+    };
+    addWorktree(worktreeState);
+    return {
+        path: worktreePath,
+        branch: branchName,
+        isNew: true,
+    };
+}
+/**
+ * Remove a git worktree
+ */
+export async function removeWorktreeDir(worktreePath, projectRoot) {
+    console.log(pc.dim(`Removing worktree at ${worktreePath}...`));
+    // Remove symlinks first to avoid issues
+    const nodeModulesDirs = findNodeModulesDirs(projectRoot);
+    for (const dir of nodeModulesDirs) {
+        const target = path.join(worktreePath, dir);
+        if (fs.existsSync(target)) {
+            try {
+                await fs.promises.unlink(target);
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+    // Remove worktree
+    await execa('git', ['worktree', 'remove', worktreePath, '--force'], {
+        cwd: projectRoot,
+        stdio: 'pipe',
+    });
+    // Get the worktree state to find the task ID
+    const state = await import('./state.js');
+    const worktree = state.getWorktreeByPath(worktreePath);
+    if (worktree) {
+        removeWorktree(worktree.taskId);
+    }
+}
+/**
+ * List all git worktrees for a project
+ */
+export async function listWorktrees(projectRoot) {
+    const { stdout } = await execa('git', ['worktree', 'list', '--porcelain'], {
+        cwd: projectRoot,
+        stdio: 'pipe',
+    });
+    const worktrees = [];
+    let current = {};
+    for (const line of stdout.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            current.path = line.slice(9);
+        }
+        else if (line.startsWith('HEAD ')) {
+            current.head = line.slice(5);
+        }
+        else if (line.startsWith('branch ')) {
+            current.branch = line.slice(7);
+        }
+        else if (line === '' && current.path) {
+            if (current.path && current.branch && current.head) {
+                worktrees.push({
+                    path: current.path,
+                    branch: current.branch,
+                    head: current.head,
+                });
+            }
+            current = {};
+        }
+    }
+    // Handle last entry
+    if (current.path && current.branch && current.head) {
+        worktrees.push({
+            path: current.path,
+            branch: current.branch,
+            head: current.head,
+        });
+    }
+    return worktrees;
+}
+/**
+ * Check if a path is inside a git worktree
+ */
+export async function isInWorktree(dir) {
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd: dir,
+            stdio: 'pipe',
+        });
+        return stdout.trim() === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the git root directory
+ */
+export async function getGitRoot(dir) {
+    const { stdout } = await execa('git', ['rev-parse', '--show-toplevel'], {
+        cwd: dir,
+        stdio: 'pipe',
+    });
+    return stdout.trim();
+}

package/dist/templates/CLAUDE_APPEND.md.d.ts

@@ -0,0 +1,6 @@
+interface ClaudeAppendOptions {
+    taskId: string;
+    taskTitle: string;
+}
+export declare function generateClaudeAppend(options: ClaudeAppendOptions): string;
+export {};

package/dist/templates/CLAUDE_APPEND.md.js

@@ -0,0 +1,17 @@
+export function generateClaudeAppend(options) {
+    const { taskId, taskTitle } = options;
+    return `
+## Current Task: #${taskId} ${taskTitle}
+
+**IMPORTANT**: Read TASK_CONTEXT.md for full task details and architecture context.
+If you feel you've lost context, re-read that file.
+
+**Your responsibilities (via Damper MCP):**
+1. Use \`add_commit\` after each git commit
+2. Use \`add_note\` for important decisions
+3. When done: call \`complete_task\` with summary
+4. If stopping early: call \`abandon_task\` with handoff notes
+
+The CLI just bootstrapped this environment - YOU handle the task lifecycle.
+`.trim();
+}

package/dist/templates/TASK_CONTEXT.md.d.ts

@@ -0,0 +1,15 @@
+import type { TaskDetail, ContextSection, Module } from '../services/damper-api.js';
+interface TaskContextOptions {
+    task: TaskDetail;
+    criticalRules: string[];
+    sections: ContextSection[];
+    templates: Array<{
+        name: string;
+        description?: string | null;
+        filePattern?: string | null;
+    }>;
+    modules: Module[];
+    damperInstructions: string;
+}
+export declare function generateTaskContext(options: TaskContextOptions): string;
+export {};

package/dist/templates/TASK_CONTEXT.md.js

@@ -0,0 +1,115 @@
+export function generateTaskContext(options) {
+    const { task, criticalRules, sections, templates, modules, damperInstructions } = options;
+    const typeIcon = task.type === 'bug' ? 'Bug' : task.type === 'feature' ? 'Feature' : task.type === 'improvement' ? 'Improvement' : 'Task';
+    const lines = [];
+    // Header
+    lines.push(`# Task: ${task.title} (#${task.id})`);
+    lines.push('');
+    lines.push(`**Type:** ${typeIcon} | **Status:** ${task.status} | **Priority:** ${task.priority || 'none'}`);
+    if (task.effort)
+        lines.push(`**Effort:** ${task.effort}`);
+    if (task.quarter)
+        lines.push(`**Quarter:** ${task.quarter}`);
+    lines.push('');
+    // Critical Rules
+    if (criticalRules.length > 0) {
+        lines.push('## Critical Rules (DO NOT SKIP)');
+        lines.push('');
+        for (const rule of criticalRules) {
+            lines.push(`- ${rule}`);
+        }
+        lines.push('');
+    }
+    // Damper Workflow
+    lines.push('## Damper Workflow');
+    lines.push('');
+    lines.push(damperInstructions);
+    lines.push('');
+    // Task Description
+    if (task.description) {
+        lines.push('## Task Description');
+        lines.push('');
+        lines.push(task.description);
+        lines.push('');
+    }
+    // Implementation Plan
+    if (task.implementationPlan) {
+        lines.push('## Implementation Plan');
+        lines.push('');
+        lines.push(task.implementationPlan);
+        lines.push('');
+    }
+    // Subtasks
+    if (task.subtasks && task.subtasks.length > 0) {
+        const done = task.subtasks.filter(s => s.done).length;
+        lines.push(`## Subtasks (${done}/${task.subtasks.length})`);
+        lines.push('');
+        for (const subtask of task.subtasks) {
+            lines.push(`- [${subtask.done ? 'x' : ' '}] ${subtask.title} (id: ${subtask.id})`);
+        }
+        lines.push('');
+    }
+    // Previous Session Notes
+    if (task.agentNotes) {
+        lines.push('## Previous Session Notes (IMPORTANT for continuity)');
+        lines.push('');
+        lines.push(task.agentNotes);
+        lines.push('');
+    }
+    // Previous Commits
+    if (task.commits && task.commits.length > 0) {
+        lines.push(`## Previous Commits (${task.commits.length})`);
+        lines.push('');
+        for (const commit of task.commits) {
+            lines.push(`- ${commit.hash.slice(0, 7)}: ${commit.message}`);
+        }
+        lines.push('');
+    }
+    // Project Context Sections
+    if (sections.length > 0) {
+        lines.push('## Relevant Architecture');
+        lines.push('');
+        for (const section of sections) {
+            lines.push(`### ${section.section}`);
+            lines.push('');
+            lines.push(section.content);
+            lines.push('');
+        }
+    }
+    // Templates
+    if (templates.length > 0) {
+        lines.push('## Templates Available');
+        lines.push('');
+        for (const template of templates) {
+            const pattern = template.filePattern ? ` (${template.filePattern})` : '';
+            const desc = template.description ? `: ${template.description}` : '';
+            lines.push(`- \`${template.name}\`${pattern}${desc}`);
+        }
+        lines.push('');
+    }
+    // Modules
+    if (modules.length > 0) {
+        lines.push('## Module Structure');
+        lines.push('');
+        for (const mod of modules) {
+            const port = mod.port ? ` (port ${mod.port})` : '';
+            const deps = mod.dependsOn && mod.dependsOn.length > 0 ? ` → ${mod.dependsOn.join(', ')}` : '';
+            lines.push(`- **${mod.name}**: ${mod.path}${port}${deps}`);
+        }
+        lines.push('');
+    }
+    // Linked Feedback
+    if (task.feedback && task.feedback.length > 0) {
+        lines.push('## Linked Feedback (customer requests driving this task)');
+        lines.push('');
+        for (const fb of task.feedback) {
+            lines.push(`- "${fb.title}" (${fb.voterCount} votes)`);
+        }
+        lines.push('');
+    }
+    // Footer
+    lines.push('---');
+    lines.push(`Generated by @damper/cli at ${new Date().toISOString()}.`);
+    lines.push('Re-read this file if conversation context is lost.');
+    return lines.join('\n');
+}

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

@@ -0,0 +1,15 @@
+import type { Task, DamperApi } from '../services/damper-api.js';
+import type { WorktreeState } from '../services/state.js';
+interface TaskPickerOptions {
+    api: DamperApi;
+    worktrees: WorktreeState[];
+    typeFilter?: 'bug' | 'feature' | 'improvement' | 'task';
+    statusFilter?: 'planned' | 'in_progress' | 'done' | 'all';
+}
+interface TaskPickerResult {
+    task: Task;
+    worktree?: WorktreeState;
+    isResume: boolean;
+}
+export declare function pickTask(options: TaskPickerOptions): Promise<TaskPickerResult | null>;
+export {};

package/dist/ui/task-picker.js

@@ -0,0 +1,121 @@
+import { select, Separator } from '@inquirer/prompts';
+import pc from 'picocolors';
+function getTypeIcon(type) {
+    switch (type) {
+        case 'bug': return pc.red('bug');
+        case 'feature': return pc.green('feature');
+        case 'improvement': return pc.blue('improvement');
+        default: return pc.gray('task');
+    }
+}
+function getPriorityIcon(priority) {
+    switch (priority) {
+        case 'high': return pc.red('!');
+        case 'medium': return pc.yellow('~');
+        default: return pc.dim('-');
+    }
+}
+function formatTaskChoice(choice) {
+    const { task } = choice;
+    const typeIcon = getTypeIcon(task.type);
+    const priorityIcon = getPriorityIcon(task.priority);
+    if (choice.type === 'in_progress') {
+        const worktreeName = choice.worktree.path.split('/').pop() || choice.worktree.path;
+        let description = `${pc.dim('#')}${pc.cyan(task.id)} ${task.title} ${pc.dim(`[${typeIcon}]`)} ${priorityIcon}`;
+        description += `\n    ${pc.dim(`Worktree: ${worktreeName}`)}`;
+        if (choice.lastNote) {
+            // Truncate long notes
+            const note = choice.lastNote.length > 60 ? choice.lastNote.slice(0, 60) + '...' : choice.lastNote;
+            description += `\n    ${pc.dim(`Last: "${note}"`)}`;
+        }
+        return description;
+    }
+    // Available task
+    let description = `${pc.dim('#')}${pc.cyan(task.id)} ${task.title} ${pc.dim(`[${typeIcon}]`)} ${priorityIcon}`;
+    if (task.quarter) {
+        description += ` ${pc.dim(task.quarter)}`;
+    }
+    if (task.hasImplementationPlan) {
+        description += pc.dim(' [plan]');
+    }
+    if (task.subtaskProgress) {
+        description += pc.dim(` [${task.subtaskProgress.done}/${task.subtaskProgress.total}]`);
+    }
+    return description;
+}
+export async function pickTask(options) {
+    const { api, worktrees, typeFilter, statusFilter } = options;
+    // Fetch tasks from Damper
+    const { tasks, project } = await api.listTasks({
+        status: statusFilter || 'all',
+        type: typeFilter,
+        sort: 'importance',
+    });
+    // Filter out completed tasks unless specifically requested
+    const availableTasks = tasks.filter(t => statusFilter === 'done' || statusFilter === 'all' ||
+        (t.status === 'planned' || t.status === 'in_progress'));
+    // Match worktrees with tasks
+    const inProgressChoices = [];
+    const worktreeTaskIds = new Set();
+    for (const worktree of worktrees) {
+        const task = tasks.find(t => t.id === worktree.taskId);
+        if (task) {
+            worktreeTaskIds.add(task.id);
+            // Get last note for display (we'd need to fetch task detail for this)
+            // For now, we'll leave it undefined - the API doesn't include notes in list
+            inProgressChoices.push({
+                type: 'in_progress',
+                task,
+                worktree,
+            });
+        }
+    }
+    // Available tasks are those not in our worktrees and either planned or in_progress
+    const availableChoices = availableTasks
+        .filter(t => !worktreeTaskIds.has(t.id) && (t.status === 'planned' || t.status === 'in_progress'))
+        .map(task => ({ type: 'available', task }));
+    if (inProgressChoices.length === 0 && availableChoices.length === 0) {
+        console.log(pc.yellow('\nNo tasks available.'));
+        if (typeFilter) {
+            console.log(pc.dim(`(filtered by type: ${typeFilter})`));
+        }
+        console.log(pc.dim('Create new tasks in Damper or check your filters.\n'));
+        return null;
+    }
+    const choices = [];
+    if (inProgressChoices.length > 0) {
+        choices.push(new Separator(pc.bold('\n--- In Progress (your worktrees) ---')));
+        for (const choice of inProgressChoices) {
+            choices.push({
+                name: formatTaskChoice(choice),
+                value: choice,
+            });
+        }
+    }
+    if (availableChoices.length > 0) {
+        choices.push(new Separator(pc.bold('\n--- Available Tasks ---')));
+        for (const choice of availableChoices) {
+            choices.push({
+                name: formatTaskChoice(choice),
+                value: choice,
+            });
+        }
+    }
+    console.log(pc.bold(`\nProject: ${project}`));
+    const selected = await select({
+        message: 'Select a task to work on:',
+        choices: choices,
+        pageSize: 15,
+    });
+    if (selected.type === 'in_progress') {
+        return {
+            task: selected.task,
+            worktree: selected.worktree,
+            isResume: true,
+        };
+    }
+    return {
+        task: selected.task,
+        isResume: false,
+    };
+}