@damper/cli 0.1.4 → 0.2.0

package/README.md

@@ -33,7 +33,8 @@ damper
 ## Quick Start
 
 ```bash
-# First time? Run setup to configure MCP and API key
+# First time? Run setup in your project directory
+cd your-project
 npx @damper/cli setup
 
 # Start working on a task
@@ -57,17 +58,19 @@ npx @damper/cli --status planned   # Filter by status
 
 ### `npx @damper/cli setup`
 
-Configure Damper MCP in Claude Code. Run this first if you haven't set up MCP yet.
+Configure Damper for the current project. Stores your API key in `.damper/config.json`.
 
 - Checks if Claude CLI is installed
-- Configures `~/.claude/settings.json` with Damper MCP
-- Prompts for API key if not in environment
+- Prompts for your project's API key
+- Configures Damper MCP globally (if not already set up)
 
 ```bash
-npx @damper/cli setup                # First-time setup
+npx @damper/cli setup                # Configure current project
 npx @damper/cli setup --reconfigure  # Change API key
 ```
 
+**Note:** Add `.damper/` to your `.gitignore` to keep your API key private.
+
 ### `npx @damper/cli status`
 
 Show all tracked worktrees and their task status.
@@ -91,6 +94,34 @@ Remove worktrees for completed or abandoned tasks. Interactive selection with au
 - Abandoned tasks (unlocked in Damper)
 - Missing worktree directories
 
+## Configuration
+
+### Per-Project Setup (Default)
+
+Each project has its own API key stored in `.damper/config.json`:
+
+```bash
+cd project-a
+npx @damper/cli setup  # Enter API key for project-a
+
+cd ../project-b
+npx @damper/cli setup  # Enter API key for project-b
+```
+
+### API Key Resolution
+
+The CLI looks for API keys in this order:
+1. `DAMPER_API_KEY` environment variable (highest priority)
+2. `.damper/config.json` in the project root
+3. Global MCP config in `~/.claude/settings.json` (legacy)
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `DAMPER_API_KEY` | Override API key (useful for CI/scripts) |
+| `DAMPER_API_URL` | API URL override (default: `https://api.usedamper.com`) |
+
 ## Workflow
 
 ### Starting a New Task
@@ -150,40 +181,6 @@ Once Claude is running, it handles:
 - `complete_task` - Mark done with summary
 - `abandon_task` - Hand off with notes for next agent
 
-## Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `DAMPER_API_KEY` | Your Damper API key (or configure via `setup`) |
-| `DAMPER_API_URL` | API URL override (default: `https://api.usedamper.com`) |
-
-### Per-Project API Keys
-
-Damper API keys are project-scoped. If you work with multiple Damper projects, you can use different keys:
-
-**Option 1: Environment variable (recommended)**
-```bash
-# Set in your shell or project's .env file
-export DAMPER_API_KEY=your-project-specific-key
-npx @damper/cli
-```
-
-**Option 2: Use direnv for automatic switching**
-```bash
-# In each project directory, create .envrc:
-echo 'export DAMPER_API_KEY=your-key-here' > .envrc
-direnv allow
-```
-
-**Option 3: Reconfigure when switching projects**
-```bash
-npx @damper/cli setup --reconfigure
-```
-
-The CLI checks for keys in this order:
-1. `DAMPER_API_KEY` environment variable
-2. `~/.claude/settings.json` (configured via `setup`)
-
 ## How it Works
 
 ### Worktree Isolation

package/dist/commands/setup.js

@@ -1,12 +1,12 @@
-import { confirm } from '@inquirer/prompts';
+import { confirm, password } from '@inquirer/prompts';
 import pc from 'picocolors';
-import { isDamperMcpConfigured, getConfiguredApiKey, setupDamperMcp, configureDamperMcp, isClaudeInstalled, } from '../services/claude.js';
+import { isDamperMcpConfigured, configureDamperMcp, isClaudeInstalled, } from '../services/claude.js';
+import { getApiKey, writeProjectConfig, isProjectConfigured, tryGetProjectRoot, getProjectConfigPath, } from '../services/config.js';
 import { createDamperApi } from '../services/damper-api.js';
