@claudetools/tools 0.1.2 → 0.2.1

package/dist/setup.js

@@ -1,206 +1,894 @@
 // =============================================================================
-// 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, hostname, platform } from 'os';
+import { join, basename } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from 'fs';
+import { randomUUID } from 'crypto';
 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 CLAUDETOOLS_DIR = join(homedir(), '.claudetools');
+const MCP_CONFIG_PATH = join(CLAUDE_DIR, 'mcp.json');
+const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
+const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+const SYSTEM_FILE = join(CLAUDETOOLS_DIR, 'system.json');
+const PROJECTS_FILE = join(CLAUDETOOLS_DIR, 'projects.json');
+// -----------------------------------------------------------------------------
+// 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');
+}
+function success(msg) {
+    console.log(chalk.green('✓ ') + msg);
+}
+function error(msg) {
+    console.log(chalk.red('✗ ') + msg);
+}
+function info(msg) {
+    console.log(chalk.blue('ℹ ') + msg);
+}
+// -----------------------------------------------------------------------------
+// System Registration
+// -----------------------------------------------------------------------------
+async function registerSystem(apiUrl, apiKey) {
+    const spinner = ora('Registering system...').start();
+    try {
+        // First try to register with the API
+        const response = await fetch(`${apiUrl}/api/v1/systems/register`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                hostname: hostname(),
+                platform: platform(),
+            }),
         });
