@damper/cli 0.9.20 → 0.10.0

package/dist/commands/cleanup.js

@@ -1,203 +0,0 @@
-import * as fs from 'node:fs';
-import { confirm, checkbox } from '@inquirer/prompts';
-import { execa } from 'execa';
-import pc from 'picocolors';
-import { getWorktrees, cleanupStaleWorktrees, removeWorktree } from '../services/state.js';
-import { createDamperApi } from '../services/damper-api.js';
-import { removeWorktreeDir } from '../services/worktree.js';
-import { shortId, shortIdRaw, formatTaskLine } from '../ui/format.js';
-async function hasUncommittedChanges(worktreePath) {
-    try {
-        const { stdout } = await execa('git', ['status', '--porcelain'], {
-            cwd: worktreePath,
-            stdio: 'pipe',
-        });
-        return stdout.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-export async function cleanupCommand() {
-    // Clean up stale entries first
-    const stale = cleanupStaleWorktrees();
-    if (stale.length > 0) {
-        console.log(pc.dim(`Removed ${stale.length} stale worktree reference(s)`));
-    }
-    const worktrees = getWorktrees();
-    if (worktrees.length === 0) {
-        console.log(pc.yellow('\nNo tracked worktrees found.'));
-        return;
-    }
-    // Try to connect to Damper for task status
-    let api;
-    try {
-        api = createDamperApi();
-    }
-    catch {
-        console.log(pc.yellow('\nWarning: Could not connect to Damper API (no API key).'));
-        console.log(pc.dim('Will show all worktrees for manual selection.\n'));
-    }
-    // Identify cleanup candidates
-    const candidates = [];
-    console.log(pc.dim('\nAnalyzing worktrees...'));
-    for (const wt of worktrees) {
-        const exists = fs.existsSync(wt.path);
-        if (!exists) {
-            // Worktree directory is missing
-            candidates.push({
-                worktree: wt,
-                reason: 'missing',
-            });
-            continue;
-        }
-        // Check for uncommitted changes
-        const uncommitted = await hasUncommittedChanges(wt.path);
-        if (api) {
-            try {
-                const task = await api.getTask(wt.taskId);
-                if (task.status === 'done') {
-                    candidates.push({
-                        worktree: wt,
-                        task,
-                        reason: 'completed',
-                        hasUncommittedChanges: uncommitted,
-                    });
-                }
-                else if (task.status === 'planned' && !task.lockedBy) {
-                    // Task was abandoned (planned and not locked)
-                    candidates.push({
-                        worktree: wt,
-                        task,
-                        reason: 'abandoned',
-                        hasUncommittedChanges: uncommitted,
-                    });
-                }
-                else if (task.status === 'in_progress') {
-                    // Task is still in progress - can drop it
-                    candidates.push({
-                        worktree: wt,
-                        task,
-                        reason: 'in_progress',
-                        hasUncommittedChanges: uncommitted,
-                    });
-                }
-            }
-            catch {
-                // Could not fetch task - might be deleted
-                candidates.push({
-                    worktree: wt,
-                    reason: 'manual',
-                    hasUncommittedChanges: uncommitted,
-                });
-            }
-        }
-        else {
-            // No API - show all for manual selection
-            candidates.push({
-                worktree: wt,
-                reason: 'manual',
-                hasUncommittedChanges: uncommitted,
-            });
-        }
-    }
-    if (candidates.length === 0) {
-        console.log(pc.green('\n✓ No worktrees to clean up.\n'));
-        return;
-    }
-    // Show candidates and let user select
-    console.log(pc.bold('\nWorktrees available for cleanup:\n'));
-    const choices = candidates.map(c => {
-        const worktreeName = c.worktree.path.split('/').pop() || c.worktree.path;
-        let description = c.task ? formatTaskLine(c.task) : shortId(c.worktree.taskId);
-        let reasonBadge = '';
-        switch (c.reason) {
-            case 'completed':
-                reasonBadge = pc.green('[completed]');
-                break;
-            case 'abandoned':
-                reasonBadge = pc.yellow('[abandoned]');
-                break;
-            case 'in_progress':
-                reasonBadge = pc.cyan('[in progress - will release]');
-                break;
-            case 'missing':
-                reasonBadge = pc.red('[missing]');
-                break;
-            case 'manual':
-                reasonBadge = pc.dim('[manual]');
-                break;
-        }
-        // Warning for uncommitted changes
-        const uncommittedWarning = c.hasUncommittedChanges
-            ? pc.red(' ⚠ uncommitted changes')
-            : '';
-        return {
-            name: `${description} ${reasonBadge}${uncommittedWarning}\n    ${pc.dim(worktreeName)}`,
-            value: c,
-            // Don't auto-check if there are uncommitted changes
-            checked: (c.reason === 'completed' || c.reason === 'missing') && !c.hasUncommittedChanges,
-        };
-    });
-    const selected = await checkbox({
-        message: 'Select worktrees to remove:',
-        choices,
-        pageSize: 10,
-    });
-    if (selected.length === 0) {
-        console.log(pc.dim('\nNo worktrees selected. Nothing to clean up.\n'));
-        return;
-    }
-    // Check for uncommitted changes in selected worktrees
-    const withUncommitted = selected.filter(c => c.hasUncommittedChanges);
-    if (withUncommitted.length > 0) {
-        console.log(pc.yellow(`\n⚠ Warning: ${withUncommitted.length} worktree(s) have uncommitted changes that will be lost!`));
-    }
-    // Confirm
-    const confirmMessage = withUncommitted.length > 0
-        ? `Remove ${selected.length} worktree(s)? (${withUncommitted.length} with uncommitted changes)`
-        : `Remove ${selected.length} worktree(s)?`;
-    const confirmed = await confirm({
-        message: confirmMessage,
-        default: false,
-    });
-    if (!confirmed) {
-        console.log(pc.dim('\nCancelled.\n'));
-        return;
-    }
-    // Remove selected worktrees
-    console.log();
-    for (const candidate of selected) {
-        const { worktree } = candidate;
-        const worktreeName = worktree.path.split('/').pop() || worktree.path;
-        try {
-            // Release the task first if it's in progress
-            if (candidate.reason === 'in_progress' && api) {
-                try {
-                    await api.abandonTask(worktree.taskId, 'Dropped via CLI cleanup');
-                    console.log(pc.green(`✓ Released task #${shortIdRaw(worktree.taskId)}`));
-                }
-                catch (err) {
-                    const error = err;
-                    console.log(pc.yellow(`⚠ Could not release task: ${error.message}`));
-                    // Continue with worktree removal anyway
-                }
-            }
-            if (candidate.reason === 'missing') {
-                // Just remove from state
-                removeWorktree(worktree.taskId);
-                console.log(pc.green(`✓ Removed reference: ${worktreeName}`));
-            }
-            else {
-                // Remove actual worktree
-                await removeWorktreeDir(worktree.path, worktree.projectRoot);
-                console.log(pc.green(`✓ Removed: ${worktreeName}`));
-            }
-        }
-        catch (err) {
-            const error = err;
-            console.log(pc.red(`✗ Failed to remove ${worktreeName}: ${error.message}`));
-        }
-    }
-    console.log();
-}

package/dist/commands/status.d.ts

@@ -1 +0,0 @@
-export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -1,94 +0,0 @@
-import * as fs from 'node:fs';
-import pc from 'picocolors';
-import { getWorktrees, cleanupStaleWorktrees } from '../services/state.js';
-import { createDamperApi } from '../services/damper-api.js';
-import { getGitRoot } from '../services/worktree.js';
-import { shortId, getTypeIcon, getPriorityIcon, formatEffort, formatSubtaskProgress, relativeTime, statusColor as getStatusColor, } from '../ui/format.js';
-export async function statusCommand() {
-    // Clean up stale entries first
-    const stale = cleanupStaleWorktrees();
-    if (stale.length > 0) {
-        console.log(pc.dim(`Cleaned up ${stale.length} stale worktree reference(s)\n`));
-    }
-    // Get current project root
-    let projectRoot;
-    try {
-        projectRoot = await getGitRoot(process.cwd());
-    }
-    catch {
-        // Not in a git repo - show all worktrees
-    }
-    const worktrees = getWorktrees();
-    if (worktrees.length === 0) {
-        console.log(pc.yellow('\nNo tracked worktrees found.'));
-        console.log(pc.dim('Use `npx @damper/cli` to start working on a task.\n'));
-        return;
-    }
-    // Try to fetch task statuses from Damper
-    let api;
-    try {
-        api = createDamperApi();
-    }
-    catch {
-        // No API key - show worktrees without status
-    }
-    console.log(pc.bold('\nTracked Worktrees:\n'));
-    // Group by project
-    const byProject = new Map();
-    for (const wt of worktrees) {
-        const project = wt.projectRoot;
-        if (!byProject.has(project)) {
-            byProject.set(project, []);
-        }
-        byProject.get(project).push(wt);
-    }
-    for (const [project, projectWorktrees] of byProject) {
-        const isCurrent = projectRoot && project === projectRoot;
-        const projectName = project.split('/').pop() || project;
-        console.log(pc.bold(`${projectName}${isCurrent ? pc.cyan(' (current)') : ''}`));
-        console.log(pc.dim(`  ${project}`));
-        console.log();
-        for (const wt of projectWorktrees) {
-            const exists = fs.existsSync(wt.path);
-            const statusIcon = exists ? pc.green('●') : pc.red('○');
-            // Try to get task details from Damper
-            if (api) {
-                try {
-                    const task = await api.getTask(wt.taskId);
-                    const priorityIcon = getPriorityIcon(task.priority);
-                    const typeIcon = getTypeIcon(task.type);
-                    const colorFn = getStatusColor(task.status);
-                    const statusBadge = colorFn(`[${task.status}]`);
-                    const effort = formatEffort(task.effort);
-                    const progress = formatSubtaskProgress(task.subtaskProgress);
-                    const time = relativeTime(wt.createdAt);
-                    console.log(`  ${statusIcon} ${priorityIcon}${typeIcon} ${shortId(task.id)}  ${task.title} ${statusBadge}${effort ? `  ${effort}` : ''}`);
-                    const metaParts = [wt.branch];
-                    if (time)
-                        metaParts.push(time);
-                    if (progress)
-                        metaParts.push(progress);
-                    console.log(`    ${metaParts.join(` ${pc.dim('\u00B7')} `)}`);
-                }
-                catch {
-                    console.log(`  ${statusIcon} ${shortId(wt.taskId)} ${pc.dim('[unknown]')}`);
-                    const time = relativeTime(wt.createdAt);
-                    const metaParts = [wt.branch];
-                    if (time)
-                        metaParts.push(time);
-                    console.log(`    ${metaParts.join(` ${pc.dim('\u00B7')} `)}`);
-                }
-            }
-            else {
-                console.log(`  ${statusIcon} ${shortId(wt.taskId)}`);
-                const time = relativeTime(wt.createdAt);
-                const metaParts = [wt.branch];
-                if (time)
-                    metaParts.push(time);
-                console.log(`    ${metaParts.join(` ${pc.dim('\u00B7')} `)}`);
-            }
-            console.log();
-        }
-    }
-    console.log(pc.dim('Use `npx @damper/cli cleanup` to remove worktrees for completed tasks.\n'));
-}

package/dist/services/context-bootstrap.d.ts

@@ -1,30 +0,0 @@
-import type { DamperApi } from './damper-api.js';
-export interface BootstrapOptions {
-    api: DamperApi;
-    taskId: string;
-    worktreePath: string;
-    yolo?: boolean;
-    completionChecklist?: string[];
-}
-export interface BootstrapResult {
-    taskContextPath: string;
-    claudeMdUpdated: boolean;
-}
-export interface SectionBlockIndex {
-    section: string;
-    blocks: Array<{
-        id: string;
-        heading: string | null;
-        level: number;
-        charCount: number;
-    }>;
-    totalChars: number;
-}
-/**
- * Fetch all relevant context from Damper and write local files
- */
-export declare function bootstrapContext(options: BootstrapOptions): Promise<BootstrapResult>;
-/**
- * Refresh TASK_CONTEXT.md with latest data from Damper (for resume scenarios)
- */
-export declare function refreshContext(options: BootstrapOptions): Promise<BootstrapResult>;

package/dist/services/context-bootstrap.js

@@ -1,100 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import pc from 'picocolors';
-import { generateTaskContext } from '../templates/TASK_CONTEXT.md.js';
-import { generateClaudeAppend } from '../templates/CLAUDE_APPEND.md.js';
-const TASK_CONTEXT_FILE = 'TASK_CONTEXT.md';
-const CLAUDE_MD_FILE = 'CLAUDE.md';
-const TASK_SECTION_MARKER = '## Current Task:';
-/**
- * Fetch block indices for relevant sections.
- * Only fetches the headings/structure - no content.
- * The agent will use get_section_block_content to load what it needs.
- */
-async function fetchBlockIndices(api, relevantSections) {
-    const indices = [];
-    for (const sectionName of relevantSections) {
-        try {
-            const blockIndex = await api.getSectionBlocks(sectionName);
-            indices.push(blockIndex);
-        }
-        catch {
-            console.log(pc.dim(`  Could not fetch blocks for: ${sectionName}`));
-        }
-    }
-    return indices;
-}
-/**
- * Fetch all relevant context from Damper and write local files
- */
-export async function bootstrapContext(options) {
-    const { api, taskId, worktreePath } = options;
-    console.log(pc.dim('Fetching task details...'));
-    const task = await api.getTask(taskId);
-    console.log(pc.dim('Fetching project context...'));
-    const context = await api.getProjectContext(taskId);
-    // Fetch block indices (not content) for relevant sections
-    const relevantSections = context.relevantSections || [];
-    let blockIndices = [];
-    if (relevantSections.length > 0) {
-        console.log(pc.dim(`Fetching block indices for ${relevantSections.length} relevant sections...`));
-        blockIndices = await fetchBlockIndices(api, relevantSections);
-    }
-    // Fetch templates
-    console.log(pc.dim('Fetching templates...'));
-    const templatesResult = await api.listTemplates();
-    const templates = templatesResult.isEmpty ? [] : templatesResult.templates;
-    // Fetch modules
-    console.log(pc.dim('Fetching modules...'));
-    const modulesResult = await api.listModules();
-    const modules = modulesResult.isEmpty ? [] : modulesResult.modules;
-    // Get agent instructions
-    console.log(pc.dim('Fetching Damper workflow instructions...'));
-    const instructions = await api.getAgentInstructions('section');
-    // Generate TASK_CONTEXT.md
-    const taskContext = generateTaskContext({
-        task,
-        criticalRules: context.criticalRules || [],
-        completionChecklist: options.completionChecklist,
-        blockIndices,
-        templates,
-        modules,
-        damperInstructions: instructions.content,
-    });
-    // Write TASK_CONTEXT.md
-    const taskContextPath = path.join(worktreePath, TASK_CONTEXT_FILE);
-    console.log(pc.dim(`Writing ${TASK_CONTEXT_FILE}...`));
-    await fs.promises.writeFile(taskContextPath, taskContext, 'utf-8');
-    // Update CLAUDE.md with task section
-    const claudeMdPath = path.join(worktreePath, CLAUDE_MD_FILE);
-    let claudeMdUpdated = false;
-    if (fs.existsSync(claudeMdPath)) {
-        console.log(pc.dim(`Updating ${CLAUDE_MD_FILE}...`));
-        let claudeMd = await fs.promises.readFile(claudeMdPath, 'utf-8');
-        // Remove any existing task section
-        const markerIndex = claudeMd.indexOf(TASK_SECTION_MARKER);
-        if (markerIndex !== -1) {
-            claudeMd = claudeMd.slice(0, markerIndex).trimEnd();
-        }
-        // Append new task section
-        const taskSection = generateClaudeAppend({
-            taskId,
-            taskTitle: task.title,
-            yolo: options.yolo,
-        });
-        claudeMd = `${claudeMd}\n\n${taskSection}\n`;
-        await fs.promises.writeFile(claudeMdPath, claudeMd, 'utf-8');
-        claudeMdUpdated = true;
-    }
-    return {
-        taskContextPath,
-        claudeMdUpdated,
-    };
-}
-/**
- * Refresh TASK_CONTEXT.md with latest data from Damper (for resume scenarios)
- */
-export async function refreshContext(options) {
-    // For now, just run bootstrap again - it will overwrite with fresh data
-    return bootstrapContext(options);
-}

package/dist/services/state.d.ts

@@ -1,22 +0,0 @@
-export interface WorktreeState {
-    taskId: string;
-    path: string;
-    branch: string;
-    projectRoot: string;
-    createdAt: string;
-}
-export declare function getWorktrees(): WorktreeState[];
-export declare function getWorktreeByTaskId(taskId: string): WorktreeState | undefined;
-export declare function getWorktreeByPath(worktreePath: string): WorktreeState | undefined;
-export declare function addWorktree(worktree: WorktreeState): void;
-export declare function removeWorktree(taskId: string): void;
-export declare function removeWorktreeByPath(worktreePath: string): void;
-export declare function cleanupStaleWorktrees(): WorktreeState[];
-export declare function getWorktreesForProject(projectRoot: string): WorktreeState[];
-interface Preferences {
-    tmuxPromptDismissed?: boolean;
-    [key: string]: unknown;
-}
-export declare function getPreference<K extends keyof Preferences>(key: K): Preferences[K];
-export declare function setPreference<K extends keyof Preferences>(key: K, value: Preferences[K]): void;
-export {};

package/dist/services/state.js

@@ -1,102 +0,0 @@
-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);
-}
-// ── Preferences (persistent user choices) ──
-const PREFS_FILE = path.join(STATE_DIR, 'preferences.json');
-function readPrefs() {
-    ensureStateDir();
-    if (!fs.existsSync(PREFS_FILE))
-        return {};
-    try {
-        return JSON.parse(fs.readFileSync(PREFS_FILE, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-function writePrefs(prefs) {
-    ensureStateDir();
-    fs.writeFileSync(PREFS_FILE, JSON.stringify(prefs, null, 2));
-}
-export function getPreference(key) {
-    return readPrefs()[key];
-}
-export function setPreference(key, value) {
-    const prefs = readPrefs();
-    prefs[key] = value;
-    writePrefs(prefs);
-}

package/dist/services/worktree.d.ts

@@ -1,40 +0,0 @@
-export interface WorktreeOptions {
-    taskId: string;
-    taskTitle: string;
-    projectRoot: string;
-    apiKey: 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 and its branch
- */
-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>;
-/**
- * Get the main project root (not a worktree).
- * If we're in a worktree, this returns the main repo's path.
- */
-export declare function getMainProjectRoot(dir: string): Promise<string>;