@contextmirror/claude-memory 0.2.2 → 0.3.1

package/dist/cli.js

@@ -17,6 +17,7 @@ import { generateGlobalContext, writeGlobalContext, getMemoryDir } from './scann
 import { generateBriefing, briefingToClaudeMd } from './briefing/briefingGenerator.js';
 import { runSetupWizard } from './setup/setupWizard.js';
 import { activateLicense, deactivateLicense, getLicenseStatus } from './license/index.js';
+import { detectStaleProjects } from './scanner/stalenessDetector.js';
 const program = new Command();
 program
     .name('claude-memory')
@@ -29,19 +30,83 @@ program
     .argument('[directory]', 'Root directory to scan', `${homedir()}/Project`)
     .option('-d, --depth <number>', 'Max depth to search', '2')
     .option('--generate-claude-md', 'Generate CLAUDE.md for projects without one')
+    .option('-q, --quick', 'Only rescan stale projects (faster)')
+    .option('--check', 'Only check for stale projects, don\'t scan')
     .action(async (directory, options) => {
+    // Check-only mode: just report staleness
+    if (options.check) {
+        const context = loadContext();
+        if (!context) {
+            console.log('No projects scanned yet. Run: claude-memory scan');
+            return;
+        }
+        const report = detectStaleProjects(context);
+        console.log('🧠 Claude Memory - Staleness Check\n');
+        console.log(`Last full scan: ${new Date(context.lastUpdated).toLocaleString()}`);
+        console.log(`Data age: ${report.dataAgeHours} hours\n`);
+        if (report.staleProjects.length === 0) {
+            console.log('✅ All projects are up to date!');
+        }
+        else {
+            console.log(`⚠️  ${report.staleProjects.length} project(s) need updating:\n`);
+            for (const p of report.staleProjects) {
+                const icon = p.reason === 'git_activity' ? '📝' :
+                    p.reason === 'file_changed' ? '📄' : '⏰';
+                console.log(`  ${icon} ${p.name}`);
+                console.log(`     ${p.details}`);
+            }
+            console.log(`\n${report.freshCount} project(s) are fresh.`);
+            console.log('\nRun `claude-memory scan --quick` to refresh only stale projects.');
+        }
+        return;
+    }
     console.log('🧠 Claude Memory Scanner\n');
+    // Quick mode: only scan stale projects
+    let projectsToScan;
+    if (options.quick) {
+        const existingContext = loadContext();
+        if (existingContext) {
+            const report = detectStaleProjects(existingContext);
+            if (report.staleProjects.length === 0) {
+                console.log('✅ All projects are up to date! Nothing to scan.');
+                return;
+            }
+            projectsToScan = report.staleProjects.map(p => p.path);
+            console.log(`🔄 Quick mode: Rescanning ${projectsToScan.length} stale project(s)...\n`);
+        }
+    }
     const projects = await scanProjects({
         rootDir: directory,
         maxDepth: parseInt(options.depth, 10),
         generateClaudeMd: options.generateClaudeMd,
+        onlyPaths: projectsToScan,
     });
     if (projects.length === 0) {
         console.log('\n⚠️  No projects found. Context not updated.');
         console.log('   Check the directory path and try again.');
         return;
     }
-    const context = generateGlobalContext(projects);
+    // For quick mode, merge with existing context
+    let context;
+    if (options.quick && projectsToScan) {
+        const existingContext = loadContext();
+        if (existingContext) {
+            // Replace only the rescanned projects
+            const rescannedPaths = new Set(projects.map(p => p.path));
+            const unchangedProjects = existingContext.projects.filter(p => !rescannedPaths.has(p.path));
+            context = {
+                ...existingContext,
+                lastUpdated: new Date().toISOString(),
+                projects: [...unchangedProjects, ...projects],
+            };
+        }
+        else {
+            context = generateGlobalContext(projects);
+        }
+    }
+    else {
+        context = generateGlobalContext(projects);
+    }
     writeGlobalContext(context);
     console.log('\n✅ Done! Global context updated.');
     console.log('\nTo use with Claude Code, add the MCP server to your config:');

package/dist/mcp/server.js

@@ -15,7 +15,9 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { DEFAULT_MEMORY_CONFIG } from '../types/index.js';
 import { isPro, getProFeatureMessage } from '../license/index.js';
+import { detectStaleProjects, checkCurrentProjectStaleness, formatStalenessForMcp } from '../scanner/stalenessDetector.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
+const CURRENT_VERSION = '0.3.0'; // Update this with each release
 // Tool definitions
 const tools = [
     {
@@ -238,6 +240,13 @@ function handleGetGlobalContext(cwd) {
         lines.push(`**Status:** ${cwdStatus.status}`);
         if (cwdStatus.projectName) {
             lines.push(`**Project:** ${cwdStatus.projectName}`);
+            // Check if current project is stale
+            if (context) {
+                const currentStaleness = checkCurrentProjectStaleness(context, cwd);
+                if (currentStaleness.isStale && currentStaleness.reason) {
+                    lines.push(`**⚠️ Stale:** ${currentStaleness.reason}`);
+                }
+            }
         }
         if (cwdStatus.needsSetup) {
             lines.push(`**Needs Setup:** Yes`);
@@ -267,8 +276,15 @@ function handleGetGlobalContext(cwd) {
     const hoursSinceUpdate = (Date.now() - new Date(context.lastUpdated).getTime()) / (1000 * 60 * 60);
     lines.push('# Your Development Environment');
     lines.push('');
-    lines.push(`Last scanned: ${new Date(context.lastUpdated).toLocaleString()}`);
-    if (hoursSinceUpdate > 24) {
+    lines.push(`Last scanned: ${new Date(context.lastUpdated).toLocaleString()} | claude-memory v${CURRENT_VERSION}`);
+    // Run detailed staleness check
+    const stalenessReport = detectStaleProjects(context);
+    // Add staleness warnings if needed
+    if (stalenessReport.staleProjects.length > 0) {
+        lines.push('');
+        lines.push(formatStalenessForMcp(stalenessReport));
+    }
+    else if (hoursSinceUpdate > 24) {
         lines.push('');
         lines.push(`> ⚠️ **Data may be stale** (${Math.floor(hoursSinceUpdate)} hours old). Run \`claude-memory scan\` to refresh.`);
     }

package/dist/scanner/projectScanner.d.ts

@@ -2,7 +2,15 @@
  * Project Scanner - Discovers and analyzes projects
  */
 import { ProjectInfo, ScanOptions } from '../types/index.js';
+/**
+ * Extended scan options with onlyPaths support
+ */
+interface ExtendedScanOptions extends Partial<ScanOptions> {
+    /** If provided, only scan these specific paths (for quick/incremental scan) */
+    onlyPaths?: string[];
+}
 /**
  * Scan a directory for projects and extract information
  */
-export declare function scanProjects(options?: Partial<ScanOptions>): Promise<ProjectInfo[]>;
+export declare function scanProjects(options?: ExtendedScanOptions): Promise<ProjectInfo[]>;
+export {};

package/dist/scanner/projectScanner.js

@@ -13,6 +13,31 @@ export async function scanProjects(options = {}) {
     const opts = { ...DEFAULT_SCAN_OPTIONS, ...options };
     const projects = [];
     const errors = [];
+    // Quick mode: only scan specific paths
+    if (options.onlyPaths && options.onlyPaths.length > 0) {
+        console.log(`🔍 Quick scan: ${options.onlyPaths.length} project(s)...`);
+        for (const projectPath of options.onlyPaths) {
+            if (!existsSync(projectPath)) {
+                console.warn(`  ⚠ Path not found: ${projectPath}`);
+                continue;
+            }
+            try {
+                const info = await analyzeProject(projectPath);
+                if (info) {
+                    projects.push(info);
+                    console.log(`  ✓ ${info.name} (${info.language})`);
+                }
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+                errors.push({ path: projectPath, error: errorMsg });
+                console.warn(`  ⚠ Failed: ${basename(projectPath)} - ${errorMsg}`);
+            }
+        }
+        console.log(`\n📊 Quick scan results: ${projects.length} project(s) updated`);
+        return projects;
+    }
+    // Full scan mode
     console.log(`🔍 Scanning ${opts.rootDir} for projects...`);
     // Verify root directory exists
     if (!existsSync(opts.rootDir)) {

package/dist/scanner/stalenessDetector.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Staleness detection for claude-memory
+ * Detects which projects need rescanning based on age and git activity
+ */
+import { GlobalContext, ProjectInfo } from '../types/index.js';
+export interface StaleProject {
+    name: string;
+    path: string;
+    daysSinceScanned: number;
+    reason: 'age' | 'git_activity' | 'file_changed' | 'never_scanned';
+    details?: string;
+}
+export interface StalenessReport {
+    /** Overall data age in hours */
+    dataAgeHours: number;
+    /** Projects that need rescanning */
+    staleProjects: StaleProject[];
+    /** Projects that are fresh */
+    freshCount: number;
+    /** Human-readable summary */
+    summary: string;
+    /** Suggested CLI command */
+    suggestion?: string;
+}
+/**
+ * Detect all stale projects in the global context
+ */
+export declare function detectStaleProjects(context: GlobalContext): StalenessReport;
+/**
+ * Get a quick staleness check for the current working directory
+ */
+export declare function checkCurrentProjectStaleness(context: GlobalContext, cwd: string): {
+    isStale: boolean;
+    project?: ProjectInfo;
+    reason?: string;
+};
+/**
+ * Format staleness report for MCP output
+ */
+export declare function formatStalenessForMcp(report: StalenessReport): string;

package/dist/scanner/stalenessDetector.js

@@ -0,0 +1,198 @@
+/**
+ * Staleness detection for claude-memory
+ * Detects which projects need rescanning based on age and git activity
+ */
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+/** Thresholds for staleness (in days) */
+const STALENESS_THRESHOLDS = {
+    WARNING: 3, // Yellow warning
+    STALE: 7, // Orange warning
+    CRITICAL: 14, // Red warning
+};
+/**
+ * Check if a project has new git commits since last scan
+ */
+function hasNewCommits(projectPath, lastScanned) {
+    try {
+        const gitDir = path.join(projectPath, '.git');
+        if (!fs.existsSync(gitDir))
+            return false;
+        // Get latest commit date
+        const result = execSync('git log -1 --format=%cI 2>/dev/null || echo ""', { cwd: projectPath, timeout: 5000, encoding: 'utf-8' }).trim();
+        if (!result)
+            return false;
+        const lastCommitDate = new Date(result);
+        const lastScannedDate = new Date(lastScanned);
+        return lastCommitDate > lastScannedDate;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if key project files have been modified since last scan
+ */
+function hasModifiedFiles(projectPath, lastScanned) {
+    const keyFiles = [
+        'package.json',
+        'CLAUDE.md',
+        'README.md',
+        'Cargo.toml',
+        'pyproject.toml',
+        'go.mod',
+    ];
+    const lastScannedTime = new Date(lastScanned).getTime();
+    for (const file of keyFiles) {
+        try {
+            const filePath = path.join(projectPath, file);
+            if (fs.existsSync(filePath)) {
+                const stat = fs.statSync(filePath);
+                if (stat.mtimeMs > lastScannedTime) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return false;
+}
+/**
+ * Analyze a single project for staleness
+ */
+function analyzeProjectStaleness(project) {
+    const now = new Date();
+    const lastScanned = new Date(project.lastScanned);
+    const daysSinceScanned = Math.floor((now.getTime() - lastScanned.getTime()) / (1000 * 60 * 60 * 24));
+    // Check for git activity first (most reliable signal)
+    if (hasNewCommits(project.path, project.lastScanned)) {
+        return {
+            name: project.name,
+            path: project.path,
+            daysSinceScanned,
+            reason: 'git_activity',
+            details: 'New commits since last scan',
+        };
+    }
+    // Check for modified key files
+    if (hasModifiedFiles(project.path, project.lastScanned)) {
+        return {
+            name: project.name,
+            path: project.path,
+            daysSinceScanned,
+            reason: 'file_changed',
+            details: 'Key files modified since last scan',
+        };
+    }
+    // Check age threshold
+    if (daysSinceScanned >= STALENESS_THRESHOLDS.STALE) {
+        return {
+            name: project.name,
+            path: project.path,
+            daysSinceScanned,
+            reason: 'age',
+            details: `Not scanned in ${daysSinceScanned} days`,
+        };
+    }
+    return null;
+}
+/**
+ * Detect all stale projects in the global context
+ */
+export function detectStaleProjects(context) {
+    const now = new Date();
+    const lastUpdated = new Date(context.lastUpdated);
+    const dataAgeHours = Math.floor((now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60));
+    const staleProjects = [];
+    for (const project of context.projects) {
+        const staleness = analyzeProjectStaleness(project);
+        if (staleness) {
+            staleProjects.push(staleness);
+        }
+    }
+    // Sort by days since scanned (most stale first)
+    staleProjects.sort((a, b) => b.daysSinceScanned - a.daysSinceScanned);
+    const freshCount = context.projects.length - staleProjects.length;
+    // Generate summary
+    let summary;
+    let suggestion;
+    if (staleProjects.length === 0) {
+        summary = `All ${context.projects.length} projects are up to date.`;
+    }
+    else if (staleProjects.length === 1) {
+        const p = staleProjects[0];
+        summary = `1 project needs updating: ${p.name} (${p.details})`;
+        suggestion = `claude-memory scan --quick`;
+    }
+    else {
+        const critical = staleProjects.filter(p => p.daysSinceScanned >= STALENESS_THRESHOLDS.CRITICAL);
+        if (critical.length > 0) {
+            summary = `⚠️ ${staleProjects.length} projects need updating (${critical.length} critical)`;
+        }
+        else {
+            summary = `${staleProjects.length} projects could use a refresh`;
+        }
+        suggestion = `claude-memory scan --quick`;
+    }
+    return {
+        dataAgeHours,
+        staleProjects,
+        freshCount,
+        summary,
+        suggestion,
+    };
+}
+/**
+ * Get a quick staleness check for the current working directory
+ */
+export function checkCurrentProjectStaleness(context, cwd) {
+    // Find the project that matches the cwd
+    const project = context.projects.find(p => cwd.startsWith(p.path) || p.path.startsWith(cwd));
+    if (!project) {
+        return { isStale: false };
+    }
+    const staleness = analyzeProjectStaleness(project);
+    if (staleness) {
+        return {
+            isStale: true,
+            project,
+            reason: staleness.details,
+        };
+    }
+    return { isStale: false, project };
+}
+/**
+ * Format staleness report for MCP output
+ */
+export function formatStalenessForMcp(report) {
+    const lines = [];
+    if (report.staleProjects.length === 0) {
+        return ''; // Don't add noise if everything is fresh
+    }
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push('### 🔄 Data Freshness');
+    lines.push('');
+    lines.push(report.summary);
+    if (report.staleProjects.length > 0 && report.staleProjects.length <= 5) {
+        lines.push('');
+        for (const p of report.staleProjects) {
+            const icon = p.reason === 'git_activity' ? '📝' :
+                p.reason === 'file_changed' ? '📄' : '⏰';
+            lines.push(`- ${icon} **${p.name}**: ${p.details}`);
+        }
+    }
+    else if (report.staleProjects.length > 5) {
+        lines.push('');
+        lines.push(`Stale projects: ${report.staleProjects.map(p => p.name).join(', ')}`);
+    }
+    if (report.suggestion) {
+        lines.push('');
+        lines.push(`> Run \`${report.suggestion}\` to refresh`);
+    }
+    return lines.join('\n');
+}

package/package.json

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