@claudetools/tools 0.3.4 → 0.3.6

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, runUninstall, runInit } from './setup.js';
+import { runSetup, runUninstall, runInit, runCleanup } from './setup.js';
 import { startServer } from './index.js';
 import { startWatcher, stopWatcher, watcherStatus } from './watcher.js';
 // Get version from package.json
@@ -49,6 +49,7 @@ Options:
 
 Commands:
   init             Initialize current directory as a project
+  cleanup          Remove legacy config and broken hooks
   watch            Start the file watcher daemon
   watch --stop     Stop the watcher daemon
   watch --status   Check watcher status
@@ -79,6 +80,13 @@ else if (positionals[0] === 'init') {
         process.exit(1);
     });
 }
+else if (positionals[0] === 'cleanup') {
+    // Handle cleanup command
+    runCleanup().catch((error) => {
+        console.error('Cleanup failed:', error);
+        process.exit(1);
+    });
+}
 else if (positionals[0] === 'watch') {
     // Handle watch command
     const watchArgs = process.argv.slice(3); // Get args after 'watch'

package/dist/helpers/config.d.ts

@@ -14,7 +14,8 @@ export interface ProjectsCache {
     last_sync: string;
 }
 /**
- * Validates that a project ID is a proper UUID format
+ * Validates that a project ID is in a valid format
+ * Accepts both API-registered (proj_*) and local fallback (local_*) formats
  */
 export declare function isValidProjectId(id: string): boolean;
 /**

package/dist/helpers/config.js

@@ -13,10 +13,19 @@ export const PROJECTS_FILE = getProjectsPath();
 // Cache for resolved project ID
 let resolvedProjectId = null;
 /**
- * Validates that a project ID is a proper UUID format
+ * Validates that a project ID is in a valid format
+ * Accepts both API-registered (proj_*) and local fallback (local_*) formats
  */
 export function isValidProjectId(id) {
-    return /^proj_[a-f0-9]{20}$/.test(id);
+    // API-registered format: proj_ followed by 20 hex chars
+    if (/^proj_[a-f0-9]{20}$/.test(id)) {
+        return true;
+    }
+    // Local fallback format: local_ followed by sanitized project name
+    if (/^local_[a-z0-9_]+$/.test(id)) {
+        return true;
+    }
+    return false;
 }
 /**
  * Finds a project binding in the cache by directory path
@@ -78,7 +87,7 @@ export async function resolveProjectIdAsync() {
         // Validate UUID format
         if (!isValidProjectId(envProjectId)) {
             throw new Error(`Invalid project ID format in CLAUDETOOLS_PROJECT_ID: ${envProjectId}. ` +
-                `Expected format: proj_xxxxxxxxxxxxxxxxxxxx (20 hex chars)`);
+                `Expected format: proj_xxxxxxxxxxxxxxxxxxxx or local_projectname`);
         }
         resolvedProjectId = envProjectId;
         mcpLogger.debug('MEMORY', `Using project ID from env: ${resolvedProjectId}`);
@@ -135,7 +144,7 @@ export function getDefaultProjectId() {
     if (config.defaultProjectId) {
         if (!isValidProjectId(config.defaultProjectId)) {
             throw new Error(`Invalid defaultProjectId in config: ${config.defaultProjectId}. ` +
-                `Expected format: proj_xxxxxxxxxxxxxxxxxxxx (20 hex chars)`);
+                `Expected format: proj_xxxxxxxxxxxxxxxxxxxx or local_projectname`);
         }
         _defaultProjectId = config.defaultProjectId;
         return _defaultProjectId;
@@ -155,7 +164,7 @@ export async function getDefaultProjectIdAsync() {
     if (config.defaultProjectId) {
         if (!isValidProjectId(config.defaultProjectId)) {
             throw new Error(`Invalid defaultProjectId in config: ${config.defaultProjectId}. ` +
-                `Expected format: proj_xxxxxxxxxxxxxxxxxxxx (20 hex chars)`);
+                `Expected format: proj_xxxxxxxxxxxxxxxxxxxx or local_projectname`);
         }
         _defaultProjectId = config.defaultProjectId;
         return _defaultProjectId;

package/dist/setup.d.ts

@@ -1,3 +1,4 @@
 export declare function runSetup(): Promise<void>;
 export declare function runUninstall(): Promise<void>;
 export declare function runInit(): Promise<void>;
+export declare function runCleanup(): Promise<void>;

package/dist/setup.js

@@ -18,11 +18,19 @@ import { GLOBAL_TEMPLATE, SECTION_START, SECTION_END, getProjectTemplate, } from
 const CLAUDE_DIR = join(homedir(), '.claude');
 const CLAUDETOOLS_DIR = join(homedir(), '.claudetools');
 const MCP_CONFIG_PATH = join(CLAUDE_DIR, 'mcp.json');
+const CLAUDE_DESKTOP_CONFIG_PATH = join(CLAUDE_DIR, 'claude_desktop_config.json');
 const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
 const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
 const CLAUDE_MD_PATH = join(CLAUDE_DIR, 'CLAUDE.md');
 const SYSTEM_FILE = join(CLAUDETOOLS_DIR, 'system.json');
 const PROJECTS_FILE = join(CLAUDETOOLS_DIR, 'projects.json');
+// Legacy env vars that should be removed from MCP configs
+const LEGACY_ENV_VARS = [
+    'CLAUDETOOLS_PROJECT_ID',
+    'CLAUDETOOLS_USER_ID',
+    'AUTO_INJECT_CONTEXT',
+    'MEMORY_PROJECT_ID',
+];
 // -----------------------------------------------------------------------------
 // Utility Functions
 // -----------------------------------------------------------------------------
@@ -40,6 +48,61 @@ function error(msg) {
 function info(msg) {
     console.log(chalk.blue('ℹ ') + msg);
 }
+/**
+ * Clean up legacy env vars from MCP server configs
+ * This removes deprecated vars like CLAUDETOOLS_PROJECT_ID that cause validation errors
+ */
+function cleanupLegacyMcpConfig(configPath) {
+    if (!existsSync(configPath)) {
+        return false;
+    }
+    try {
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        let modified = false;
+        if (config.mcpServers) {
+            for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+                if (serverConfig.env) {
+                    for (const legacyVar of LEGACY_ENV_VARS) {
+                        if (legacyVar in serverConfig.env) {
+                            delete serverConfig.env[legacyVar];
+                            modified = true;
+                            info(`Removed legacy ${legacyVar} from ${serverName}`);
+                        }
+                    }
+                    // Remove empty env object
+                    if (Object.keys(serverConfig.env).length === 0) {
+                        delete serverConfig.env;
+                    }
+                }
+            }
+        }
+        if (modified) {
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+            return true;
+        }
+    }
+    catch (err) {
+        // Non-fatal - just skip cleanup
+    }
+    return false;
+}
+/**
+ * Clean up all legacy MCP configs (both mcp.json and claude_desktop_config.json)
+ */
+function cleanupAllLegacyConfigs() {
+    let cleaned = false;
+    if (cleanupLegacyMcpConfig(MCP_CONFIG_PATH)) {
+        success('Cleaned up legacy config in mcp.json');
+        cleaned = true;
+    }
+    if (cleanupLegacyMcpConfig(CLAUDE_DESKTOP_CONFIG_PATH)) {
+        success('Cleaned up legacy config in claude_desktop_config.json');
+        cleaned = true;
+    }
+    if (!cleaned) {
+        info('No legacy config cleanup needed');
+    }
+}
 // -----------------------------------------------------------------------------
 // System Registration
 // -----------------------------------------------------------------------------
