@claudetools/tools 0.1.2 → 0.2.1

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.1.2",
+  "version": "0.2.1",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",
@@ -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",