-async function promptForNewApiKey() {
-    const { password } = await import('@inquirer/prompts');
+async function promptForApiKey() {
     console.log(pc.dim('\nGet your API key from: https://usedamper.com → Settings → API Keys\n'));
     const apiKey = await password({
-        message: 'Enter your new Damper API key:',
+        message: 'Enter your Damper API key:',
         mask: '*',
         validate: (value) => {
             if (!value || value.trim().length === 0) {
@@ -20,6 +20,17 @@ async function promptForNewApiKey() {
     });
     return apiKey.trim();
 }
+async function verifyApiKey(apiKey) {
+    try {
+        const api = createDamperApi(apiKey);
+        const { project } = await api.listTasks({ limit: 1 });
+        return { valid: true, project };
+    }
+    catch (err) {
+        const error = err;
+        return { valid: false, error: error.message };
+    }
+}
 export async function setupCommand(options = {}) {
     console.log(pc.bold('\n@damper/cli Setup\n'));
     // Check Claude CLI
@@ -31,88 +42,111 @@ export async function setupCommand(options = {}) {
     else {
         console.log(pc.green('✓ Claude Code CLI installed'));
     }
-    // Check MCP configuration
+    // Check MCP configuration (global)
     const mcpConfigured = isDamperMcpConfigured();
-    const apiKey = getConfiguredApiKey();
-    if (mcpConfigured && apiKey) {
-        console.log(pc.green('✓ Damper MCP configured'));
-        console.log(pc.dim(`  API key: ${'*'.repeat(12)} (${apiKey.length} chars)`));
-        // If reconfigure flag is set, prompt for new key
+    if (mcpConfigured) {
+        console.log(pc.green('✓ Damper MCP configured globally'));
+    }
+    else {
+        console.log(pc.yellow('○ Damper MCP not configured'));
+    }
+    // Get project root
+    const projectRoot = await tryGetProjectRoot();
+    if (!projectRoot) {
+        console.log(pc.yellow('\n⚠️  Not in a git repository'));
+        console.log(pc.dim('  Run this command from within a project to configure it.\n'));
+        // Still offer to set up global MCP if not configured
+        if (!mcpConfigured) {
+            const shouldSetupMcp = await confirm({
+                message: 'Set up Damper MCP globally (without API key)?',
+                default: true,
+            });
+            if (shouldSetupMcp) {
+                configureDamperMcp();
+                console.log(pc.green('\n✓ Damper MCP configured globally'));
+                console.log(pc.dim('  Run setup again from a project directory to add an API key.\n'));
+            }
+        }
+        return;
+    }
+    // Check project configuration
+    const projectConfigured = isProjectConfigured(projectRoot);
+    const existingKey = getApiKey(projectRoot);
+    if (projectConfigured && existingKey) {
+        console.log(pc.green('✓ Project configured'));
+        console.log(pc.dim(`  Config: ${getProjectConfigPath(projectRoot)}`));
+        // Reconfigure flow
         if (options.reconfigure) {
             console.log(pc.yellow('\nReconfiguring API key...'));
-            const newKey = await promptForNewApiKey();
-            if (newKey) {
-                // Verify before saving
-                console.log(pc.dim('\nVerifying new API key...'));
-                try {
-                    const api = createDamperApi(newKey);
-                    const { project } = await api.listTasks({ limit: 1 });
-                    console.log(pc.green(`✓ Connected to project: ${project}`));
-                    // Save the new key
-                    configureDamperMcp(newKey);
-                    process.env.DAMPER_API_KEY = newKey;
-                    console.log(pc.green('\n✓ API key updated successfully!\n'));
-                }
-                catch (err) {
-                    const error = err;
-                    console.log(pc.red(`✗ API key verification failed: ${error.message}`));
-                    console.log(pc.dim('  API key was NOT updated.\n'));
-                }
+            const newKey = await promptForApiKey();
+            console.log(pc.dim('\nVerifying API key...'));
+            const { valid, project, error } = await verifyApiKey(newKey);
+            if (!valid) {
+                console.log(pc.red(`✗ API key verification failed: ${error}`));
+                console.log(pc.dim('  API key was NOT updated.\n'));
+                return;
             }
+            console.log(pc.green(`✓ Connected to project: ${project}`));
+            // Save to project config
+            writeProjectConfig(projectRoot, { apiKey: newKey });
+            process.env.DAMPER_API_KEY = newKey;
+            console.log(pc.green('\n✓ API key updated successfully!\n'));
             return;
         }
-        // Verify the API key works
+        // Verify existing key works
         console.log(pc.dim('\nVerifying API key...'));
-        try {
-            const api = createDamperApi(apiKey);
-            const { project } = await api.listTasks({ limit: 1 });
-            console.log(pc.green(`✓ Connected to project: ${project}`));
-        }
-        catch (err) {
-            const error = err;
-            console.log(pc.red(`✗ API key verification failed: ${error.message}`));
-            // Offer to reconfigure
+        const { valid, project, error } = await verifyApiKey(existingKey);
+        if (!valid) {
+            console.log(pc.red(`✗ API key verification failed: ${error}`));
             const shouldReconfigure = await confirm({
                 message: 'Would you like to enter a new API key?',
                 default: true,
             });
             if (shouldReconfigure) {
-                const newKey = await promptForNewApiKey();
-                if (newKey) {
-                    configureDamperMcp(newKey);
+                const newKey = await promptForApiKey();
+                const result = await verifyApiKey(newKey);
+                if (result.valid) {
+                    writeProjectConfig(projectRoot, { apiKey: newKey });
                     process.env.DAMPER_API_KEY = newKey;
-                    console.log(pc.green('\n✓ API key updated!\n'));
+                    console.log(pc.green(`\n✓ Connected to project: ${result.project}`));
+                    console.log(pc.green('✓ API key updated!\n'));
+                }
+                else {
+                    console.log(pc.red(`✗ API key verification failed: ${result.error}\n`));
                 }
             }
             return;
         }
+        console.log(pc.green(`✓ Connected to project: ${project}`));
         console.log(pc.green('\n✓ All checks passed! You\'re ready to use @damper/cli.\n'));
         console.log(pc.dim('Run `npx @damper/cli` to start working on a task.'));
         console.log(pc.dim('Run `npx @damper/cli setup --reconfigure` to change API key.\n'));
         return;
     }
-    // Not configured - run setup
-    if (!mcpConfigured) {
-        console.log(pc.yellow('○ Damper MCP not configured'));
-    }
-    else if (!apiKey) {
-        console.log(pc.yellow('○ Damper MCP configured but missing API key'));
+    // New project setup
+    console.log(pc.yellow('\n○ Project not configured'));
+    console.log(pc.dim(`  Will save config to: ${getProjectConfigPath(projectRoot)}\n`));
+    // Prompt for API key
+    const apiKey = await promptForApiKey();
+    // Verify
+    console.log(pc.dim('\nVerifying API key...'));
+    const { valid, project, error } = await verifyApiKey(apiKey);
+    if (!valid) {
+        console.log(pc.red(`✗ API key verification failed: ${error}`));
+        console.log(pc.dim('  Please check your API key and try again.\n'));
+        return;
     }
-    const key = await setupDamperMcp();
-    if (key) {
-        // Verify the new key
-        console.log(pc.dim('\nVerifying API key...'));
-        try {
-            const api = createDamperApi(key);
-            const { project } = await api.listTasks({ limit: 1 });
-            console.log(pc.green(`✓ Connected to project: ${project}`));
-            console.log(pc.green('\n✓ Setup complete! You\'re ready to use @damper/cli.\n'));
-            console.log(pc.dim('Run `npx @damper/cli` to start working on a task.\n'));
-        }
-        catch (err) {
-            const error = err;
-            console.log(pc.red(`✗ API key verification failed: ${error.message}`));
-            console.log(pc.dim('  Please check your API key and try again.\n'));
-        }
+    console.log(pc.green(`✓ Connected to project: ${project}`));
+    // Save to project config
+    writeProjectConfig(projectRoot, { apiKey });
+    console.log(pc.green(`✓ Saved API key to ${getProjectConfigPath(projectRoot)}`));
+    // Set up global MCP if not configured
+    if (!mcpConfigured) {
+        configureDamperMcp();
+        console.log(pc.green('✓ Configured Damper MCP globally'));
     }
+    // Remind about .gitignore
+    console.log(pc.yellow('\n⚠️  Add .damper/ to your .gitignore to keep your API key private'));
+    console.log(pc.green('\n✓ Setup complete! You\'re ready to use @damper/cli.\n'));
+    console.log(pc.dim('Run `npx @damper/cli` to start working on a task.\n'));
 }

package/dist/commands/start.js

@@ -4,8 +4,9 @@ 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, ensureMcpConfigured } from '../services/claude.js';
+import { launchClaude, 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) {
     // Check Claude CLI first
     const claudeInstalled = await isClaudeInstalled();
@@ -14,9 +15,6 @@ export async function startCommand(options) {
         console.log(pc.dim('Install it with: npm install -g @anthropic-ai/claude-code\n'));
         process.exit(1);
     }
-    // Ensure MCP is configured (will prompt for setup if not)
-    // This also handles API key setup
-    const apiKey = await ensureMcpConfigured();
     // Get project root (git root)
     let projectRoot;
     try {
@@ -27,7 +25,26 @@ export async function startCommand(options) {
         console.log(pc.dim('Run this command from within a git repository.\n'));
         process.exit(1);
     }
-    // Create API client with the configured key
+    // Check project configuration
+    const apiKey = getApiKey(projectRoot);
+    if (!apiKey) {
+        if (!isProjectConfigured(projectRoot)) {
+            console.log(pc.yellow('\nProject not configured.'));
+            console.log(pc.dim(`Run ${pc.cyan('npx @damper/cli setup')} to configure this project.\n`));
+        }
+        else {
+            console.log(pc.red('\nNo API key found.'));
+            console.log(pc.dim(`Check ${getProjectConfigPath(projectRoot)} or set DAMPER_API_KEY env var.\n`));
+        }
+        process.exit(1);
+    }
+    // Ensure MCP is configured globally (without key - key comes from env)
+    if (!isDamperMcpConfigured()) {
+        console.log(pc.dim('Configuring Damper MCP...'));
+        configureDamperMcp();
+        console.log(pc.green('✓ Damper MCP configured'));
+    }
+    // Create API client with the project's key
     const api = createDamperApi(apiKey);
     // Clean up stale worktrees
     const stale = cleanupStaleWorktrees();
@@ -130,10 +147,11 @@ export async function startCommand(options) {
             console.log(pc.green('✓ Updated CLAUDE.md with task section'));
         }
     }
-    // Launch Claude
+    // Launch Claude with project's API key
     await launchClaude({
         cwd: worktreePath,
         taskId,
         taskTitle,
+        apiKey,
     });
 }

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.1.4';
+const VERSION = '0.2.0';
 function showHelp() {
     console.log(`
 ${pc.bold('@damper/cli')} - Agent orchestration for Damper tasks

package/dist/services/claude.d.ts

@@ -9,26 +9,19 @@ interface McpServerConfig {
 export declare function isDamperMcpConfigured(): boolean;
 /**
  * Get the current API key from MCP config or environment
+ * @deprecated Use getApiKey from config.ts instead for project-aware key resolution
  */
 export declare function getConfiguredApiKey(): string | undefined;
 /**
  * Get the recommended MCP configuration
+ * Note: API key is passed via environment when launching Claude, not stored in config
  */
-export declare function getDamperMcpConfig(apiKey?: string): McpServerConfig;
+export declare function getDamperMcpConfig(): McpServerConfig;
 /**
- * Configure Damper MCP in Claude settings
+ * Configure Damper MCP in Claude settings (global)
+ * Note: API key is NOT stored here - it's passed via environment when launching Claude
  */
-export declare function configureDamperMcp(apiKey: string): void;
-/**
- * Interactive setup for Damper MCP
- * Returns the API key (either existing or newly entered)
- */
-export declare function setupDamperMcp(): Promise<string | null>;
-/**
- * Ensure MCP is configured, offering to set it up if not
- * Returns the API key to use
- */
-export declare function ensureMcpConfigured(): Promise<string>;
+export declare function configureDamperMcp(): void;
 /**
  * Launch Claude Code in a directory
  */
@@ -36,6 +29,7 @@ export declare function launchClaude(options: {
     cwd: string;
     taskId: string;
     taskTitle: string;
+    apiKey: string;
 }): Promise<void>;
 /**
  * Check if Claude Code CLI is installed

package/dist/services/claude.js

@@ -2,7 +2,6 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { execa } from 'execa';
-import { confirm, password } from '@inquirer/prompts';
 import pc from 'picocolors';
 const CLAUDE_SETTINGS_DIR = path.join(os.homedir(), '.claude');
 const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_SETTINGS_DIR, 'settings.json');
@@ -23,13 +22,14 @@ export function isDamperMcpConfigured() {
 }
 /**
  * Get the current API key from MCP config or environment
+ * @deprecated Use getApiKey from config.ts instead for project-aware key resolution
  */
 export function getConfiguredApiKey() {
     // First check environment
     if (process.env.DAMPER_API_KEY) {
         return process.env.DAMPER_API_KEY;
     }
-    // Then check Claude settings
+    // Then check Claude settings (legacy global key)
     if (!fs.existsSync(CLAUDE_SETTINGS_FILE)) {
         return undefined;
     }
@@ -43,21 +43,19 @@ export function getConfiguredApiKey() {
 }
 /**
  * Get the recommended MCP configuration
+ * Note: API key is passed via environment when launching Claude, not stored in config
  */
-export function getDamperMcpConfig(apiKey) {
-    const config = {
+export function getDamperMcpConfig() {
+    return {
         command: 'npx',
         args: ['-y', '@damper/mcp'],
     };
-    if (apiKey) {
-        config.env = { DAMPER_API_KEY: apiKey };
-    }
-    return config;
 }
 /**
- * Configure Damper MCP in Claude settings
+ * Configure Damper MCP in Claude settings (global)
+ * Note: API key is NOT stored here - it's passed via environment when launching Claude
  */
-export function configureDamperMcp(apiKey) {
+export function configureDamperMcp() {
     // Ensure directory exists
     if (!fs.existsSync(CLAUDE_SETTINGS_DIR)) {
         fs.mkdirSync(CLAUDE_SETTINGS_DIR, { recursive: true });
@@ -73,106 +71,19 @@ export function configureDamperMcp(apiKey) {
             settings = {};
         }
     }
-    // Add/update MCP config
+    // Add/update MCP config (without API key - it comes from env)
     if (!settings.mcpServers) {
         settings.mcpServers = {};
     }
-    settings.mcpServers.damper = getDamperMcpConfig(apiKey);
+    settings.mcpServers.damper = getDamperMcpConfig();
     // Write back
     fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2));
 }
-/**
- * Interactive setup for Damper MCP
- * Returns the API key (either existing or newly entered)
- */
-export async function setupDamperMcp() {
-    console.log(pc.yellow('\nDamper MCP is not configured in Claude Code.'));
-    console.log(pc.dim('The MCP server allows Claude to interact with your Damper tasks.\n'));
-    const shouldSetup = await confirm({
-        message: 'Would you like to set it up now?',
-        default: true,
-    });
-    if (!shouldSetup) {
-        console.log(pc.dim('\nYou can set it up later by running:'));
-        console.log(pc.cyan('  claude mcp add damper npx @damper/mcp\n'));
-        return null;
-    }
-    // Check if we already have an API key in the environment
-    const existingKey = process.env.DAMPER_API_KEY;
-    let apiKey;
-    if (existingKey) {
-        console.log(pc.dim('\nFound DAMPER_API_KEY in environment.'));
-        const useExisting = await confirm({
-            message: 'Use the API key from your environment?',
-            default: true,
-        });
-        if (useExisting) {
-            apiKey = existingKey;
-        }
-        else {
-            apiKey = await promptForApiKey();
-        }
-    }
-    else {
-        apiKey = await promptForApiKey();
-    }
-    // Configure MCP
-    console.log(pc.dim('\nConfiguring Damper MCP...'));
-    configureDamperMcp(apiKey);
-    console.log(pc.green('✓ Damper MCP configured in ~/.claude/settings.json'));
-    // Set in environment for current session
-    process.env.DAMPER_API_KEY = apiKey;
-    return apiKey;
-}
-async function promptForApiKey() {
-    console.log(pc.dim('\nGet your API key from: https://usedamper.com → Settings → API Keys\n'));
-    const apiKey = await password({
-        message: 'Enter your Damper API key:',
-        mask: '*',
-        validate: (value) => {
-            if (!value || value.trim().length === 0) {
-                return 'API key is required';
-            }
-            if (value.length < 10) {
-                return 'API key seems too short';
-            }
-            return true;
-        },
-    });
-    return apiKey.trim();
-}
-/**
- * Ensure MCP is configured, offering to set it up if not
- * Returns the API key to use
- */
-export async function ensureMcpConfigured() {
-    // Check if already configured
-    if (isDamperMcpConfigured()) {
-        const apiKey = getConfiguredApiKey();
-        if (apiKey) {
-            return apiKey;
-        }
-        // MCP configured but no API key - need to add it
-        console.log(pc.yellow('\nDamper MCP is configured but no API key found.'));
-        const key = await promptForApiKey();
-        configureDamperMcp(key);
-        process.env.DAMPER_API_KEY = key;
-        return key;
-    }
-    // Not configured - run setup
-    const apiKey = await setupDamperMcp();
-    if (!apiKey) {
-        // User declined setup
-        console.log(pc.red('\nCannot continue without Damper MCP configuration.'));
-        process.exit(1);
-    }
-    return apiKey;
-}
 /**
  * Launch Claude Code in a directory
  */
 export async function launchClaude(options) {
-    const { cwd, taskId, taskTitle } = options;
+    const { cwd, taskId, taskTitle, apiKey } = options;
     console.log(pc.green(`\nStarting Claude Code for task #${taskId}: ${taskTitle}`));
     console.log(pc.dim(`Directory: ${cwd}\n`));
     // Build initial prompt
@@ -188,12 +99,14 @@ export async function launchClaude(options) {
     ].join('\n');
     // Launch Claude Code
     // Using subprocess with inherited stdio so user can interact
+    // Pass API key so MCP server gets it
     try {
         await execa('claude', ['--print', initialPrompt], {
             cwd,
             stdio: 'inherit',
             env: {
                 ...process.env,
+                DAMPER_API_KEY: apiKey,
             },
         });
     }

package/dist/services/config.d.ts

@@ -0,0 +1,33 @@
+interface ProjectConfig {
+    apiKey?: string;
+}
+/**
+ * Get the project config directory path
+ */
+export declare function getProjectConfigDir(projectRoot: string): string;
+/**
+ * Get the project config file path
+ */
+export declare function getProjectConfigPath(projectRoot: string): string;
+/**
+ * Read project config
+ */
+export declare function readProjectConfig(projectRoot: string): ProjectConfig;
+/**
+ * Write project config
+ */
+export declare function writeProjectConfig(projectRoot: string, config: ProjectConfig): void;
+/**
+ * Get API key for a project
+ * Priority: env var > project config > global MCP config
+ */
+export declare function getApiKey(projectRoot?: string): string | undefined;
+/**
+ * Check if project has Damper configured
+ */
+export declare function isProjectConfigured(projectRoot: string): boolean;
+/**
+ * Try to get project root, returns undefined if not in a git repo
+ */
+export declare function tryGetProjectRoot(): Promise<string | undefined>;
+export {};

package/dist/services/config.js

@@ -0,0 +1,101 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { getGitRoot } from './worktree.js';
+const CONFIG_DIR = '.damper';
+const CONFIG_FILE = 'config.json';
+/**
+ * Get the project config directory path
+ */
+export function getProjectConfigDir(projectRoot) {
+    return path.join(projectRoot, CONFIG_DIR);
+}
+/**
+ * Get the project config file path
+ */
+export function getProjectConfigPath(projectRoot) {
+    return path.join(getProjectConfigDir(projectRoot), CONFIG_FILE);
+}
+/**
+ * Read project config
+ */
+export function readProjectConfig(projectRoot) {
+    const configPath = getProjectConfigPath(projectRoot);
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Write project config
+ */
+export function writeProjectConfig(projectRoot, config) {
+    const configDir = getProjectConfigDir(projectRoot);
+    const configPath = getProjectConfigPath(projectRoot);
+    // Ensure directory exists
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    // Merge with existing config
+    const existing = readProjectConfig(projectRoot);
+    const merged = { ...existing, ...config };
+    fs.writeFileSync(configPath, JSON.stringify(merged, null, 2) + '\n');
+}
+/**
+ * Get API key for a project
+ * Priority: env var > project config > global MCP config
+ */
+export function getApiKey(projectRoot) {
+    // 1. Environment variable (highest priority)
+    if (process.env.DAMPER_API_KEY) {
+        return process.env.DAMPER_API_KEY;
+    }
+    // 2. Project config
+    if (projectRoot) {
+        const projectConfig = readProjectConfig(projectRoot);
+        if (projectConfig.apiKey) {
+            return projectConfig.apiKey;
+        }
+    }
+    // 3. Global MCP config (legacy/fallback)
+    return getGlobalApiKey();
+}
+/**
+ * Get API key from global MCP settings (legacy)
+ */
+function getGlobalApiKey() {
+    const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+    if (!fs.existsSync(settingsPath)) {
+        return undefined;
+    }
+    try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        return settings.mcpServers?.damper?.env?.DAMPER_API_KEY;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Check if project has Damper configured
+ */
+export function isProjectConfigured(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    return !!config.apiKey;
+}
+/**
+ * Try to get project root, returns undefined if not in a git repo
+ */
+export async function tryGetProjectRoot() {
+    try {
+        return await getGitRoot(process.cwd());
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

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