@contextmirror/claude-memory 0.2.1 → 0.2.2

package/dist/scanner/projectScanner.js

@@ -5,27 +5,61 @@ import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, basename } from 'path';
 import { simpleGit } from 'simple-git';
 import { DEFAULT_SCAN_OPTIONS } from '../types/index.js';
+import { loadExistingContext } from './contextGenerator.js';
 /**
  * Scan a directory for projects and extract information
  */
 export async function scanProjects(options = {}) {
     const opts = { ...DEFAULT_SCAN_OPTIONS, ...options };
     const projects = [];
+    const errors = [];
     console.log(`🔍 Scanning ${opts.rootDir} for projects...`);
+    // Verify root directory exists
+    if (!existsSync(opts.rootDir)) {
+        console.error(`❌ Directory does not exist: ${opts.rootDir}`);
+        console.error(`   Check the path and try again.`);
+        return [];
+    }
     const candidates = findProjectRoots(opts.rootDir, opts.maxDepth, opts.ignore);
-    for (const projectPath of candidates) {
+    if (candidates.length === 0) {
+        console.log(`   No project directories found in ${opts.rootDir}`);
+        console.log(`   Looking for: package.json, Cargo.toml, pyproject.toml, go.mod, or .git`);
+        return [];
+    }
+    // Load excluded projects from existing context
+    const existingContext = loadExistingContext();
+    const excludedProjects = new Set(existingContext?.excludedProjects || []);
+    // Filter out excluded projects
+    const filteredCandidates = candidates.filter(path => {
+        if (excludedProjects.has(path)) {
+            console.log(`   ⊘ Skipping excluded: ${basename(path)}`);
+            return false;
+        }
+        return true;
+    });
+    console.log(`   Found ${filteredCandidates.length} candidate directories\n`);
+    if (excludedProjects.size > 0) {
+        console.log(`   (${excludedProjects.size} excluded)\n`);
+    }
+    for (const projectPath of filteredCandidates) {
         try {
             const info = await analyzeProject(projectPath);
             if (info) {
                 projects.push(info);
-                console.log(`  ✓ Found: ${info.name} (${info.language})`);
+                console.log(`  ✓ ${info.name} (${info.language}) - ${info.techStack.join(', ') || 'no stack detected'}`);
             }
         }
         catch (err) {
-            console.warn(`  ⚠ Failed to analyze: ${projectPath}`);
+            const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+            errors.push({ path: projectPath, error: errorMsg });
+            console.warn(`  ⚠ Failed: ${basename(projectPath)} - ${errorMsg}`);
         }
     }
-    console.log(`\n📊 Found ${projects.length} projects`);
+    console.log(`\n📊 Results:`);
+    console.log(`   ✅ Successfully scanned: ${projects.length}`);
+    if (errors.length > 0) {
+        console.log(`   ⚠️  Failed to scan: ${errors.length}`);
+    }
     return projects;
 }
 /**
@@ -77,23 +111,33 @@ async function analyzeProject(projectPath) {
     const name = detectProjectName(projectPath);
     const description = detectDescription(projectPath);
     const { language, techStack } = detectTechStack(projectPath);
-    // Git info
+    // Git info with timeout to prevent hanging on large/slow repos
     let lastActivity = new Date().toISOString();
     let currentBranch = 'unknown';
     let isDirty = false;
     if (existsSync(join(projectPath, '.git'))) {
         try {
-            const git = simpleGit(projectPath);
-            const log = await git.log({ maxCount: 1 });
-            if (log.latest) {
-                lastActivity = log.latest.date;
-            }
-            const status = await git.status();
-            currentBranch = status.current || 'unknown';
-            isDirty = !status.isClean();
+            // 10 second timeout for git operations
+            const git = simpleGit(projectPath, { timeout: { block: 10000 } });
+            // Wrap in Promise.race for extra safety
+            const gitOps = async () => {
+                const log = await git.log({ maxCount: 1 });
+                if (log.latest) {
+                    lastActivity = log.latest.date;
+                }
+                const status = await git.status();
+                currentBranch = status.current || 'unknown';
+                isDirty = !status.isClean();
+            };
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Git timeout')), 10000));
+            await Promise.race([gitOps(), timeout]);
         }
-        catch {
-            // Git operations failed, use defaults
+        catch (err) {
+            // Git operations failed or timed out, use defaults
+            const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+            if (errorMsg.includes('timeout') || errorMsg.includes('Timeout')) {
+                console.warn(`   ⚠️  Git timeout for ${basename(projectPath)} - using defaults`);
+            }
         }
     }
     // Extract insights from CLAUDE.md if it exists

package/dist/setup/setupWizard.js

@@ -25,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}`);
@@ -164,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();
@@ -178,14 +200,17 @@ 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

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 */

package/dist/types/index.js

@@ -1,10 +1,43 @@
 /**
  * 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,
 };