-    });
+        if (response.ok) {
+            const data = await response.json();
+            const systemInfo = {
+                user_id: data.user_id,
+                system_id: data.system_id,
+                hostname: hostname(),
+                platform: platform(),
+                created_at: new Date().toISOString(),
+            };
+            spinner.succeed('System registered with API');
+            return systemInfo;
+        }
+        // If API fails, generate local UUIDs
+        spinner.warn('API registration failed, using local UUIDs');
+    }
+    catch {
+        spinner.warn('Could not reach API, using local UUIDs');
+    }
+    // Generate local UUIDs as fallback
+    const systemInfo = {
+        user_id: `user_${randomUUID().replace(/-/g, '').slice(0, 12)}`,
+        system_id: `sys_${randomUUID().replace(/-/g, '').slice(0, 12)}`,
+        hostname: hostname(),
+        platform: platform(),
+        created_at: new Date().toISOString(),
+    };
+    return systemInfo;
+}
+function saveSystemInfo(systemInfo) {
+    if (!existsSync(CLAUDETOOLS_DIR)) {
+        mkdirSync(CLAUDETOOLS_DIR, { recursive: true });
+    }
+    writeFileSync(SYSTEM_FILE, JSON.stringify(systemInfo, null, 2));
+}
+function loadSystemInfo() {
+    if (existsSync(SYSTEM_FILE)) {
+        try {
+            return JSON.parse(readFileSync(SYSTEM_FILE, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
 }
-/**
- * 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;
+function initializeProjectsFile() {
+    if (!existsSync(PROJECTS_FILE)) {
+        writeFileSync(PROJECTS_FILE, JSON.stringify({
+            bindings: [],
+            last_sync: new Date().toISOString(),
+        }, null, 2));
     }
-    return answer.toLowerCase().startsWith('y');
 }
 // -----------------------------------------------------------------------------
-// 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 {
+        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();
+        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 (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;
+    }
+}
+// -----------------------------------------------------------------------------
+// Projects Directory Configuration
+// -----------------------------------------------------------------------------
+async function configureProjectsDirectory() {
+    header('Projects Directory');
+    info('Where do you keep your code projects?');
+    console.log(chalk.dim('The watcher will monitor this directory for new projects.\n'));
+    // Suggest common locations
+    const homeDir = homedir();
+    const suggestions = [
+        join(homeDir, 'Projects'),
+        join(homeDir, 'projects'),
+        join(homeDir, 'code'),
+        join(homeDir, 'Code'),
+        join(homeDir, 'dev'),
+        join(homeDir, 'Development'),
+        join(homeDir, 'workspace'),
+    ].filter(existsSync);
+    let projectsDir;
+    if (suggestions.length > 0) {
+        const { selectedDir } = await prompts({
+            type: 'select',
+            name: 'selectedDir',
+            message: 'Select your projects directory:',
+            choices: [
+                ...suggestions.map(dir => ({ title: dir, value: dir })),
+                { title: 'Enter custom path...', value: 'custom' },
+            ],
+        });
+        if (selectedDir === 'custom') {
+            const { customDir } = await prompts({
+                type: 'text',
+                name: 'customDir',
+                message: 'Enter path to your projects directory:',
+                initial: join(homeDir, 'Projects'),
+                validate: (v) => {
+                    if (!v)
+                        return 'Path required';
+                    const expanded = v.replace(/^~/, homeDir);
+                    return existsSync(expanded) || `Directory not found: ${expanded}`;
+                },
+            });
+            projectsDir = customDir.replace(/^~/, homeDir);
+        }
+        else {
+            projectsDir = selectedDir;
+        }
     }
-    catch (error) {
-        throw new Error(`Failed to register system: ${error instanceof Error ? error.message : String(error)}`);
+    else {
+        const { customDir } = await prompts({
+            type: 'text',
+            name: 'customDir',
+            message: 'Enter path to your projects directory:',
+            initial: join(homeDir, 'Projects'),
+        });
+        projectsDir = customDir.replace(/^~/, homeDir);
+        // Create if doesn't exist
+        if (!existsSync(projectsDir)) {
+            const { create } = await prompts({
+                type: 'confirm',
+                name: 'create',
+                message: `Directory doesn't exist. Create it?`,
+                initial: true,
+            });
+            if (create) {
+                mkdirSync(projectsDir, { recursive: true });
+                success(`Created ${projectsDir}`);
+            }
+        }
     }
+    success(`Projects directory: ${projectsDir}`);
+    return [projectsDir];
 }
 // -----------------------------------------------------------------------------
-// Setup Wizard
+// 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,
+    };
+}
+// -----------------------------------------------------------------------------
+// Claude Code Integration
+// -----------------------------------------------------------------------------
+function ensureClaudeDir() {
+    if (!existsSync(CLAUDE_DIR)) {
+        mkdirSync(CLAUDE_DIR, { recursive: true });
+    }
+}
+function backupFile(filePath) {
+    if (existsSync(filePath)) {
+        const backupPath = `${filePath}.backup.${Date.now()}`;
+        copyFileSync(filePath, 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 ${basename(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', '@upstash/context7-mcp'],
+            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 });
+    }
+    // Session start hook - ensures watcher is running
+    const sessionStartHook = `#!/bin/bash
+# ClaudeTools Session Start Hook
+# Ensures the code watcher is running when Claude Code starts
+
+# Skip if disabled
+if [ "$CLAUDE_DISABLE_HOOKS" = "1" ]; then exit 0; fi
+
+# Check if watcher is already running
+WATCHER_PID_FILE="/tmp/claudetools-watcher.pid"
+if [ -f "$WATCHER_PID_FILE" ]; then
+  PID=$(cat "$WATCHER_PID_FILE")
+  if kill -0 "$PID" 2>/dev/null; then
+    # Watcher is running
+    exit 0
+  fi
+fi
+
+# Start watcher in background if claudetools is installed
+if command -v claudetools &> /dev/null; then
+  nohup claudetools watch > /tmp/claudetools-watcher.log 2>&1 &
+  echo $! > "$WATCHER_PID_FILE"
+fi
+`;
+    const sessionStartPath = join(HOOKS_DIR, 'session-start.sh');
+    if (existsSync(sessionStartPath)) {
+        const backup = backupFile(sessionStartPath);
+        if (backup)
+            info(`Backed up existing hook to ${basename(backup)}`);
+    }
+    writeFileSync(sessionStartPath, sessionStartHook, { mode: 0o755 });
+    success('Installed session-start.sh hook');
+    // 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 from projects.json
+PROJECT_FILE="$HOME/.claudetools/projects.json"
+CWD=$(pwd)
+PROJECT_ID=""
+
+if [ -f "$PROJECT_FILE" ]; then
+  # Try to find project by path prefix
+  PROJECT_ID=$(jq -r --arg cwd "$CWD" '
+    .bindings[]? | select(.local_path != null) |
+    select($cwd | startswith(.local_path)) |
+    .project_id' "$PROJECT_FILE" 2>/dev/null | head -1)
+fi
+
+# Inject context (silent fail)
+RESULT=$(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)
+
+# Output context if available
+if [ -n "$RESULT" ] && [ "$RESULT" != "null" ]; then
+  CONTEXT=$(echo "$RESULT" | jq -r '.context // empty' 2>/dev/null)
+  if [ -n "$CONTEXT" ]; then
+    echo "$CONTEXT"
+  fi
+fi
+`;
+    const userPromptPath = join(HOOKS_DIR, 'user-prompt-submit.sh');
+    if (existsSync(userPromptPath)) {
+        const backup = backupFile(userPromptPath);
+        if (backup)
+            info(`Backed up existing hook to ${basename(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 ${basename(backup)}`);
+    }
+    writeFileSync(postToolPath, postToolHook, { mode: 0o755 });
+    success('Installed post-tool-use.sh hook');
+}
+async function configureSettings() {
+    header('Claude Code Settings');
+    // Read existing settings
+    let settings = {};
+    if (existsSync(SETTINGS_PATH)) {
+        try {
+            settings = JSON.parse(readFileSync(SETTINGS_PATH, 'utf-8'));
+            const backup = backupFile(SETTINGS_PATH);
+            if (backup) {
+                info(`Backed up existing settings to ${basename(backup)}`);
+            }
+        }
+        catch {
+            // Start fresh
+        }
+    }
+    // Initialize hooks if not present
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    // Add SessionStart hook
+    if (!hooks.SessionStart) {
+        hooks.SessionStart = [];
+    }
+    const sessionStartHooks = hooks.SessionStart;
+    const hasSessionStart = sessionStartHooks.some(h => h.hooks?.some(hk => hk.command?.includes('session-start.sh')));
+    if (!hasSessionStart) {
+        sessionStartHooks.push({
+            matcher: '',
+            hooks: [{
+                    type: 'command',
+                    command: join(HOOKS_DIR, 'session-start.sh'),
+                    timeout: 5,
+                }],
+        });
+        success('Added SessionStart hook to settings');
+    }
+    // Add UserPromptSubmit hook
+    if (!hooks.UserPromptSubmit) {
+        hooks.UserPromptSubmit = [];
+    }
+    const promptHooks = hooks.UserPromptSubmit;
+    const hasPromptHook = promptHooks.some(h => h.hooks?.some(hk => hk.command?.includes('user-prompt-submit.sh')));
+    if (!hasPromptHook) {
+        promptHooks.push({
+            matcher: '',
+            hooks: [{
+                    type: 'command',
+                    command: join(HOOKS_DIR, 'user-prompt-submit.sh'),
+                    timeout: 10,
+                }],
+        });
+        success('Added UserPromptSubmit hook to settings');
+    }
+    // Add PostToolUse hook
+    if (!hooks.PostToolUse) {
+        hooks.PostToolUse = [];
+    }
+    const toolHooks = hooks.PostToolUse;
+    const hasToolHook = toolHooks.some(h => h.hooks?.some(hk => hk.command?.includes('post-tool-use.sh')));
+    if (!hasToolHook) {
+        toolHooks.push({
+            matcher: 'Edit|Write|Bash',
+            hooks: [{
+                    type: 'command',
+                    command: join(HOOKS_DIR, 'post-tool-use.sh'),
+                    timeout: 5,
+                }],
+        });
+        success('Added PostToolUse hook to settings');
+    }
+    // Write settings
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    success(`Saved settings to ${SETTINGS_PATH}`);
+}
+// -----------------------------------------------------------------------------
+// Verification
+// -----------------------------------------------------------------------------
+async function verifySetup(config) {
+    header('Verification');
+    const spinner = ora('Checking API connection...').start();
+    try {
+        const response = await fetch(`${config.apiUrl}/api/v1/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 system registration
+    if (existsSync(SYSTEM_FILE)) {
+        success('System registered');
+    }
+    else {
+        error('System not registered');
+    }
+    // Check MCP config exists
+    if (existsSync(MCP_CONFIG_PATH)) {
+        success('MCP config installed');
+    }
+    else {
+        error('MCP config not found');
+    }
+    // Check hooks installed
+    const requiredHooks = ['session-start.sh', 'user-prompt-submit.sh', 'post-tool-use.sh'];
+    const installedHooks = requiredHooks.filter(h => existsSync(join(HOOKS_DIR, h)));
+    if (installedHooks.length === requiredHooks.length) {
+        success('All hooks installed');
+    }
+    else {
+        error(`Missing hooks: ${requiredHooks.filter(h => !installedHooks.includes(h)).join(', ')}`);
+    }
+    // Check settings configured
+    if (existsSync(SETTINGS_PATH)) {
+        success('Settings configured');
+    }
+    else {
+        error('Settings 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;
+                }
             }
         }
-        // 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);
+        // Step 2: System Registration
+        header('System Registration');
+        const existingSystem = loadSystemInfo();
+        if (existingSystem) {
+            info(`System already registered: ${existingSystem.system_id}`);
+        }
+        else if (config.apiKey) {
+            const systemInfo = await registerSystem(config.apiUrl || DEFAULT_CONFIG.apiUrl, config.apiKey);
+            if (systemInfo) {
+                saveSystemInfo(systemInfo);
+                success(`System ID: ${systemInfo.system_id}`);
+                success(`User ID: ${systemInfo.user_id}`);
             }
         }
         else {
-            console.log('✅ API connection validated');
-        }
-        // 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.');
+            info('Skipping system registration (no API key)');
+        }
+        // Initialize projects file
+        initializeProjectsFile();
+        // Step 3: Projects Directory
+        const projectDirs = await configureProjectsDirectory();
+        // Step 4: Service Configuration
+        const services = await configureServices();
+        // Store all configs
+        const extendedConfig = config;
+        if (services.context7ApiKey) {
+            extendedConfig.context7ApiKey = services.context7ApiKey;
+        }
+        extendedConfig.sequentialThinkingEnabled = services.sequentialThinkingEnabled;
+        extendedConfig.watchedDirectories = projectDirs;
+        // Step 5: Save ClaudeTools config
+        header('Saving Configuration');
+        await saveConfig(extendedConfig);
+        success(`Configuration saved to ${getConfigPath()}`);
+        // Step 6: Configure Claude Code MCP
+        await configureMcpSettings(services);
+        // Step 7: Install Hooks
+        await installHooks();
+        // Step 8: Configure Settings
+        await configureSettings();
+        // Step 9: 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');
+            }
+        }
+        catch {
+            error('Could not update MCP config');
+        }
+    }
+    // Remove hooks from settings
+    if (existsSync(SETTINGS_PATH)) {
+        try {
+            const settings = JSON.parse(readFileSync(SETTINGS_PATH, 'utf-8'));
+            if (settings.hooks) {
+                // Remove claudetools hooks
+                for (const hookType of ['SessionStart', 'UserPromptSubmit', 'PostToolUse']) {
+                    if (settings.hooks[hookType]) {
+                        settings.hooks[hookType] = settings.hooks[hookType].filter((h) => !h.hooks?.some(hk => hk.command?.includes('.claudetools') || hk.command?.includes('claudetools')));
+                    }
                 }
+                writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+                success('Removed hooks from settings');
             }
         }
-        // 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);
+        catch {
+            error('Could not update settings');
+        }
+    }
+    // Remove hook scripts
+    const hooks = ['session-start.sh', '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}`);
+            }
+        }
+    }
+    // Stop watcher if running
+    const pidFile = '/tmp/claudetools-watcher.pid';
+    if (existsSync(pidFile)) {
+        try {
+            const pid = readFileSync(pidFile, 'utf-8').trim();
+            process.kill(parseInt(pid), 'SIGTERM');
+            const { unlinkSync } = await import('fs');
+            unlinkSync(pidFile);
+            success('Stopped watcher');
+        }
+        catch {
+            // Process might already be dead
+        }
     }
+    console.log('\n' + chalk.green('ClaudeTools removed from Claude Code.'));
+    console.log(chalk.dim('Your ~/.claudetools/ config and data are preserved.\n'));
 }