@claudetools/tools 0.2.0 → 0.2.2

package/dist/cli.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { runSetup, runUninstall } from './setup.js';
 import { startServer } from './index.js';
+import { startWatcher, stopWatcher, watcherStatus } from './watcher.js';
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -16,14 +17,14 @@ const packagePath = join(__dirname, '..', 'package.json');
 const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
 const version = packageJson.version;
 // Parse command-line arguments
-const { values } = parseArgs({
+const { values, positionals } = parseArgs({
     options: {
         setup: { type: 'boolean', short: 's' },
         uninstall: { type: 'boolean', short: 'u' },
         version: { type: 'boolean', short: 'v' },
         help: { type: 'boolean', short: 'h' },
     },
-    allowPositionals: false,
+    allowPositionals: true,
 });
 // Handle version flag
 if (values.version) {
@@ -37,6 +38,7 @@ claudetools - Persistent AI memory for Claude Code
 
 Usage:
   claudetools [options]
+  claudetools [command]
 
 Options:
   -s, --setup      Interactive setup wizard
@@ -44,7 +46,12 @@ Options:
   -v, --version    Show version
   -h, --help       Show this help
 
-Running without options starts the server.
+Commands:
+  watch            Start the file watcher daemon
+  watch --stop     Stop the watcher daemon
+  watch --status   Check watcher status
+
+Running without options starts the MCP server.
 
 Documentation: https://github.com/claudetools/memory
 `);
@@ -63,6 +70,22 @@ else if (values.uninstall) {
         process.exit(1);
     });
 }
+else if (positionals[0] === 'watch') {
+    // Handle watch command
+    const watchArgs = process.argv.slice(3); // Get args after 'watch'
+    if (watchArgs.includes('--stop')) {
+        stopWatcher();
+    }
+    else if (watchArgs.includes('--status')) {
+        watcherStatus();
+    }
+    else {
+        startWatcher().catch((error) => {
+            console.error('Watcher failed:', error);
+            process.exit(1);
+        });
+    }
+}
 else {
     // Start MCP server
     startServer();

package/dist/helpers/project-registration.js

@@ -85,15 +85,21 @@ async function ensureSystemRegistered() {
  */
 function detectGitRemote(localPath) {
     try {
+        // Resolve symlinks and validate path to prevent path traversal attacks
+        const resolvedPath = fs.realpathSync(localPath);
+        // Ensure path is absolute and doesn't contain path traversal
+        if (!path.isAbsolute(resolvedPath) || resolvedPath.includes('..')) {
+            return undefined;
+        }
         const gitRemote = execSync('git config --get remote.origin.url', {
-            cwd: localPath,
+            cwd: resolvedPath,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'ignore'],
         }).trim();
         return gitRemote || undefined;
     }
     catch {
-        // Not a git repo or no remote configured
+        // Not a git repo, no remote configured, or invalid path
         return undefined;
     }
 }

package/dist/setup.js

@@ -5,16 +5,21 @@
 import prompts from 'prompts';
 import chalk from 'chalk';
 import ora from 'ora';
-import { homedir } from 'os';
-import { join } from 'path';
+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';
 // -----------------------------------------------------------------------------
 // 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
 // -----------------------------------------------------------------------------
@@ -33,6 +38,77 @@ 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;
+}
+function initializeProjectsFile() {
+    if (!existsSync(PROJECTS_FILE)) {
+        writeFileSync(PROJECTS_FILE, JSON.stringify({
+            bindings: [],
+            last_sync: new Date().toISOString(),
+        }, null, 2));
+    }
+}
+// -----------------------------------------------------------------------------
 // Authentication
 // -----------------------------------------------------------------------------
 async function authenticateWithEmailPassword(apiUrl) {
@@ -78,7 +154,6 @@ async function authenticateWithEmailPassword(apiUrl) {
 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' },
@@ -93,7 +168,6 @@ async function authenticateWithDeviceCode(apiUrl) {
         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) {
@@ -206,6 +280,79 @@ async function runAuthFlow(apiUrl) {
     }
 }
 // -----------------------------------------------------------------------------
+// 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;
+        }
+    }
+    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];
+}
+// -----------------------------------------------------------------------------
 // Service Configuration
 // -----------------------------------------------------------------------------
 async function configureServices() {
@@ -241,10 +388,10 @@ function ensureClaudeDir() {
         mkdirSync(CLAUDE_DIR, { recursive: true });
     }
 }
-function backupFile(path) {
-    if (existsSync(path)) {
-        const backupPath = `${path}.backup.${Date.now()}`;
-        copyFileSync(path, backupPath);
+function backupFile(filePath) {
+    if (existsSync(filePath)) {
+        const backupPath = `${filePath}.backup.${Date.now()}`;
+        copyFileSync(filePath, backupPath);
         return backupPath;
     }
     return null;
@@ -259,7 +406,7 @@ async function configureMcpSettings(services) {
             mcpConfig = JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf-8'));
             const backup = backupFile(MCP_CONFIG_PATH);
             if (backup) {
-                info(`Backed up existing config to ${backup}`);
+                info(`Backed up existing config to ${basename(backup)}`);
             }
         }
         catch {
@@ -280,7 +427,7 @@ async function configureMcpSettings(services) {
     if (services.context7ApiKey) {
         servers['context7'] = {
             command: 'npx',
-            args: ['-y', '@context7/mcp-server'],
+            args: ['-y', '@upstash/context7-mcp'],
             env: {
                 CONTEXT7_API_KEY: services.context7ApiKey,
             },
@@ -305,6 +452,38 @@ async function installHooks() {
     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
@@ -328,27 +507,39 @@ API_KEY=$(jq -r '.apiKey // empty' "$CONFIG_FILE")
 
 if [ -z "$API_KEY" ]; then exit 0; fi
 
-# Get current project
+# Get current project from projects.json
 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")
+  # 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)
-curl -s -X POST "$API_URL/api/v1/context/inject" \\
+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 || true
+  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 ${backup}`);
+            info(`Backed up existing hook to ${basename(backup)}`);
     }
     writeFileSync(userPromptPath, userPromptHook, { mode: 0o755 });
     success('Installed user-prompt-submit.sh hook');
@@ -389,11 +580,87 @@ curl -s -X POST "$API_URL/api/v1/tools/log" \\
     if (existsSync(postToolPath)) {
         const backup = backupFile(postToolPath);
         if (backup)
-            info(`Backed up existing hook to ${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
 // -----------------------------------------------------------------------------
@@ -401,7 +668,7 @@ async function verifySetup(config) {
     header('Verification');
     const spinner = ora('Checking API connection...').start();
     try {
-        const response = await fetch(`${config.apiUrl}/health`, {
+        const response = await fetch(`${config.apiUrl}/api/v1/health`, {
             headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
             signal: AbortSignal.timeout(10000),
         });
@@ -415,6 +682,13 @@ async function verifySetup(config) {
     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');
@@ -423,11 +697,20 @@ async function verifySetup(config) {
         error('MCP config not found');
     }
     // Check hooks installed
-    if (existsSync(join(HOOKS_DIR, 'user-prompt-submit.sh'))) {
-        success('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('Hooks not found');
+        error('Settings not found');
     }
 }
 // -----------------------------------------------------------------------------
@@ -445,7 +728,7 @@ export async function runSetup() {
         // Step 1: Authentication
         header('Authentication');
         if (config.apiKey) {
-            info(`Existing API key found: ${config.apiKey.substring(0, 10)}...`);
+            info(`Existing API key found: ${config.apiKey.substring(0, 6)}...`);
             const { replace } = await prompts({
                 type: 'confirm',
                 name: 'replace',
@@ -478,23 +761,47 @@ export async function runSetup() {
                 }
             }
         }
-        // Step 2: Service Configuration
+        // 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 {
+            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 service configs in extended config
+        // Store all configs
         const extendedConfig = config;
         if (services.context7ApiKey) {
             extendedConfig.context7ApiKey = services.context7ApiKey;
         }
         extendedConfig.sequentialThinkingEnabled = services.sequentialThinkingEnabled;
-        // Step 3: Save ClaudeTools config
+        extendedConfig.watchedDirectories = projectDirs;
+        // Step 5: Save ClaudeTools config
         header('Saving Configuration');
         await saveConfig(extendedConfig);
         success(`Configuration saved to ${getConfigPath()}`);
-        // Step 4: Configure Claude Code MCP
+        // Step 6: Configure Claude Code MCP
         await configureMcpSettings(services);
-        // Step 5: Install Hooks
+        // Step 7: Install Hooks
         await installHooks();
-        // Step 6: Verify
+        // Step 8: Configure Settings
+        await configureSettings();
+        // Step 9: Verify
         await verifySetup(extendedConfig);
         // Done
         header('Setup Complete');
@@ -536,8 +843,27 @@ export async function runUninstall() {
             error('Could not update MCP config');
         }
     }
-    // Remove hooks
-    const hooks = ['user-prompt-submit.sh', 'post-tool-use.sh'];
+    // 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');
+            }
+        }
+        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)) {
@@ -549,6 +875,20 @@ export async function runUninstall() {
             }
         }
     }
+    // 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'));
 }

package/dist/watcher.d.ts

@@ -0,0 +1,3 @@
+export declare function startWatcher(): Promise<void>;
+export declare function stopWatcher(): void;
+export declare function watcherStatus(): void;

package/dist/watcher.js

@@ -0,0 +1,307 @@
+// =============================================================================
+// ClaudeTools Code Watcher Daemon
+// =============================================================================
+// Monitors project directories for changes and syncs with the API
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, watch, readdirSync, statSync } from 'fs';
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const PID_FILE = '/tmp/claudetools-watcher.pid';
+const LOG_FILE = '/tmp/claudetools-watcher.log';
+const CONFIG_FILE = join(homedir(), '.claudetools', 'config.json');
+const PROJECTS_FILE = join(homedir(), '.claudetools', 'projects.json');
+const SYSTEM_FILE = join(homedir(), '.claudetools', 'system.json');
+// -----------------------------------------------------------------------------
+// Logging
+// -----------------------------------------------------------------------------
+function log(level, message) {
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+    // Write to log file
+    try {
+        const fs = require('fs');
+        fs.appendFileSync(LOG_FILE, line);
+    }
+    catch {
+        // Ignore write errors
+    }
+    // Also output to console when running interactively
+    if (process.stdout.isTTY) {
+        const prefix = level === 'error' ? '\x1b[31m' : level === 'warn' ? '\x1b[33m' : '\x1b[36m';
+        console.log(`${prefix}[${level}]\x1b[0m ${message}`);
+    }
+}
+function loadConfig() {
+    try {
+        if (!existsSync(CONFIG_FILE)) {
+            log('error', `Config file not found: ${CONFIG_FILE}`);
+            return null;
+        }
+        const config = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+        if (!config.apiKey) {
+            log('error', 'No API key configured');
+            return null;
+        }
+        return {
+            apiUrl: config.apiUrl || 'https://api.claudetools.dev',
+            apiKey: config.apiKey,
+            watchedDirectories: config.watchedDirectories,
+        };
+    }
+    catch (err) {
+        log('error', `Failed to load config: ${err}`);
+        return null;
+    }
+}
+function loadSystemInfo() {
+    try {
+        if (!existsSync(SYSTEM_FILE)) {
+            return null;
+        }
+        return JSON.parse(readFileSync(SYSTEM_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+// -----------------------------------------------------------------------------
+// PID File Management
+// -----------------------------------------------------------------------------
+function writePidFile() {
+    writeFileSync(PID_FILE, String(process.pid));
+}
+function removePidFile() {
+    try {
+        if (existsSync(PID_FILE)) {
+            unlinkSync(PID_FILE);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+function isWatcherRunning() {
+    if (!existsSync(PID_FILE)) {
+        return false;
+    }
+    try {
+        const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim());
+        // Check if process is alive
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        // Process not running or permission denied
+        removePidFile();
+        return false;
+    }
+}
+function discoverProjects(directories) {
+    const projects = [];
+    for (const dir of directories) {
+        if (!existsSync(dir)) {
+            continue;
+        }
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                try {
+                    const stat = statSync(fullPath);
+                    if (!stat.isDirectory() || entry.startsWith('.')) {
+                        continue;
+                    }
+                    const hasGit = existsSync(join(fullPath, '.git'));
+                    const hasPackageJson = existsSync(join(fullPath, 'package.json'));
+                    // Consider it a project if it has git or package.json
+                    if (hasGit || hasPackageJson) {
+                        projects.push({
+                            name: entry,
+                            path: fullPath,
+                            hasGit,
+                            hasPackageJson,
+                        });
+                    }
+                }
+                catch {
+                    // Skip inaccessible entries
+                }
+            }
+        }
+        catch (err) {
+            log('warn', `Could not read directory ${dir}: ${err}`);
+        }
+    }
+    return projects;
+}
+// -----------------------------------------------------------------------------
+// API Sync
+// -----------------------------------------------------------------------------
+async function syncProjectsWithAPI(config, system, projects) {
+    try {
+        const response = await fetch(`${config.apiUrl}/api/v1/projects/sync`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({
+                system_id: system.system_id,
+                projects: projects.map(p => ({
+                    name: p.name,
+                    local_path: p.path,
+                    has_git: p.hasGit,
+                })),
+            }),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            // Update local projects file
+            if (data.bindings) {
+                const projectsData = existsSync(PROJECTS_FILE)
+                    ? JSON.parse(readFileSync(PROJECTS_FILE, 'utf-8'))
+                    : { bindings: [] };
+                projectsData.bindings = data.bindings;
+                projectsData.last_sync = new Date().toISOString();
+                writeFileSync(PROJECTS_FILE, JSON.stringify(projectsData, null, 2));
+            }
+            log('info', `Synced ${projects.length} projects with API`);
+        }
+        else {
+            const text = await response.text();
+            log('warn', `API sync returned ${response.status}: ${text}`);
+        }
+    }
+    catch (err) {
+        log('error', `Failed to sync with API: ${err}`);
+    }
+}
+// -----------------------------------------------------------------------------
+// File Watcher
+// -----------------------------------------------------------------------------
+function startWatching(directories, onChange) {
+    const watchers = [];
+    let debounceTimer = null;
+    const debouncedOnChange = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(onChange, 5000); // 5 second debounce
+    };
+    for (const dir of directories) {
+        if (!existsSync(dir)) {
+            continue;
+        }
+        try {
+            const watcher = watch(dir, { recursive: false }, (eventType, filename) => {
+                if (filename && !filename.startsWith('.')) {
+                    log('info', `Detected ${eventType} in ${dir}: ${filename}`);
+                    debouncedOnChange();
+                }
+            });
+            watcher.on('error', (err) => {
+                log('error', `Watcher error for ${dir}: ${err}`);
+            });
+            watchers.push(watcher);
+            log('info', `Watching directory: ${dir}`);
+        }
+        catch (err) {
+            log('warn', `Could not watch directory ${dir}: ${err}`);
+        }
+    }
+    // Clean up on exit
+    const cleanup = () => {
+        for (const watcher of watchers) {
+            watcher.close();
+        }
+        removePidFile();
+    };
+    process.on('SIGINT', () => {
+        log('info', 'Received SIGINT, shutting down...');
+        cleanup();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        log('info', 'Received SIGTERM, shutting down...');
+        cleanup();
+        process.exit(0);
+    });
+}
+// -----------------------------------------------------------------------------
+// Main
+// -----------------------------------------------------------------------------
+export async function startWatcher() {
+    // Check if already running
+    if (isWatcherRunning()) {
+        log('info', 'Watcher is already running');
+        console.log('Watcher is already running. Use "claudetools watch --stop" to stop it.');
+        return;
+    }
+    // Load config
+    const config = loadConfig();
+    if (!config) {
+        console.error('Failed to load config. Run "claudetools --setup" first.');
+        process.exit(1);
+    }
+    // Load system info
+    const system = loadSystemInfo();
+    if (!system) {
+        console.error('System not registered. Run "claudetools --setup" first.');
+        process.exit(1);
+    }
+    // Determine directories to watch
+    const directories = config.watchedDirectories || [join(homedir(), 'Projects')];
+    if (directories.length === 0) {
+        console.error('No directories configured to watch.');
+        process.exit(1);
+    }
+    // Write PID file
+    writePidFile();
+    log('info', `ClaudeTools watcher started (PID: ${process.pid})`);
+    console.log(`Watcher started (PID: ${process.pid})`);
+    console.log(`Watching: ${directories.join(', ')}`);
+    console.log(`Log file: ${LOG_FILE}`);
+    // Initial project discovery and sync
+    const projects = discoverProjects(directories);
+    log('info', `Discovered ${projects.length} projects`);
+    await syncProjectsWithAPI(config, system, projects);
+    // Set up file watching
+    const resync = async () => {
+        const updatedProjects = discoverProjects(directories);
+        await syncProjectsWithAPI(config, system, updatedProjects);
+    };
+    startWatching(directories, resync);
+    // Periodic resync every 5 minutes
+    setInterval(resync, 5 * 60 * 1000);
+    // Keep process alive
+    log('info', 'Watcher is running. Press Ctrl+C to stop.');
+}
+export function stopWatcher() {
+    if (!existsSync(PID_FILE)) {
+        console.log('Watcher is not running.');
+        return;
+    }
+    try {
+        const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim());
+        process.kill(pid, 'SIGTERM');
+        console.log(`Stopped watcher (PID: ${pid})`);
+        removePidFile();
+    }
+    catch (err) {
+        console.error(`Failed to stop watcher: ${err}`);
+        // Clean up stale PID file
+        removePidFile();
+    }
+}
+export function watcherStatus() {
+    if (isWatcherRunning()) {
+        const pid = readFileSync(PID_FILE, 'utf-8').trim();
+        console.log(`Watcher is running (PID: ${pid})`);
+        console.log(`Log file: ${LOG_FILE}`);
+    }
+    else {
+        console.log('Watcher is not running.');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",