@contextmirror/claude-memory 0.1.0 → 0.2.0

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/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,196 @@
+/**
+ * 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 } 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';
+const CLAUDE_JSON_PATH = join(homedir(), '.claude.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('   }');
+        }
+    }
+    // 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;
+}
+/**
+ * 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';
+}