@contextmirror/claude-memory 0.1.0 → 0.2.1

package/dist/cli.js

@@ -9,11 +9,13 @@
  *   claude-memory mcp                 Start MCP server
  */
 import { Command } from 'commander';
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { scanProjects } from './scanner/projectScanner.js';
 import { generateGlobalContext, writeGlobalContext, getMemoryDir } from './scanner/contextGenerator.js';
+import { generateBriefing, briefingToClaudeMd } from './briefing/briefingGenerator.js';
+import { runSetupWizard } from './setup/setupWizard.js';
 const program = new Command();
 program
     .name('claude-memory')
@@ -87,34 +89,85 @@ program
     console.log(`  CLAUDE.md: ${project.hasFiles.claudeMd ? '✓' : '✗'}`);
     console.log(`  README.md: ${project.hasFiles.readme ? '✓' : '✗'}`);
 });
-// Init command - shows how to generate CLAUDE.md
+// Briefing command - deep project analysis and CLAUDE.md generation
+program
+    .command('briefing')
+    .description('Generate a detailed CLAUDE.md briefing for a project')
+    .argument('[directory]', 'Project directory', process.cwd())
+    .option('-o, --output <file>', 'Output file (default: CLAUDE.md in project)')
+    .option('--stdout', 'Print to stdout instead of file')
+    .option('--force', 'Overwrite existing CLAUDE.md')
+    .action(async (directory, options) => {
+    const projectPath = directory.startsWith('/') ? directory : join(process.cwd(), directory);
+    console.log('🧠 Claude Memory - Project Briefing\n');
+    console.log(`📁 Analyzing: ${projectPath}\n`);
+    // Check if project exists
+    if (!existsSync(projectPath)) {
+        console.log(`❌ Directory not found: ${projectPath}`);
+        return;
+    }
+    // Check for existing CLAUDE.md
+    const claudeMdPath = options.output || join(projectPath, 'CLAUDE.md');
+    if (existsSync(claudeMdPath) && !options.force && !options.stdout) {
+        console.log(`⚠️  CLAUDE.md already exists at ${claudeMdPath}`);
+        console.log('   Use --force to overwrite, or --stdout to preview');
+        return;
+    }
+    try {
+        console.log('📊 Scanning project structure...');
+        const briefing = await generateBriefing({ projectPath });
+        console.log(`   Name: ${briefing.name}`);
+        console.log(`   Language: ${briefing.language}`);
+        console.log(`   Stack: ${briefing.techStack.join(', ')}`);
+        console.log(`   Entry points: ${briefing.entryPoints.length}`);
+        console.log(`   Patterns detected: ${briefing.patterns.length}`);
+        console.log(`   Dependencies: ${briefing.dependencies.length}`);
+        console.log('\n📝 Generating CLAUDE.md...');
+        const markdown = briefingToClaudeMd(briefing);
+        if (options.stdout) {
+            console.log('\n' + '='.repeat(60) + '\n');
+            console.log(markdown);
+        }
+        else {
+            writeFileSync(claudeMdPath, markdown, 'utf-8');
+            console.log(`\n✅ Written to: ${claudeMdPath}`);
+        }
+        console.log('\n💡 Pro tip: Run `claude-memory scan` to update your global context');
+    }
+    catch (err) {
+        console.error('❌ Failed to generate briefing:', err);
+    }
+});
+// Init command - alias for briefing (backwards compatibility)
 program
     .command('init')
