@claudetools/tools 0.1.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # claudetools
 
-MCP server for Claude Code - persistent AI memory, task management, and codebase intelligence.
+Persistent AI memory, task management, and codebase intelligence for Claude Code.
 
 ## Installation
 

package/dist/cli.js

@@ -7,7 +7,7 @@ import { parseArgs } from 'node:util';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { runSetup } from './setup.js';
+import { runSetup, runUninstall } from './setup.js';
 import { startServer } from './index.js';
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -19,6 +19,7 @@ const version = packageJson.version;
 const { values } = parseArgs({
     options: {
         setup: { type: 'boolean', short: 's' },
+        uninstall: { type: 'boolean', short: 'u' },
         version: { type: 'boolean', short: 'v' },
         help: { type: 'boolean', short: 'h' },
     },
@@ -32,17 +33,18 @@ if (values.version) {
 // Handle help flag
 if (values.help) {
     console.log(`
-claudetools - MCP server for Claude Code
+claudetools - Persistent AI memory for Claude Code
 
 Usage:
   claudetools [options]
 
 Options:
-  -s, --setup    Interactive setup wizard
-  -v, --version  Show version
-  -h, --help     Show this help
+  -s, --setup      Interactive setup wizard
+  -u, --uninstall  Remove from Claude Code
+  -v, --version    Show version
+  -h, --help       Show this help
 
-Running without options starts the MCP server.
+Running without options starts the server.
 
 Documentation: https://github.com/claudetools/memory
 `);
@@ -55,6 +57,12 @@ if (values.setup) {
         process.exit(1);
     });
 }
+else if (values.uninstall) {
+    runUninstall().catch((error) => {
+        console.error('Uninstall failed:', error);
+        process.exit(1);
+    });
+}
 else {
     // Start MCP server
     startServer();

package/dist/setup.d.ts

@@ -1 +1,2 @@
 export declare function runSetup(): Promise<void>;
+export declare function runUninstall(): Promise<void>;

package/dist/setup.js

@@ -1,206 +1,554 @@
 // =============================================================================
-// ClaudeTools Memory Interactive Setup Wizard
+// ClaudeTools Interactive Setup Wizard
 // =============================================================================
-// Guides users through initial configuration with validation
-import readline from 'readline';
-import { stdin as input, stdout as output } from 'process';
+// Guides users through authentication, service configuration, and Claude Code integration
+import prompts from 'prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from 'fs';
 import { loadConfigFromFile, saveConfig, ensureConfigDir, getConfigPath, DEFAULT_CONFIG, } from './helpers/config-manager.js';
 // -----------------------------------------------------------------------------
-// Prompt Helpers
-// -----------------------------------------------------------------------------
-/**
- * Prompt user for input with optional default value
- */
-function prompt(question, defaultValue) {
-    const rl = readline.createInterface({ input, output });
-    return new Promise((resolve) => {
-        const displayQuestion = defaultValue
-            ? `${question} [${defaultValue}]: `
-            : `${question}: `;
-        rl.question(displayQuestion, (answer) => {
-            rl.close();
-            resolve(answer.trim() || defaultValue || '');
-        });
-    });
+// Constants
+// -----------------------------------------------------------------------------
+const CLAUDE_DIR = join(homedir(), '.claude');
+const MCP_CONFIG_PATH = join(CLAUDE_DIR, 'mcp.json');
+const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+// -----------------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------------
+function header(title) {
+    console.log('\n' + chalk.cyan('━'.repeat(50)));
+    console.log(chalk.cyan.bold(title));
+    console.log(chalk.cyan('━'.repeat(50)) + '\n');
 }
-/**
- * Prompt user for yes/no confirmation
- */
-async function confirm(question, defaultValue = true) {
-    const defaultStr = defaultValue ? 'Y/n' : 'y/N';
-    const answer = await prompt(`${question} (${defaultStr})`);
-    if (!answer) {
-        return defaultValue;
-    }
-    return answer.toLowerCase().startsWith('y');
+function success(msg) {
+    console.log(chalk.green('✓ ') + msg);
+}
+function error(msg) {
+    console.log(chalk.red('✗ ') + msg);
+}
+function info(msg) {
+    console.log(chalk.blue('ℹ ') + msg);
 }
 // -----------------------------------------------------------------------------
-// API Validation
+// Authentication
 // -----------------------------------------------------------------------------
-/**
- * Validate API connection and authentication
- */
-async function validateApiConnection(apiUrl, apiKey) {
+async function authenticateWithEmailPassword(apiUrl) {
+    const { email, password } = await prompts([
+        {
+            type: 'text',
+            name: 'email',
+            message: 'Email:',
+            validate: (v) => v.includes('@') || 'Enter a valid email',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            validate: (v) => v.length >= 8 || 'Password must be at least 8 characters',
+        },
+    ]);
+    if (!email || !password)
+        return null;
+    const spinner = ora('Authenticating...').start();
     try {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (apiKey) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
+        const response = await fetch(`${apiUrl}/api/v1/auth/login`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password }),
+        });
+        if (!response.ok) {
+            const data = await response.json().catch(() => ({}));
+            spinner.fail('Authentication failed');
+            error(data.message || `HTTP ${response.status}`);
+            return null;
         }
-        const response = await fetch(`${apiUrl}/health`, {
-            headers,
-            signal: AbortSignal.timeout(10000), // 10 second timeout
+        const data = await response.json();
+        spinner.succeed('Authenticated');
+        return data;
+    }
+    catch (err) {
+        spinner.fail('Connection failed');
+        error(err instanceof Error ? err.message : String(err));
+        return null;
+    }
+}
+async function authenticateWithDeviceCode(apiUrl) {
+    const spinner = ora('Requesting device code...').start();
+    try {
+        // Request device code
+        const codeResponse = await fetch(`${apiUrl}/api/v1/auth/device/code`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
         });
-        return response.ok;
+        if (!codeResponse.ok) {
+            spinner.fail('Failed to get device code');
+            return null;
+        }
+        const { device_code, user_code, verification_uri, expires_in, interval } = await codeResponse.json();
+        spinner.stop();
+        console.log('\n' + chalk.yellow.bold('  ' + user_code) + '\n');
+        console.log(`  Open: ${chalk.underline(verification_uri)}`);
+        console.log(`  Enter the code above to authenticate.\n`);
+        const pollSpinner = ora('Waiting for authentication...').start();
+        // Poll for token
+        const pollInterval = (interval || 5) * 1000;
+        const expiresAt = Date.now() + (expires_in || 900) * 1000;
+        while (Date.now() < expiresAt) {
+            await new Promise((r) => setTimeout(r, pollInterval));
+            const tokenResponse = await fetch(`${apiUrl}/api/v1/auth/device/token`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ device_code }),
+            });
+            if (tokenResponse.ok) {
+                const data = await tokenResponse.json();
+                pollSpinner.succeed('Authenticated');
+                return data;
+            }
+            const errorData = await tokenResponse.json().catch(() => ({ error: 'unknown' }));
+            if (errorData.error === 'authorization_pending') {
+                continue;
+            }
+            else if (errorData.error === 'slow_down') {
+                await new Promise((r) => setTimeout(r, 5000));
+                continue;
+            }
+            else {
+                pollSpinner.fail('Authentication failed');
+                error(errorData.error || 'Unknown error');
+                return null;
+            }
+        }
+        pollSpinner.fail('Authentication timed out');
+        return null;
     }
-    catch (error) {
-        return false;
+    catch (err) {
+        spinner.fail('Connection failed');
+        error(err instanceof Error ? err.message : String(err));
+        return null;
     }
 }
-/**
- * Register this system with the ClaudeTools API
- */
-async function registerSystem(config) {
+async function signUp(apiUrl) {
+    const { email, password, confirmPassword } = await prompts([
+        {
+            type: 'text',
+            name: 'email',
+            message: 'Email:',
+            validate: (v) => v.includes('@') || 'Enter a valid email',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            validate: (v) => v.length >= 8 || 'Password must be at least 8 characters',
+        },
+        {
+            type: 'password',
+            name: 'confirmPassword',
+            message: 'Confirm password:',
+        },
+    ]);
+    if (!email || !password)
+        return null;
+    if (password !== confirmPassword) {
+        error('Passwords do not match');
+        return null;
+    }
+    const spinner = ora('Creating account...').start();
     try {
-        const hostname = require('os').hostname();
-        const platform = process.platform;
-        const cwd = process.cwd();
-        const response = await fetch(`${config.apiUrl}/api/v1/systems/register`, {
+        const response = await fetch(`${apiUrl}/api/v1/auth/signup`, {
             method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': config.apiKey ? `Bearer ${config.apiKey}` : '',
-            },
-            body: JSON.stringify({
-                name: hostname,
-                platform,
-                working_directory: cwd,
-            }),
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password }),
         });
         if (!response.ok) {
-            throw new Error(`Registration failed: ${response.status} ${response.statusText}`);
+            const data = await response.json().catch(() => ({}));
+            spinner.fail('Sign up failed');
+            error(data.message || `HTTP ${response.status}`);
+            return null;
         }
         const data = await response.json();
-        return data.system_id;
+        spinner.succeed('Account created');
+        return data;
     }
-    catch (error) {
-        throw new Error(`Failed to register system: ${error instanceof Error ? error.message : String(error)}`);
+    catch (err) {
+        spinner.fail('Connection failed');
+        error(err instanceof Error ? err.message : String(err));
+        return null;
     }
 }
+async function runAuthFlow(apiUrl) {
+    const { authMethod } = await prompts({
+        type: 'select',
+        name: 'authMethod',
+        message: 'How would you like to authenticate?',
+        choices: [
+            { title: 'Sign up (new account)', value: 'signup' },
+            { title: 'Login with email/password', value: 'email' },
+            { title: 'Login with device code (browser)', value: 'device' },
+            { title: 'Skip (use existing API key)', value: 'skip' },
+        ],
+    });
+    switch (authMethod) {
+        case 'signup':
+            return signUp(apiUrl);
+        case 'email':
+            return authenticateWithEmailPassword(apiUrl);
+        case 'device':
+            return authenticateWithDeviceCode(apiUrl);
+        case 'skip':
+            return null;
+        default:
+            return null;
+    }
+}
+// -----------------------------------------------------------------------------
+// Service Configuration
+// -----------------------------------------------------------------------------
+async function configureServices() {
+    header('Service Configuration');
+    info('Configure optional integrations for enhanced functionality.\n');
+    // Context7
+    console.log(chalk.bold('Context7') + ' - Library documentation fetching');
+    console.log(chalk.dim('Provides up-to-date docs for npm packages, frameworks, etc.\n'));
+    const { context7ApiKey } = await prompts({
+        type: 'text',
+        name: 'context7ApiKey',
+        message: 'Context7 API key (leave blank to skip):',
+    });
+    // Sequential Thinking
+    console.log('\n' + chalk.bold('Sequential Thinking') + ' - Planning and reasoning MCP');
+    console.log(chalk.dim('Enables structured problem-solving and task planning.\n'));
+    const { sequentialThinking } = await prompts({
+        type: 'confirm',
+        name: 'sequentialThinking',
+        message: 'Enable Sequential Thinking?',
+        initial: true,
+    });
+    return {
+        context7ApiKey: context7ApiKey || undefined,
+        sequentialThinkingEnabled: sequentialThinking,
+    };
+}
 // -----------------------------------------------------------------------------
-// Setup Wizard
+// Claude Code Integration
+// -----------------------------------------------------------------------------
+function ensureClaudeDir() {
+    if (!existsSync(CLAUDE_DIR)) {
+        mkdirSync(CLAUDE_DIR, { recursive: true });
+    }
+}
+function backupFile(path) {
+    if (existsSync(path)) {
+        const backupPath = `${path}.backup.${Date.now()}`;
+        copyFileSync(path, backupPath);
+        return backupPath;
+    }
+    return null;
+}
+async function configureMcpSettings(services) {
+    header('Claude Code MCP Configuration');
+    ensureClaudeDir();
+    // Read existing config
+    let mcpConfig = { mcpServers: {} };
+    if (existsSync(MCP_CONFIG_PATH)) {
+        try {
+            mcpConfig = JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf-8'));
+            const backup = backupFile(MCP_CONFIG_PATH);
+            if (backup) {
+                info(`Backed up existing config to ${backup}`);
+            }
+        }
+        catch {
+            error('Could not parse existing mcp.json, creating new one');
+        }
+    }
+    // Ensure mcpServers object exists
+    if (!mcpConfig.mcpServers || typeof mcpConfig.mcpServers !== 'object') {
+        mcpConfig.mcpServers = {};
+    }
+    const servers = mcpConfig.mcpServers;
+    // Add claudetools
+    servers['claudetools_memory'] = {
+        command: 'claudetools',
+    };
+    success('Added claudetools_memory server');
+    // Add context7 if configured
+    if (services.context7ApiKey) {
+        servers['context7'] = {
+            command: 'npx',
+            args: ['-y', '@context7/mcp-server'],
+            env: {
+                CONTEXT7_API_KEY: services.context7ApiKey,
+            },
+        };
+        success('Added context7 server');
+    }
+    // Add sequential-thinking if enabled
+    if (services.sequentialThinkingEnabled) {
+        servers['sequential-thinking'] = {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+        };
+        success('Added sequential-thinking server');
+    }
+    // Write config
+    writeFileSync(MCP_CONFIG_PATH, JSON.stringify(mcpConfig, null, 2));
+    success(`Saved MCP config to ${MCP_CONFIG_PATH}`);
+}
+async function installHooks() {
+    header('Claude Code Hooks Installation');
+    ensureClaudeDir();
+    if (!existsSync(HOOKS_DIR)) {
+        mkdirSync(HOOKS_DIR, { recursive: true });
+    }
+    // User prompt submit hook - injects context before each message
+    const userPromptHook = `#!/bin/bash
+# ClaudeTools Context Injection Hook
+# Automatically injects relevant memory context before each prompt
+
+# Prevent recursion
+LOCK_FILE="/tmp/claude-prompt-hook.lock"
+if [ -f "$LOCK_FILE" ]; then exit 0; fi
+touch "$LOCK_FILE"
+trap "rm -f $LOCK_FILE" EXIT
+
+# Skip if disabled
+if [ "$CLAUDE_DISABLE_HOOKS" = "1" ]; then exit 0; fi
+
+# Read config
+CONFIG_FILE="$HOME/.claudetools/config.json"
+if [ ! -f "$CONFIG_FILE" ]; then exit 0; fi
+
+API_URL=$(jq -r '.apiUrl // "https://api.claudetools.dev"' "$CONFIG_FILE")
+API_KEY=$(jq -r '.apiKey // empty' "$CONFIG_FILE")
+
+if [ -z "$API_KEY" ]; then exit 0; fi
+
+# Get current project
+PROJECT_FILE="$HOME/.claudetools/projects.json"
+CWD=$(pwd)
+PROJECT_ID=""
+
+if [ -f "$PROJECT_FILE" ]; then
+  PROJECT_ID=$(jq -r --arg cwd "$CWD" '.[$cwd] // empty' "$PROJECT_FILE")
+fi
+
+# Inject context (silent fail)
+curl -s -X POST "$API_URL/api/v1/context/inject" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d "{\\"project_id\\": \\"$PROJECT_ID\\", \\"cwd\\": \\"$CWD\\"}" \\
+  2>/dev/null || true
+`;
+    const userPromptPath = join(HOOKS_DIR, 'user-prompt-submit.sh');
+    if (existsSync(userPromptPath)) {
+        const backup = backupFile(userPromptPath);
+        if (backup)
+            info(`Backed up existing hook to ${backup}`);
+    }
+    writeFileSync(userPromptPath, userPromptHook, { mode: 0o755 });
+    success('Installed user-prompt-submit.sh hook');
+    // Post tool use hook - logs tool usage for learning
+    const postToolHook = `#!/bin/bash
+# ClaudeTools Tool Usage Logger
+# Logs tool executions for pattern learning
+
+# Prevent recursion
+LOCK_FILE="/tmp/claude-tool-hook.lock"
+if [ -f "$LOCK_FILE" ]; then exit 0; fi
+touch "$LOCK_FILE"
+trap "rm -f $LOCK_FILE" EXIT
+
+# Skip if disabled
+if [ "$CLAUDE_DISABLE_HOOKS" = "1" ]; then exit 0; fi
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Read config
+CONFIG_FILE="$HOME/.claudetools/config.json"
+if [ ! -f "$CONFIG_FILE" ]; then exit 0; fi
+
+API_URL=$(jq -r '.apiUrl // "https://api.claudetools.dev"' "$CONFIG_FILE")
+API_KEY=$(jq -r '.apiKey // empty' "$CONFIG_FILE")
+
+if [ -z "$API_KEY" ]; then exit 0; fi
+
+# Log tool usage (silent fail)
+curl -s -X POST "$API_URL/api/v1/tools/log" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d "$INPUT" \\
+  2>/dev/null || true
+`;
+    const postToolPath = join(HOOKS_DIR, 'post-tool-use.sh');
+    if (existsSync(postToolPath)) {
+        const backup = backupFile(postToolPath);
+        if (backup)
+            info(`Backed up existing hook to ${backup}`);
+    }
+    writeFileSync(postToolPath, postToolHook, { mode: 0o755 });
+    success('Installed post-tool-use.sh hook');
+}
+// -----------------------------------------------------------------------------
+// Verification
+// -----------------------------------------------------------------------------
+async function verifySetup(config) {
+    header('Verification');
+    const spinner = ora('Checking API connection...').start();
+    try {
+        const response = await fetch(`${config.apiUrl}/health`, {
+            headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+            signal: AbortSignal.timeout(10000),
+        });
+        if (response.ok) {
+            spinner.succeed('API connection verified');
+        }
+        else {
+            spinner.warn('API returned non-OK status');
+        }
+    }
+    catch {
+        spinner.fail('Could not connect to API');
+    }
+    // Check MCP config exists
+    if (existsSync(MCP_CONFIG_PATH)) {
+        success('MCP config installed');
+    }
+    else {
+        error('MCP config not found');
+    }
+    // Check hooks installed
+    if (existsSync(join(HOOKS_DIR, 'user-prompt-submit.sh'))) {
+        success('Hooks installed');
+    }
+    else {
+        error('Hooks not found');
+    }
+}
+// -----------------------------------------------------------------------------
+// Main Setup Flow
 // -----------------------------------------------------------------------------
 export async function runSetup() {
-    console.log('\n🧠 ClaudeTools Memory Setup\n');
-    console.log('This wizard will guide you through the initial configuration.\n');
+    console.log('\n' + chalk.bold.cyan('  ClaudeTools Setup Wizard') + '\n');
+    console.log('  ' + chalk.dim('Persistent AI memory for Claude Code') + '\n');
     try {
-        // 1. Ensure config directory exists
+        // Ensure config directory exists
         await ensureConfigDir();
-        // 2. Load existing config or use defaults
+        // Load existing config
         const loadedConfig = await loadConfigFromFile();
-        // Merge with defaults to ensure all fields exist
         let config = { ...DEFAULT_CONFIG, ...loadedConfig };
-        // 3. API URL configuration
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('API Configuration');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        const useDefaultApi = await confirm(`Use default API URL (${DEFAULT_CONFIG.apiUrl})?`, true);
-        if (!useDefaultApi) {
-            const customApiUrl = await prompt('Enter custom API URL');
-            if (customApiUrl) {
-                config.apiUrl = customApiUrl;
-            }
-        }
-        // 4. API Key configuration
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('Authentication');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        // Step 1: Authentication
+        header('Authentication');
         if (config.apiKey) {
-            console.log(`Current API key: ${config.apiKey.substring(0, 10)}...`);
-            const replaceKey = await confirm('Replace existing API key?', false);
-            if (replaceKey) {
-                const newApiKey = await prompt('Enter new API key (from claudetools.dev/dashboard)');
-                if (newApiKey) {
-                    config.apiKey = newApiKey;
+            info(`Existing API key found: ${config.apiKey.substring(0, 10)}...`);
+            const { replace } = await prompts({
+                type: 'confirm',
+                name: 'replace',
+                message: 'Replace existing authentication?',
+                initial: false,
+            });
+            if (replace) {
+                const auth = await runAuthFlow(config.apiUrl || DEFAULT_CONFIG.apiUrl);
+                if (auth) {
+                    config.apiKey = auth.token;
+                    success(`Logged in as ${auth.email}`);
                 }
             }
         }
         else {
-            console.log('Get your API key from: https://claudetools.dev/dashboard\n');
-            const apiKey = await prompt('Enter API key (leave blank to skip)');
-            if (apiKey) {
-                config.apiKey = apiKey;
+            const auth = await runAuthFlow(config.apiUrl || DEFAULT_CONFIG.apiUrl);
+            if (auth) {
+                config.apiKey = auth.token;
+                success(`Logged in as ${auth.email}`);
             }
+            else {
+                // Manual API key entry
+                const { apiKey } = await prompts({
+                    type: 'text',
+                    name: 'apiKey',
+                    message: 'Enter API key manually (from claudetools.dev/dashboard):',
+                });
+                if (apiKey) {
+                    config.apiKey = apiKey;
+                }
+            }
+        }
+        // Step 2: Service Configuration
+        const services = await configureServices();
+        // Store service configs in extended config
+        const extendedConfig = config;
+        if (services.context7ApiKey) {
+            extendedConfig.context7ApiKey = services.context7ApiKey;
         }
-        // 5. Validate API connection
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('Validation');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        console.log('Validating API connection...');
-        const isValid = await validateApiConnection(config.apiUrl || DEFAULT_CONFIG.apiUrl, config.apiKey);
-        if (!isValid) {
-            console.error('❌ Could not connect to API.');
-            console.error('   Check your API URL and key, or continue without validation.\n');
-            const continueAnyway = await confirm('Continue anyway?', false);
-            if (!continueAnyway) {
-                console.log('\nSetup cancelled.');
-                process.exit(1);
+        extendedConfig.sequentialThinkingEnabled = services.sequentialThinkingEnabled;
+        // Step 3: Save ClaudeTools config
+        header('Saving Configuration');
+        await saveConfig(extendedConfig);
+        success(`Configuration saved to ${getConfigPath()}`);
+        // Step 4: Configure Claude Code MCP
+        await configureMcpSettings(services);
+        // Step 5: Install Hooks
+        await installHooks();
+        // Step 6: Verify
+        await verifySetup(extendedConfig);
+        // Done
+        header('Setup Complete');
+        console.log(chalk.green('  ClaudeTools is now configured!\n'));
+        console.log('  ' + chalk.bold('Next step:') + ' Restart Claude Code\n');
+        console.log('  The memory system will activate automatically.\n');
+    }
+    catch (err) {
+        console.error('\n' + chalk.red('Setup failed:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+// -----------------------------------------------------------------------------
+// Uninstall
+// -----------------------------------------------------------------------------
+export async function runUninstall() {
+    console.log('\n' + chalk.bold.red('  ClaudeTools Uninstall') + '\n');
+    const { confirm } = await prompts({
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Remove ClaudeTools from Claude Code?',
+        initial: false,
+    });
+    if (!confirm) {
+        console.log('Cancelled.');
+        return;
+    }
+    // Remove from MCP config
+    if (existsSync(MCP_CONFIG_PATH)) {
+        try {
+            const mcpConfig = JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf-8'));
+            if (mcpConfig.mcpServers) {
+                delete mcpConfig.mcpServers['claudetools_memory'];
+                writeFileSync(MCP_CONFIG_PATH, JSON.stringify(mcpConfig, null, 2));
+                success('Removed from MCP config');
             }
         }
-        else {
-            console.log('✅ API connection validated');
+        catch {
+            error('Could not update MCP config');
         }
-        // 6. Auto-inject context configuration
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('Context Injection');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        console.log('Auto-inject context automatically adds relevant memory to every request.');
-        console.log('This uses tokens but provides more contextual responses.\n');
-        const enableAutoInject = await confirm('Enable automatic context injection?', config.autoInjectContext);
-        config.autoInjectContext = enableAutoInject;
-        // 7. System registration (optional)
-        if (isValid && config.apiKey) {
-            console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            console.log('System Registration');
-            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-            const shouldRegister = await confirm('Register this system?', true);
-            if (shouldRegister) {
-                try {
-                    console.log('Registering system...');
-                    const systemId = await registerSystem(config);
-                    console.log(`✅ System registered: ${systemId}`);
-                }
-                catch (error) {
-                    console.error(`❌ Registration failed: ${error instanceof Error ? error.message : String(error)}`);
-                    console.error('   You can continue without registration.');
-                }
+    }
+    // Remove hooks
+    const hooks = ['user-prompt-submit.sh', 'post-tool-use.sh'];
+    for (const hook of hooks) {
+        const hookPath = join(HOOKS_DIR, hook);
+        if (existsSync(hookPath)) {
+            const content = readFileSync(hookPath, 'utf-8');
+            if (content.includes('ClaudeTools')) {
+                const { unlinkSync } = await import('fs');
+                unlinkSync(hookPath);
+                success(`Removed ${hook}`);
             }
         }
-        // 8. Save configuration
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('Saving Configuration');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        await saveConfig(config);
-        console.log(`✅ Configuration saved to ${getConfigPath()}`);
-        // 9. Show next steps
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('Next Steps');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        console.log('1. Add to Claude Code MCP settings:');
-        console.log('   Location: ~/.claude/mcp.json\n');
-        console.log('   {');
-        console.log('     "mcpServers": {');
-        console.log('       "claudetools-memory": {');
-        console.log('         "command": "claudetools-memory"');
-        console.log('       }');
-        console.log('     }');
-        console.log('   }\n');
-        console.log('2. Restart Claude Code\n');
-        console.log('Done! 🎉\n');
-    }
-    catch (error) {
-        console.error('\n❌ Setup failed:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
     }
+    console.log('\n' + chalk.green('ClaudeTools removed from Claude Code.'));
+    console.log(chalk.dim('Your ~/.claudetools/ config and data are preserved.\n'));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.1.1",
-  "description": "MCP server for Claude Code - persistent AI memory, task management, and codebase intelligence",
+  "version": "0.2.0",
+  "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -46,10 +46,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "chalk": "^5.6.2",
+    "ora": "^9.0.0",
+    "prompts": "^2.4.2"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
+    "@types/prompts": "^2.4.9",
     "@vitest/ui": "^4.0.15",
     "tsx": "^4.7.0",
     "typescript": "^5.3.0",