@contextmirror/claude-memory 0.2.0 → 0.2.1

package/dist/mcp/server.js

@@ -13,6 +13,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextpro
 import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { DEFAULT_MEMORY_CONFIG } from '../types/index.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
 // Tool definitions
 const tools = [
@@ -21,7 +22,12 @@ const tools = [
         description: 'Get an overview of all projects the user is working on. Returns project names, descriptions, tech stacks, and recent activity. Use this at the start of conversations to understand the user\'s development environment.',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                cwd: {
+                    type: 'string',
+                    description: 'Current working directory. If provided, will check if this is a known project or a new project that needs setup.',
+                },
+            },
             required: [],
         },
     },
@@ -99,19 +105,150 @@ function loadContext() {
         return null;
     }
 }
-function handleGetGlobalContext() {
+function loadConfig() {
+    const configPath = join(MEMORY_DIR, 'config.json');
+    if (!existsSync(configPath)) {
+        return DEFAULT_MEMORY_CONFIG;
+    }
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return DEFAULT_MEMORY_CONFIG;
+    }
+}
+function saveConfig(config) {
+    const configPath = join(MEMORY_DIR, 'config.json');
+    config.lastUpdated = new Date().toISOString();
+    writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+/**
+ * Check if a directory looks like a project (has project markers)
+ */
+function looksLikeProject(dir) {
+    try {
+        const entries = readdirSync(dir);
+        return (entries.includes('package.json') ||
+            entries.includes('Cargo.toml') ||
+            entries.includes('pyproject.toml') ||
+            entries.includes('go.mod') ||
+            entries.includes('.git') ||
+            entries.includes('requirements.txt'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a path is under any of the watched directories
+ */
+function isUnderWatchedDir(path, watchedDirs) {
+    const normalizedPath = path.replace(/\/$/, '');
+    return watchedDirs.some(watchedDir => {
+        const normalizedWatched = watchedDir.replace(/\/$/, '');
+        return normalizedPath.startsWith(normalizedWatched);
+    });
+}
+/**
+ * Detect the status of the current working directory
+ */
+function detectCurrentDirectoryStatus(cwd, context, config) {
+    const normalizedCwd = cwd.replace(/\/$/, '');
+    // Check if it's a known project
+    if (context) {
+        const knownProject = context.projects.find(p => normalizedCwd === p.path.replace(/\/$/, '') ||
+            normalizedCwd.startsWith(p.path.replace(/\/$/, '') + '/'));
+        if (knownProject) {
+            return {
+                path: cwd,
+                status: 'known_project',
+                projectName: knownProject.name,
+                needsSetup: !knownProject.hasFiles.claudeMd,
+                suggestedAction: knownProject.hasFiles.claudeMd ? 'none' : 'offer_setup',
+            };
+        }
+    }
+    // Check if it's under a watched directory
+    if (config.autoDetectNewProjects && isUnderWatchedDir(cwd, config.watchedDirs)) {
+        // It's under a watched dir but not a known project
+        if (looksLikeProject(cwd)) {
+            return {
+                path: cwd,
+                status: 'new_project',
+                needsSetup: true,
+                suggestedAction: 'offer_setup',
+            };
+        }
+        else {
+            // Empty or non-project directory under watched area
+            return {
+                path: cwd,
+                status: 'new_project',
+                needsSetup: true,
+                suggestedAction: 'offer_setup',
+            };
+        }
+    }
+    // Not under watched directories
+    if (looksLikeProject(cwd)) {
+        return {
+            path: cwd,
+            status: 'outside_workspace',
+            needsSetup: false,
+            suggestedAction: 'offer_scan',
+        };
+    }
+    return {
+        path: cwd,
+        status: 'not_a_project',
+        needsSetup: false,
+        suggestedAction: 'none',
+    };
+}
+function handleGetGlobalContext(cwd) {
     const context = loadContext();
+    const config = loadConfig();
+    const lines = [];
+    // If cwd is provided, check the current directory status first
+    if (cwd) {
+        const cwdStatus = detectCurrentDirectoryStatus(cwd, context, config);
+        lines.push('# Current Directory Status');
+        lines.push('');
+        lines.push(`**Path:** ${cwdStatus.path}`);
+        lines.push(`**Status:** ${cwdStatus.status}`);
+        if (cwdStatus.projectName) {
+            lines.push(`**Project:** ${cwdStatus.projectName}`);
+        }
+        if (cwdStatus.needsSetup) {
+            lines.push(`**Needs Setup:** Yes`);
+        }
+        // Add actionable guidance for Claude
+        if (cwdStatus.suggestedAction === 'offer_setup') {
+            lines.push('');
+            lines.push('> 🆕 **New Project Detected!** This directory is not yet registered.');
+            lines.push('> Ask the user if they would like you to:');
+            lines.push('> 1. Generate a CLAUDE.md file for this project');
+            lines.push('> 2. Add this project to the memory index');
+        }
+        else if (cwdStatus.suggestedAction === 'offer_scan') {
+            lines.push('');
+            lines.push('> ℹ️ This looks like a project but is outside your watched directories.');
+            lines.push('> You may want to run `claude-memory scan` to add it.');
+        }
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+    }
     if (!context) {
-        return 'No projects scanned yet. Run `claude-memory scan` first.';
+        lines.push('No projects scanned yet. Run `claude-memory scan` first.');
+        return lines.join('\n');
     }
-    const lines = [
-        `# Your Development Environment`,
-        '',
-        `Last scanned: ${new Date(context.lastUpdated).toLocaleString()}`,
-        '',
-        '## Active Projects',
-        '',
-    ];
+    lines.push('# Your Development Environment');
+    lines.push('');
+    lines.push(`Last scanned: ${new Date(context.lastUpdated).toLocaleString()}`);
+    lines.push('');
+    lines.push('## Active Projects');
+    lines.push('');
     // Sort by activity
     const sorted = [...context.projects].sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
     for (const p of sorted) {
@@ -123,6 +260,16 @@ function handleGetGlobalContext() {
         lines.push(`- **Description:** ${p.description}`);
         lines.push('');
     }
+    // Add config info
+    if (config.watchedDirs.length > 0) {
+        lines.push('## Watched Directories');
+        lines.push('');
+        for (const dir of config.watchedDirs) {
+            lines.push(`- ${dir}`);
+        }
+        lines.push('');
+        lines.push(`Auto-detect new projects: ${config.autoDetectNewProjects ? 'Yes' : 'No'}`);
+    }
     return lines.join('\n');
 }
 function handleGetProjectSummary(projectQuery) {
@@ -351,7 +498,7 @@ async function main() {
             let result;
             switch (name) {
                 case 'get_global_context':
-                    result = handleGetGlobalContext();
+                    result = handleGetGlobalContext(args.cwd);
                     break;
                 case 'get_project_summary':
                     result = handleGetProjectSummary(args.project);

package/dist/setup/setupWizard.js

@@ -6,14 +6,17 @@
  * 2. Offers to generate CLAUDE.md for projects without one
  * 3. Auto-configures MCP in ~/.claude.json
  */
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { createInterface } from 'readline';
 import { scanProjects } from '../scanner/projectScanner.js';
 import { generateGlobalContext, writeGlobalContext } from '../scanner/contextGenerator.js';
 import { generateBriefing, briefingToClaudeMd } from '../briefing/briefingGenerator.js';
+import { DEFAULT_MEMORY_CONFIG } from '../types/index.js';
 const CLAUDE_JSON_PATH = join(homedir(), '.claude.json');
+const MEMORY_DIR = join(homedir(), '.claude-memory');
+const CONFIG_PATH = join(MEMORY_DIR, 'config.json');
 const MCP_SERVER_CONFIG = {
     command: 'claude-memory',
     args: ['mcp'],
@@ -104,6 +107,45 @@ export async function runSetupWizard(options = {}) {
             console.log('   }');
         }
     }
+    // Step 5: Configure auto-detection
+    console.log('\n📍 Step 5: Configure new project detection\n');
+    if (interactive) {
+        console.log('   When you create a new folder in your projects directory,');
+        console.log('   Claude can automatically detect it and offer to set it up.');
+        console.log('');
+        const enableAutoDetect = await ask('   Enable auto-detection of new projects? (Y/n) ');
+        const config = {
+            ...DEFAULT_MEMORY_CONFIG,
+            watchedDirs: [projectsDir],
+            autoDetectNewProjects: enableAutoDetect.toLowerCase() !== 'n',
+            promptForClaudeMd: true,
+            lastUpdated: new Date().toISOString(),
+        };
+        saveMemoryConfig(config);
+        if (config.autoDetectNewProjects) {
+            console.log('   ✅ Auto-detection enabled');
+            console.log(`   📁 Watching: ${projectsDir}`);
+            console.log('');
+            console.log('   When you start Claude in a new folder under this directory,');
+            console.log('   it will offer to generate a CLAUDE.md and add the project to memory.');
+        }
+        else {
+            console.log('   ℹ️  Auto-detection disabled');
+            console.log('   You can manually add projects with: claude-memory scan');
+        }
+    }
+    else {
+        // Non-interactive: enable with defaults
+        const config = {
+            ...DEFAULT_MEMORY_CONFIG,
+            watchedDirs: [projectsDir],
+            autoDetectNewProjects: true,
+            promptForClaudeMd: true,
+            lastUpdated: new Date().toISOString(),
+        };
+        saveMemoryConfig(config);
+        console.log('   ✅ Auto-detection enabled (default)');
+    }
     // Done!
     console.log('\n╔══════════════════════════════════════════════════════════╗');
     console.log('║                    ✅ Setup Complete!                    ║');
@@ -145,6 +187,16 @@ function guessProjectsDir() {
     // Fall back to home directory
     return home;
 }
+/**
+ * Save memory config to ~/.claude-memory/config.json
+ */
+function saveMemoryConfig(config) {
+    // Ensure directory exists
+    if (!existsSync(MEMORY_DIR)) {
+        mkdirSync(MEMORY_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
 /**
  * Configure MCP in ~/.claude.json
  */

package/dist/types/index.d.ts

@@ -85,3 +85,32 @@ export interface ScanOptions {
     overwriteClaudeMd: boolean;
 }
 export declare const DEFAULT_SCAN_OPTIONS: ScanOptions;
+/**
+ * Configuration for claude-memory behavior
+ */
+export interface MemoryConfig {
+    /** Directories to watch for new projects */
+    watchedDirs: string[];
+    /** Whether to auto-detect new projects in watched dirs */
+    autoDetectNewProjects: boolean;
+    /** Whether to prompt for CLAUDE.md generation on new projects */
+    promptForClaudeMd: boolean;
+    /** When config was last updated */
+    lastUpdated: string;
+}
+export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
+/**
+ * Status of the current working directory
+ */
+export interface CurrentDirectoryStatus {
+    /** The path being checked */
+    path: string;
+    /** Status of this directory */
+    status: 'known_project' | 'new_project' | 'outside_workspace' | 'not_a_project';
+    /** Project name if it's a known project */
+    projectName?: string;
+    /** Whether this directory needs setup */
+    needsSetup?: boolean;
+    /** Suggested action for Claude to take */
+    suggestedAction?: 'none' | 'offer_setup' | 'offer_scan';
+}

package/dist/types/index.js

@@ -8,3 +8,9 @@ export const DEFAULT_SCAN_OPTIONS = {
     generateClaudeMd: false,
     overwriteClaudeMd: false,
 };
+export const DEFAULT_MEMORY_CONFIG = {
+    watchedDirs: [],
+    autoDetectNewProjects: true,
+    promptForClaudeMd: true,
+    lastUpdated: new Date().toISOString(),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextmirror/claude-memory",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Cross-project memory for Claude Code - know about all your projects",
   "type": "module",
   "main": "dist/cli.js",