-    .description('Generate CLAUDE.md for the current project')
+    .description('Generate CLAUDE.md for the current project (alias for briefing)')
     .action(async () => {
+    // Just run the briefing command
     const projectPath = process.cwd();
-    console.log('🧠 Claude Memory - CLAUDE.md Generator\n');
-    console.log(`📁 Project: ${projectPath}\n`);
-    // Quick analysis of current project
-    const projects = await scanProjects({
-        rootDir: projectPath,
-        maxDepth: 0,
-    });
-    if (projects.length === 0) {
-        console.log('❌ No project detected in current directory');
-        console.log('   (Looking for package.json, Cargo.toml, pyproject.toml, or .git)');
+    console.log('🧠 Claude Memory - Project Briefing\n');
+    console.log(`📁 Analyzing: ${projectPath}\n`);
+    const claudeMdPath = join(projectPath, 'CLAUDE.md');
+    if (existsSync(claudeMdPath)) {
+        console.log(`⚠️  CLAUDE.md already exists`);
+        console.log('   Use `claude-memory briefing --force` to overwrite');
+        console.log('   Use `claude-memory briefing --stdout` to preview');
         return;
     }
-    const project = projects[0];
-    console.log(`✅ Found project: ${project.name}`);
-    console.log(`   Language: ${project.language}`);
-    console.log(`   Stack: ${project.techStack.join(', ')}`);
-    console.log(`   Has CLAUDE.md: ${project.hasFiles.claudeMd ? 'Yes' : 'No'}`);
-    console.log('\n📝 To generate a CLAUDE.md file:');
-    console.log('   1. Open this project in Claude Code');
-    console.log('   2. Ask Claude: "Generate a CLAUDE.md for this project"');
-    console.log('   3. Claude will use the MCP tools to analyze and write it');
-    console.log('\n💡 This uses your existing Claude session - no extra API costs!');
+    try {
+        console.log('📊 Scanning project structure...');
+        const briefing = await generateBriefing({ projectPath });
+        console.log(`   Name: ${briefing.name}`);
+        console.log(`   Language: ${briefing.language}`);
+        console.log(`   Stack: ${briefing.techStack.join(', ')}`);
+        console.log('\n📝 Generating CLAUDE.md...');
+        const markdown = briefingToClaudeMd(briefing);
+        writeFileSync(claudeMdPath, markdown, 'utf-8');
+        console.log(`\n✅ Written to: ${claudeMdPath}`);
+    }
+    catch (err) {
+        console.error('❌ Failed to generate briefing:', err);
+    }
 });
 // MCP command - start the MCP server
 program
@@ -124,6 +177,22 @@ program
     // Import and run the MCP server
     await import('./mcp/server.js');
 });
