@contextmirror/claude-memory 0.2.0 → 0.2.2

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'],
@@ -22,12 +25,33 @@ const MCP_SERVER_CONFIG = {
  * Run the setup wizard
  */
 export async function runSetupWizard(options = {}) {
-    const { projectsDir = guessProjectsDir(), skipMcp = false, skipBriefing = false, interactive = true, } = options;
+    const { projectsDir: providedDir, skipMcp = false, skipBriefing = false, interactive = true, } = options;
     console.log('');
     console.log('╔══════════════════════════════════════════════════════════╗');
     console.log('║         🧠 Claude Memory - Setup Wizard                  ║');
     console.log('╚══════════════════════════════════════════════════════════╝');
     console.log('');
+    // Determine projects directory
+    let projectsDir = providedDir || guessProjectsDir();
+    if (!projectsDir) {
+        console.log('📍 Step 0: Locate your projects\n');
+        console.log('   Could not auto-detect your projects directory.');
+        console.log('   Common locations like ~/Projects, ~/Code, ~/dev were not found.\n');
+        if (interactive) {
+            const answer = await ask('   Enter your projects directory path: ');
+            if (!answer || !existsSync(answer)) {
+                console.log('\n   ❌ Invalid directory. Please run:');
+                console.log('   claude-memory setup -d /path/to/your/projects');
+                return;
+            }
+            projectsDir = answer;
+        }
+        else {
+            console.log('   ❌ Cannot continue without a projects directory.');
+            console.log('   Run: claude-memory setup -d /path/to/your/projects');
+            return;
+        }
+    }
     // Step 1: Find projects
     console.log('📍 Step 1: Scanning for projects\n');
     console.log(`   Looking in: ${projectsDir}`);
@@ -104,6 +128,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!                    ║');
@@ -122,6 +185,7 @@ export async function runSetupWizard(options = {}) {
 }
 /**
  * Guess the user's projects directory
+ * Returns null if we can't find a reasonable guess (better than scanning home!)
  */
 function guessProjectsDir() {
     const home = homedir();
@@ -136,14 +200,27 @@ function guessProjectsDir() {
         join(home, 'src'),
         join(home, 'repos'),
         join(home, 'git'),
+        join(home, 'workspace'),
+        join(home, 'Workspace'),
     ];
     for (const dir of candidates) {
         if (existsSync(dir)) {
             return dir;
         }
     }
-    // Fall back to home directory
-    return home;
+    // Don't fall back to home - that scans way too much and causes issues
+    // Return null and let the caller handle it
+    return null;
+}
+/**
+ * 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

@@ -1,6 +1,8 @@
 /**
  * Core types for Claude Memory
  */
+/** Current schema version - increment when making breaking changes */
+export declare const SCHEMA_VERSION = 1;
 export interface ProjectInfo {
     /** Absolute path to project root */
     path: string;
@@ -43,14 +45,18 @@ export interface ProjectInsight {
     discoveredAt: string;
 }
 export interface GlobalContext {
+    /** Schema version for migration support */
+    schemaVersion: number;
     /** When the global context was last updated */
     lastUpdated: string;
     /** All scanned projects */
     projects: ProjectInfo[];
-    /** Cross-project insights */
+    /** Cross-project insights (preserved across rescans) */
     insights: GlobalInsight[];
     /** User preferences/patterns observed */
     userPatterns: UserPattern[];
+    /** Projects to exclude from scanning (by path) */
+    excludedProjects?: string[];
 }
 export interface GlobalInsight {
     /** Insight content */
@@ -85,3 +91,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

@@ -1,10 +1,49 @@
 /**
  * Core types for Claude Memory
  */
+/** Current schema version - increment when making breaking changes */
+export const SCHEMA_VERSION = 1;
+/**
+ * Get a sensible default projects directory
+ * Checks common locations, doesn't fall back to home
+ */
+function getDefaultProjectsDir() {
+    const home = process.env.HOME || '';
+    if (!home)
+        return './projects';
+    const candidates = [
+        `${home}/Projects`,
+        `${home}/Project`,
+        `${home}/projects`,
+        `${home}/Code`,
+        `${home}/code`,
+        `${home}/dev`,
+    ];
+    // Import fs dynamically to avoid issues
+    try {
+        const fs = require('fs');
+        for (const dir of candidates) {
+            if (fs.existsSync(dir)) {
+                return dir;
+            }
+        }
+    }
+    catch {
+        // fs not available, use first candidate
+    }
+    // Default to ~/Projects (most common convention)
+    return `${home}/Projects`;
+}
 export const DEFAULT_SCAN_OPTIONS = {
-    rootDir: process.env.HOME ? `${process.env.HOME}/Project` : './projects',
+    rootDir: getDefaultProjectsDir(),
     maxDepth: 2,
-    ignore: ['node_modules', '.git', 'dist', 'build', '__pycache__', 'target'],
+    ignore: ['node_modules', '.git', 'dist', 'build', '__pycache__', 'target', '.venv', 'venv', 'coverage', '.next'],
     generateClaudeMd: false,
     overwriteClaudeMd: false,
 };
+export const DEFAULT_MEMORY_CONFIG = {
+    watchedDirs: [],
+    autoDetectNewProjects: true,
+    promptForClaudeMd: true,
+    lastUpdated: new Date().toISOString(),
+};