@@ -999,15 +1062,18 @@ export async function runSetup() {
         header('Saving Configuration');
         await saveConfig(extendedConfig);
         success(`Configuration saved to ${getConfigPath()}`);
-        // Step 6: Configure Claude Code MCP
+        // Step 6: Clean up legacy configs
+        header('Legacy Config Cleanup');
+        cleanupAllLegacyConfigs();
+        // Step 7: Configure Claude Code MCP
         await configureMcpSettings(services);
-        // Step 7: Install Hooks
+        // Step 8: Install Hooks
         await installHooks();
-        // Step 8: Configure Settings
+        // Step 9: Configure Settings
         await configureSettings();
-        // Step 9: Configure CLAUDE.md
+        // Step 10: Configure CLAUDE.md
         await configureCLAUDEMD();
-        // Step 10: Verify
+        // Step 11: Verify
         await verifySetup(extendedConfig);
         // Done
         header('Setup Complete');
@@ -1268,3 +1334,61 @@ export async function runInit() {
     console.log('  ' + chalk.bold('Config:') + ` ${projectClaudeMd}\n`);
     console.log(chalk.dim('  Memory tools are now configured for this project.\n'));
 }
+// -----------------------------------------------------------------------------
+// Cleanup Command (standalone)
+// -----------------------------------------------------------------------------
+export async function runCleanup() {
+    console.log('\n' + chalk.bold.cyan('  ClaudeTools Legacy Cleanup') + '\n');
+    header('Cleaning Legacy Configurations');
+    cleanupAllLegacyConfigs();
+    // Also clean up any project-level legacy hooks
+    const cwd = process.cwd();
+    const projectSettingsPath = join(cwd, '.claude', 'settings.json');
+    if (existsSync(projectSettingsPath)) {
+        try {
+            const settings = JSON.parse(readFileSync(projectSettingsPath, 'utf-8'));
+            let modified = false;
+            if (settings.hooks) {
+                for (const hookType of Object.keys(settings.hooks)) {
+                    const hooks = settings.hooks[hookType];
+                    if (Array.isArray(hooks)) {
+                        const filtered = hooks.filter((h) => {
+                            // Remove hooks pointing to non-existent files or legacy memory-capture hooks
+                            if (h.hooks) {
+                                return !h.hooks.some(hk => {
+                                    if (!hk.command)
+                                        return false;
+                                    // Remove if it's a legacy memory hook
+                                    if (hk.command.includes('memory-capture') ||
+                                        hk.command.includes('memory-context-injection') ||
+                                        hk.command.includes('memory-session-save')) {
+                                        return true;
+                                    }
+                                    // Remove if the file doesn't exist
+                                    if (hk.command.startsWith('/') && !existsSync(hk.command.split(' ')[0])) {
+                                        return true;
+                                    }
+                                    return false;
+                                });
+                            }
+                            return true;
+                        });
+                        if (filtered.length !== hooks.length) {
+                            settings.hooks[hookType] = filtered;
+                            modified = true;
+                        }
+                    }
+                }
+            }
+            if (modified) {
+                writeFileSync(projectSettingsPath, JSON.stringify(settings, null, 2));
+                success('Cleaned up project-level legacy hooks');
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    console.log('\n' + chalk.green('  Cleanup complete!'));
+    console.log(chalk.dim('  Restart Claude Code for changes to take effect.\n'));
+}

package/package.json

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