+// Setup command - interactive setup wizard
+program
+    .command('setup')
+    .description('Run the interactive setup wizard')
+    .option('-d, --directory <dir>', 'Projects directory to scan')
+    .option('--skip-mcp', 'Skip MCP configuration')
+    .option('--skip-briefing', 'Skip CLAUDE.md generation')
+    .option('--non-interactive', 'Run without prompts (useful for CI)')
+    .action(async (options) => {
+    await runSetupWizard({
+        projectsDir: options.directory,
+        skipMcp: options.skipMcp,
+        skipBriefing: options.skipBriefing,
+        interactive: !options.nonInteractive,
+    });
+});
 function loadContext() {
     const contextPath = join(getMemoryDir(), 'context.json');
     if (!existsSync(contextPath)) {

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.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Setup Wizard - Runs after npm install to configure claude-memory
+ *
+ * Features:
+ * 1. Scans for projects
+ * 2. Offers to generate CLAUDE.md for projects without one
+ * 3. Auto-configures MCP in ~/.claude.json
+ */
+interface SetupOptions {
+    projectsDir?: string;
+    skipMcp?: boolean;
+    skipBriefing?: boolean;
+    interactive?: boolean;
+}
+/**
+ * Run the setup wizard
+ */
+export declare function runSetupWizard(options?: SetupOptions): Promise<void>;
+/**
+ * Check if this is running as a postinstall script
+ */
+export declare function isPostInstall(): boolean;
+export {};

package/dist/setup/setupWizard.js

@@ -0,0 +1,248 @@
+/**
+ * Setup Wizard - Runs after npm install to configure claude-memory
+ *
+ * Features:
+ * 1. Scans for projects
+ * 2. Offers to generate CLAUDE.md for projects without one
+ * 3. Auto-configures MCP in ~/.claude.json
+ */
+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'],
+};
+/**
+ * Run the setup wizard
+ */
+export async function runSetupWizard(options = {}) {
+    const { projectsDir = guessProjectsDir(), skipMcp = false, skipBriefing = false, interactive = true, } = options;
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║         🧠 Claude Memory - Setup Wizard                  ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    // Step 1: Find projects
+    console.log('📍 Step 1: Scanning for projects\n');
+    console.log(`   Looking in: ${projectsDir}`);
+    const projects = await scanProjects({
+        rootDir: projectsDir,
+        maxDepth: 2,
+    });
+    if (projects.length === 0) {
+        console.log('\n   ⚠️  No projects found.');
+        console.log(`   Make sure you have projects in ${projectsDir}`);
+        console.log('   Or run: claude-memory scan /path/to/your/projects');
+        return;
+    }
+    console.log(`\n   ✅ Found ${projects.length} project(s):\n`);
+    const projectsWithoutClaudeMd = projects.filter(p => !p.hasFiles.claudeMd);
+    const projectsWithClaudeMd = projects.filter(p => p.hasFiles.claudeMd);
+    for (const p of projectsWithClaudeMd) {
+        console.log(`   ✓ ${p.name} (${p.techStack.join(', ')}) - Has CLAUDE.md`);
+    }
+    for (const p of projectsWithoutClaudeMd) {
+        console.log(`   ○ ${p.name} (${p.techStack.join(', ')}) - No CLAUDE.md`);
+    }
+    // Step 2: Generate CLAUDE.md for projects without one
+    if (!skipBriefing && projectsWithoutClaudeMd.length > 0) {
+        console.log('\n📍 Step 2: Generate CLAUDE.md files\n');
+        if (interactive) {
+            const answer = await ask(`   Generate CLAUDE.md for ${projectsWithoutClaudeMd.length} project(s)? (Y/n) `);
+            if (answer.toLowerCase() !== 'n') {
+                for (const project of projectsWithoutClaudeMd) {
+                    console.log(`\n   📝 Generating for ${project.name}...`);
+                    try {
+                        const briefing = await generateBriefing({ projectPath: project.path });
+                        const markdown = briefingToClaudeMd(briefing);
+                        const outputPath = join(project.path, 'CLAUDE.md');
+                        writeFileSync(outputPath, markdown, 'utf-8');
+                        console.log(`   ✅ Created: ${outputPath}`);
+                    }
+                    catch (err) {
+                        console.log(`   ❌ Failed: ${err}`);
+                    }
+                }
+            }
+        }
+        else {
+            console.log(`   Skipping CLAUDE.md generation (non-interactive mode)`);
+            console.log(`   Run: claude-memory briefing /path/to/project`);
+        }
+    }
+    else if (projectsWithoutClaudeMd.length === 0) {
+        console.log('\n📍 Step 2: Generate CLAUDE.md files\n');
+        console.log('   ✅ All projects already have CLAUDE.md');
+    }
+    // Step 3: Save global context
+    console.log('\n📍 Step 3: Saving global context\n');
+    const context = generateGlobalContext(projects);
+    writeGlobalContext(context);
+    console.log('   ✅ Context saved to ~/.claude-memory/');
+    // Step 4: Configure MCP
+    if (!skipMcp) {
+        console.log('\n📍 Step 4: Configuring Claude Code integration\n');
+        const mcpConfigured = configureMcp();
+        if (mcpConfigured) {
+            console.log('   ✅ MCP server added to ~/.claude.json');
+        }
+        else {
+            console.log('   ⚠️  Could not auto-configure MCP');
+            console.log('   Add this to your Claude Code settings manually:');
+            console.log('');
+            console.log('   "mcpServers": {');
+            console.log('     "claude-memory": {');
+            console.log('       "command": "claude-memory",');
+            console.log('       "args": ["mcp"]');
+            console.log('     }');
+            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!                    ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    console.log('   Next steps:');
+    console.log('   1. Restart Claude Code to load the MCP server');
+    console.log('   2. Ask Claude: "What projects do I have?"');
+    console.log('   3. Claude now knows about all your projects!');
+    console.log('');
+    console.log('   Commands:');
+    console.log('   • claude-memory scan [dir]   - Re-scan projects');
+    console.log('   • claude-memory list         - Show known projects');
+    console.log('   • claude-memory briefing     - Generate CLAUDE.md');
+    console.log('');
+}
+/**
+ * Guess the user's projects directory
+ */
+function guessProjectsDir() {
+    const home = homedir();
+    const candidates = [
+        join(home, 'Projects'),
+        join(home, 'Project'),
+        join(home, 'projects'),
+        join(home, 'Code'),
+        join(home, 'code'),
+        join(home, 'Development'),
+        join(home, 'dev'),
+        join(home, 'src'),
+        join(home, 'repos'),
+        join(home, 'git'),
+    ];
+    for (const dir of candidates) {
+        if (existsSync(dir)) {
+            return dir;
+        }
+    }
+    // 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
+ */
+function configureMcp() {
+    try {
+        let config = {};
+        // Read existing config
+        if (existsSync(CLAUDE_JSON_PATH)) {
+            const content = readFileSync(CLAUDE_JSON_PATH, 'utf-8');
+            config = JSON.parse(content);
+        }
+        // Check if already configured
+        const mcpServers = config.mcpServers || {};
+        if (mcpServers['claude-memory']) {
+            console.log('   ℹ️  MCP server already configured');
+            return true;
+        }
+        // Add our config
+        mcpServers['claude-memory'] = MCP_SERVER_CONFIG;
+        config.mcpServers = mcpServers;
+        // Write back
+        writeFileSync(CLAUDE_JSON_PATH, JSON.stringify(config, null, 2), 'utf-8');
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * Simple async prompt
+ */
+function ask(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Check if this is running as a postinstall script
+ */
+export function isPostInstall() {
+    return process.env.npm_lifecycle_event === 'postinstall';
+}

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(),
+};