namnam-skills 1.0.0 → 1.0.2

package/src/cli.js

@@ -7,6 +7,37 @@ import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import inquirer from 'inquirer';
+import {
+  initConversations,
+  saveConversation,
+  getConversation,
+  listConversations,
+  deleteConversation,
+  exportConversation,
+  getConversationContext,
+  updateConversation,
+  // Auto-memory functions
+  initAutoMemory,
+  loadAutoMemoryIndex,
+  autoSaveMemory,
+  getRelevantMemories,
+  generateAutoMemoryContext,
+  startSession,
+  getCurrentSession,
+  updateSession,
+  endSession,
+  remember,
+  recall
+} from './conversation.js';
+import {
+  buildIndex,
+  hasIndex,
+  getIndexMeta,
+  getIndexStats,
+  checkIndexChanges,
+  searchSymbols,
+  generateAIContext
+} from './indexer.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -457,4 +488,985 @@ async function generatePlatformFiles(cwd, templatesDir, force = false) {
   }
 }
 
+// ========================================
+// CONVERSATION COMMANDS
+// ========================================
+
+const conversation = program
+  .command('conversation')
+  .alias('conv')
+  .description('Manage conversation context (@conversation feature)');
+
+conversation
+  .command('init')
+  .description('Initialize conversation storage in current project')
+  .action(async () => {
+    console.log(banner);
+    const spinner = ora('Initializing conversation storage...').start();
+
+    try {
+      const cwd = process.cwd();
+      await initConversations(cwd);
+      spinner.succeed(chalk.green('Conversation storage initialized!'));
+      console.log(chalk.gray('\nLocation: .claude/conversations/'));
+      console.log(chalk.cyan('\nUsage:'));
+      console.log(chalk.white('  namnam conv save              - Save current conversation'));
+      console.log(chalk.white('  namnam conv list              - List saved conversations'));
+      console.log(chalk.white('  namnam conv show <id>         - View a conversation'));
+      console.log(chalk.white('  @conversation:<id>            - Reference in prompts'));
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to initialize'));
+      console.error(error.message);
+    }
+  });
+
+conversation
+  .command('save')
+  .description('Save a conversation with context')
+  .option('-t, --title <title>', 'Conversation title')
+  .option('-s, --summary <summary>', 'Short summary')
+  .option('-g, --tags <tags>', 'Comma-separated tags')
+  .action(async (options) => {
+    console.log(banner);
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'title',
+        message: 'Conversation title:',
+        default: options.title || `Conversation ${new Date().toLocaleDateString()}`,
+        when: !options.title
+      },
+      {
+        type: 'input',
+        name: 'summary',
+        message: 'Short summary (1-2 sentences):',
+        when: !options.summary
+      },
+      {
+        type: 'editor',
+        name: 'context',
+        message: 'Enter the conversation context (opens editor):'
+      },
+      {
+        type: 'input',
+        name: 'tags',
+        message: 'Tags (comma-separated):',
+        when: !options.tags
+      }
+    ]);
+
+    const spinner = ora('Saving conversation...').start();
+
+    try {
+      const result = await saveConversation({
+        title: options.title || answers.title,
+        summary: options.summary || answers.summary || '',
+        context: answers.context || '',
+        tags: (options.tags || answers.tags || '').split(',').map(t => t.trim()).filter(Boolean)
+      });
+
+      spinner.succeed(chalk.green('Conversation saved!'));
+      console.log(chalk.cyan(`\nID: ${chalk.white(result.shortId)}`));
+      console.log(chalk.cyan(`Full ID: ${chalk.gray(result.id)}`));
+      console.log(chalk.yellow(`\nReference with: @conversation:${result.shortId}`));
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to save conversation'));
+      console.error(error.message);
+    }
+  });
+
+conversation
+  .command('list')
+  .description('List all saved conversations')
+  .option('-l, --limit <number>', 'Number of conversations to show', '20')
+  .option('-t, --tag <tag>', 'Filter by tag')
+  .option('-s, --search <term>', 'Search in title/summary')
+  .action(async (options) => {
+    console.log(banner);
+
+    try {
+      const conversations = await listConversations({
+        limit: parseInt(options.limit),
+        tag: options.tag,
+        search: options.search
+      });
+
+      if (conversations.length === 0) {
+        console.log(chalk.yellow('\n📭 No conversations found.'));
+        console.log(chalk.gray('Use `namnam conv save` to save your first conversation.'));
+        return;
+      }
+
+      console.log(chalk.cyan(`\n📚 Saved Conversations (${conversations.length}):\n`));
+
+      for (const conv of conversations) {
+        const date = new Date(conv.createdAt).toLocaleDateString();
+        const tags = conv.tags?.length ? chalk.gray(` [${conv.tags.join(', ')}]`) : '';
+
+        console.log(chalk.yellow(`  ${conv.shortId}`) + chalk.white(` - ${conv.title}`) + tags);
+        if (conv.summary) {
+          console.log(chalk.gray(`         ${conv.summary.substring(0, 60)}${conv.summary.length > 60 ? '...' : ''}`));
+        }
+        console.log(chalk.gray(`         ${date}`));
+        console.log();
+      }
+
+      console.log(chalk.cyan('Usage:'));
+      console.log(chalk.white('  namnam conv show <id>         - View full context'));
+      console.log(chalk.white('  @conversation:<id>            - Reference in AI prompts'));
+    } catch (error) {
+      console.error(chalk.red('Failed to list conversations:'), error.message);
+    }
+  });
+
+conversation
+  .command('show <id>')
+  .description('Show conversation details and context')
+  .option('-f, --full', 'Show full log if available')
+  .action(async (id, options) => {
+    console.log(banner);
+
+    try {
+      const conv = await getConversation(id);
+
+      if (!conv) {
+        console.log(chalk.red(`\n❌ Conversation not found: ${id}`));
+        return;
+      }
+
+      console.log(chalk.cyan(`\n📝 ${conv.title}\n`));
+      console.log(chalk.gray('─'.repeat(50)));
+      console.log(chalk.white('ID:       ') + chalk.yellow(conv.shortId));
+      console.log(chalk.white('Full ID:  ') + chalk.gray(conv.id));
+      console.log(chalk.white('Created:  ') + chalk.gray(new Date(conv.createdAt).toLocaleString()));
+      console.log(chalk.white('Updated:  ') + chalk.gray(new Date(conv.updatedAt).toLocaleString()));
+      if (conv.tags?.length) {
+        console.log(chalk.white('Tags:     ') + chalk.cyan(conv.tags.join(', ')));
+      }
+      console.log(chalk.gray('─'.repeat(50)));
+
+      if (conv.summary) {
+        console.log(chalk.cyan('\n📋 Summary:\n'));
+        console.log(conv.summary);
+      }
+
+      if (conv.context) {
+        console.log(chalk.cyan('\n📄 Context:\n'));
+        console.log(conv.context);
+      }
+
+      if (options.full && conv.fullLog) {
+        console.log(chalk.cyan('\n📜 Full Log:\n'));
+        console.log(conv.fullLog);
+      }
+
+      console.log(chalk.gray('\n─'.repeat(50)));
+      console.log(chalk.yellow(`\nReference with: @conversation:${conv.shortId}`));
+    } catch (error) {
+      console.error(chalk.red('Failed to show conversation:'), error.message);
+    }
+  });
+
+conversation
+  .command('context <id>')
+  .description('Output conversation context for AI consumption')
+  .action(async (id) => {
+    try {
+      const context = await getConversationContext(id);
+
+      if (!context) {
+        console.error(`Conversation not found: ${id}`);
+        process.exit(1);
+      }
+
+      // Output raw context (for piping to other tools)
+      console.log(context);
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+conversation
+  .command('delete <id>')
+  .description('Delete a saved conversation')
+  .option('-f, --force', 'Skip confirmation')
+  .action(async (id, options) => {
+    console.log(banner);
+
+    try {
+      const conv = await getConversation(id);
+
+      if (!conv) {
+        console.log(chalk.red(`\n❌ Conversation not found: ${id}`));
+        return;
+      }
+
+      if (!options.force) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Delete "${conv.title}" (${conv.shortId})?`,
+            default: false
+          }
+        ]);
+
+        if (!answers.confirm) {
+          console.log(chalk.gray('Cancelled.'));
+          return;
+        }
+      }
+
+      const spinner = ora('Deleting conversation...').start();
+      await deleteConversation(id);
+      spinner.succeed(chalk.green(`Deleted: ${conv.title}`));
+    } catch (error) {
+      console.error(chalk.red('Failed to delete conversation:'), error.message);
+    }
+  });
+
+conversation
+  .command('update <id>')
+  .description('Update conversation metadata or context')
+  .option('-t, --title <title>', 'Update title')
+  .option('-s, --summary <summary>', 'Update summary')
+  .option('-g, --tags <tags>', 'Update tags (comma-separated)')
+  .option('-c, --context', 'Update context via editor')
+  .action(async (id, options) => {
+    console.log(banner);
+
+    try {
+      const conv = await getConversation(id);
+
+      if (!conv) {
+        console.log(chalk.red(`\n❌ Conversation not found: ${id}`));
+        return;
+      }
+
+      const updates = {};
+
+      if (options.title) updates.title = options.title;
+      if (options.summary) updates.summary = options.summary;
+      if (options.tags) {
+        updates.tags = options.tags.split(',').map(t => t.trim()).filter(Boolean);
+      }
+
+      // If context update requested, open editor
+      if (options.context) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'editor',
+            name: 'context',
+            message: 'Update context:',
+            default: conv.context || ''
+          }
+        ]);
+        if (answers.context !== undefined) {
+          updates.context = answers.context;
+        }
+      }
+
+      if (Object.keys(updates).length === 0) {
+        console.log(chalk.yellow('\n⚠️  No updates provided.'));
+        console.log(chalk.gray('Use -t, -s, -g, or -c flags to specify what to update.'));
+        return;
+      }
+
+      const spinner = ora('Updating conversation...').start();
+      await updateConversation(id, updates);
+      spinner.succeed(chalk.green('Conversation updated!'));
+
+      console.log(chalk.cyan(`\nUpdated: ${options.title || conv.title}`));
+    } catch (error) {
+      console.error(chalk.red('Failed to update conversation:'), error.message);
+    }
+  });
+
+conversation
+  .command('export <id> [output]')
+  .description('Export conversation to markdown file')
+  .action(async (id, output) => {
+    console.log(banner);
+
+    try {
+      const conv = await getConversation(id);
+
+      if (!conv) {
+        console.log(chalk.red(`\n❌ Conversation not found: ${id}`));
+        return;
+      }
+
+      const outputPath = output || `conversation-${conv.shortId}.md`;
+      const spinner = ora('Exporting conversation...').start();
+
+      await exportConversation(id, outputPath);
+      spinner.succeed(chalk.green(`Exported to: ${outputPath}`));
+    } catch (error) {
+      console.error(chalk.red('Failed to export conversation:'), error.message);
+    }
+  });
+
+// ========================================
+// INDEX COMMANDS
+// ========================================
+
+const index = program
+  .command('index')
+  .alias('idx')
+  .description('Codebase indexing for deep code understanding');
+
+index
+  .command('build')
+  .description('Build or rebuild the codebase index')
+  .option('-f, --force', 'Force rebuild even if index exists')
+  .option('--json', 'Output results as JSON (for programmatic use)')
+  .action(async (options) => {
+    const cwd = process.cwd();
+
+    // JSON mode - no banner or colors
+    if (options.json) {
+      try {
+        const meta = await buildIndex(cwd);
+        console.log(JSON.stringify({
+          success: true,
+          stats: {
+            files: meta.stats.totalFiles,
+            lines: meta.stats.totalLines,
+            functions: meta.stats.totalFunctions,
+            classes: meta.stats.totalClasses
+          },
+          patterns: meta.patterns
+        }));
+      } catch (error) {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message
+        }));
+        process.exit(1);
+      }
+      return;
+    }
+
+    console.log(banner);
+
+    // Check if index exists
+    if (!options.force && await hasIndex(cwd)) {
+      const changes = await checkIndexChanges(cwd);
+      if (!changes.hasChanges) {
+        console.log(chalk.green('\n✅ Index is up to date!'));
+        const stats = await getIndexStats(cwd);
+        console.log(chalk.gray(`   Last updated: ${new Date(stats.lastUpdated).toLocaleString()}`));
+        console.log(chalk.gray(`   Files: ${stats.totalFiles} | Functions: ${stats.totalFunctions} | Classes: ${stats.totalClasses}`));
+        console.log(chalk.cyan('\nUse --force to rebuild anyway.'));
+        return;
+      } else {
+        console.log(chalk.yellow('\n📝 Changes detected since last index:'));
+        if (changes.newFiles?.length) console.log(chalk.green(`   + ${changes.newFiles.length} new files`));
+        if (changes.modifiedFiles?.length) console.log(chalk.yellow(`   ~ ${changes.modifiedFiles.length} modified files`));
+        if (changes.deletedFiles?.length) console.log(chalk.red(`   - ${changes.deletedFiles.length} deleted files`));
+        console.log();
+      }
+    }
+
+    const spinner = ora('Building codebase index...').start();
+
+    try {
+      const meta = await buildIndex(cwd, {
+        onProgress: (progress) => {
+          if (progress.phase === 'scanning') {
+            spinner.text = progress.message;
+          } else if (progress.phase === 'indexing') {
+            spinner.text = `Indexing: ${progress.current}/${progress.total} files`;
+          } else if (progress.phase === 'analyzing') {
+            spinner.text = 'Analyzing patterns...';
+          } else if (progress.phase === 'saving') {
+            spinner.text = 'Saving index...';
+          }
+        }
+      });
+
+      spinner.succeed(chalk.green('Index built successfully!'));
+
+      console.log(chalk.cyan('\n📊 Index Statistics:'));
+      console.log(chalk.white(`   Files indexed: ${meta.stats.totalFiles}`));
+      console.log(chalk.white(`   Total lines: ${meta.stats.totalLines.toLocaleString()}`));
+      console.log(chalk.white(`   Functions: ${meta.stats.totalFunctions}`));
+      console.log(chalk.white(`   Classes: ${meta.stats.totalClasses}`));
+
+      if (meta.patterns) {
+        console.log(chalk.cyan('\n🔍 Detected Patterns:'));
+        if (meta.patterns.framework) console.log(chalk.white(`   Framework: ${meta.patterns.framework}`));
+        console.log(chalk.white(`   Language: ${meta.patterns.language}`));
+        if (meta.patterns.styling) console.log(chalk.white(`   Styling: ${meta.patterns.styling}`));
+        if (meta.patterns.testing) console.log(chalk.white(`   Testing: ${meta.patterns.testing}`));
+        if (meta.patterns.packageManager) console.log(chalk.white(`   Package Manager: ${meta.patterns.packageManager}`));
+      }
+
+      console.log(chalk.gray('\n📁 Index location: .claude/index/'));
+      console.log(chalk.yellow('\n💡 The index will be auto-loaded when using /namnam'));
+
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to build index'));
+      console.error(error.message);
+    }
+  });
+
+index
+  .command('status')
+  .description('Show index status and statistics')
+  .option('--json', 'Output results as JSON (for programmatic use)')
+  .action(async (options) => {
+    const cwd = process.cwd();
+
+    // JSON mode
+    if (options.json) {
+      if (!(await hasIndex(cwd))) {
+        console.log(JSON.stringify({ exists: false }));
+        return;
+      }
+      const stats = await getIndexStats(cwd);
+      const changes = await checkIndexChanges(cwd);
+      console.log(JSON.stringify({
+        exists: true,
+        totalFiles: stats.totalFiles,
+        totalLines: stats.totalLines,
+        totalFunctions: stats.totalFunctions,
+        totalClasses: stats.totalClasses,
+        lastUpdated: stats.lastUpdated,
+        patterns: stats.patterns,
+        hasChanges: changes.hasChanges,
+        changes: changes.hasChanges ? {
+          newFiles: changes.newFiles?.length || 0,
+          modifiedFiles: changes.modifiedFiles?.length || 0,
+          deletedFiles: changes.deletedFiles?.length || 0
+        } : null
+      }));
+      return;
+    }
+
+    console.log(banner);
+
+    if (!(await hasIndex(cwd))) {
+      console.log(chalk.yellow('\n⚠️  No index found.'));
+      console.log(chalk.gray('Run `namnam index build` to create one.'));
+      return;
+    }
+
+    const stats = await getIndexStats(cwd);
+    const changes = await checkIndexChanges(cwd);
+
+    console.log(chalk.cyan('\n📊 Codebase Index Status\n'));
+    console.log(chalk.gray('─'.repeat(50)));
+
+    // Stats
+    console.log(chalk.white('Files indexed:    ') + chalk.yellow(stats.totalFiles));
+    console.log(chalk.white('Total lines:      ') + chalk.yellow(stats.totalLines.toLocaleString()));
+    console.log(chalk.white('Functions:        ') + chalk.yellow(stats.totalFunctions));
+    console.log(chalk.white('Classes:          ') + chalk.yellow(stats.totalClasses));
+    console.log(chalk.white('Last updated:     ') + chalk.gray(new Date(stats.lastUpdated).toLocaleString()));
+
+    // Patterns
+    if (stats.patterns) {
+      console.log(chalk.gray('\n─'.repeat(50)));
+      console.log(chalk.cyan('\nDetected Patterns:'));
+      if (stats.patterns.framework) console.log(chalk.white(`  Framework:       ${stats.patterns.framework}`));
+      console.log(chalk.white(`  Language:        ${stats.patterns.language}`));
+      if (stats.patterns.styling) console.log(chalk.white(`  Styling:         ${stats.patterns.styling}`));
+      if (stats.patterns.testing) console.log(chalk.white(`  Testing:         ${stats.patterns.testing}`));
+      if (stats.patterns.packageManager) console.log(chalk.white(`  Package Manager: ${stats.patterns.packageManager}`));
+    }
+
+    // Changes
+    console.log(chalk.gray('\n─'.repeat(50)));
+    if (changes.hasChanges) {
+      console.log(chalk.yellow('\n⚠️  Changes detected since last index:'));
+      if (changes.newFiles?.length) console.log(chalk.green(`   + ${changes.newFiles.length} new files`));
+      if (changes.modifiedFiles?.length) console.log(chalk.yellow(`   ~ ${changes.modifiedFiles.length} modified files`));
+      if (changes.deletedFiles?.length) console.log(chalk.red(`   - ${changes.deletedFiles.length} deleted files`));
+      console.log(chalk.cyan('\nRun `namnam index build` to update.'));
+    } else {
+      console.log(chalk.green('\n✅ Index is up to date!'));
+    }
+  });
+
+index
+  .command('search <query>')
+  .description('Search symbols (functions, classes, types) in the codebase')
+  .option('-l, --limit <n>', 'Limit results', '20')
+  .action(async (query, options) => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+
+    if (!(await hasIndex(cwd))) {
+      console.log(chalk.yellow('\n⚠️  No index found. Building...'));
+      await buildIndex(cwd);
+    }
+
+    const results = await searchSymbols(query, cwd);
+    const limit = parseInt(options.limit);
+
+    if (results.length === 0) {
+      console.log(chalk.yellow(`\n🔍 No results found for "${query}"`));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n🔍 Search results for "${query}" (${results.length} found):\n`));
+
+    const limited = results.slice(0, limit);
+    for (const result of limited) {
+      const icon = result.type === 'function' ? '𝑓' : result.type === 'class' ? '◇' : '𝑇';
+      const exported = result.exported ? chalk.green(' [exported]') : '';
+      console.log(
+        chalk.yellow(`  ${icon} `) +
+        chalk.white(result.name) +
+        chalk.gray(` - ${result.file}:${result.line}`) +
+        exported
+      );
+    }
+
+    if (results.length > limit) {
+      console.log(chalk.gray(`\n   ... and ${results.length - limit} more results`));
+    }
+  });
+
+index
+  .command('context')
+  .description('Generate AI context from the index')
+  .option('-q, --query <query>', 'Search query to find relevant files')
+  .option('-f, --files <files>', 'Comma-separated list of files to include')
+  .option('-o, --output <file>', 'Output to file instead of stdout')
+  .action(async (options) => {
+    const cwd = process.cwd();
+
+    if (!(await hasIndex(cwd))) {
+      console.error(chalk.red('No index found. Run `namnam index build` first.'));
+      process.exit(1);
+    }
+
+    const result = await generateAIContext({
+      query: options.query,
+      files: options.files ? options.files.split(',').map(f => f.trim()) : []
+    }, cwd);
+
+    if (result.error) {
+      console.error(chalk.red(result.error));
+      process.exit(1);
+    }
+
+    if (options.output) {
+      await fs.writeFile(options.output, result.context);
+      console.log(chalk.green(`Context written to: ${options.output}`));
+      console.log(chalk.gray(`Estimated tokens: ${result.tokenEstimate}`));
+    } else {
+      console.log(result.context);
+    }
+  });
+
+index
+  .command('watch')
+  .description('Watch for file changes and auto-update index (live indexing)')
+  .option('-v, --verbose', 'Show detailed logs')
+  .option('--no-auto-rebuild', 'Only notify on changes, do not auto-rebuild')
+  .action(async (options) => {
+    console.log(banner);
+    console.log(chalk.cyan('\n👁️  Live Index Watcher\n'));
+
+    const cwd = process.cwd();
+
+    // Dynamic import to avoid loading watcher on every CLI call
+    const { IndexWatcher, writeWatcherStatus, clearWatcherStatus } = await import('./watcher.js');
+
+    const watcher = new IndexWatcher(cwd, {
+      verbose: options.verbose,
+      autoRebuild: options.autoRebuild !== false
+    });
+
+    // Event handlers
+    watcher.on('started', () => {
+      console.log(chalk.green('✓ Watcher started'));
+      console.log(chalk.gray(`  Watching: ${cwd}`));
+      console.log(chalk.gray(`  Auto-rebuild: ${options.autoRebuild !== false ? 'enabled' : 'disabled'}`));
+      console.log(chalk.yellow('\n  Press Ctrl+C to stop\n'));
+    });
+
+    watcher.on('change', ({ type, path: filePath }) => {
+      const icon = type === 'rename' ? '~' : type === 'change' ? '±' : '+';
+      console.log(chalk.gray(`  ${icon} ${filePath}`));
+    });
+
+    watcher.on('indexing', ({ type }) => {
+      if (type === 'initial') {
+        console.log(chalk.yellow('  Building initial index...'));
+      } else {
+        console.log(chalk.yellow('  Updating index...'));
+      }
+    });
+
+    watcher.on('indexed', ({ type, changesProcessed }) => {
+      if (type === 'initial') {
+        console.log(chalk.green('  ✓ Initial index complete'));
+      } else {
+        console.log(chalk.green(`  ✓ Index updated (${changesProcessed} files)`));
+      }
+      writeWatcherStatus(cwd, watcher.getStatus());
+    });
+
+    watcher.on('error', (err) => {
+      console.log(chalk.red(`  ✗ Error: ${err.message}`));
+    });
+
+    // Graceful shutdown
+    const shutdown = async () => {
+      console.log(chalk.yellow('\n\nStopping watcher...'));
+      watcher.stop();
+      await clearWatcherStatus(cwd);
+      console.log(chalk.green('Watcher stopped.'));
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    // Start watching
+    try {
+      await watcher.start();
+      await writeWatcherStatus(cwd, watcher.getStatus());
+    } catch (error) {
+      console.error(chalk.red('Failed to start watcher:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// ========================================
+// MEMORY COMMANDS (Auto-Memory System)
+// ========================================
+
+const memory = program
+  .command('memory')
+  .alias('mem')
+  .description('Auto-memory system for persistent context across sessions');
+
+memory
+  .command('remember <content>')
+  .description('Save a memory (decision, pattern, or context)')
+  .option('-t, --type <type>', 'Memory type: decision, pattern, context, learning', 'context')
+  .option('-i, --importance <level>', 'Importance: low, normal, high, critical', 'normal')
+  .option('-g, --tags <tags>', 'Comma-separated tags')
+  .option('-f, --files <files>', 'Related files (comma-separated)')
+  .option('-s, --summary <summary>', 'Short summary of the memory')
+  .action(async (content, options) => {
+    console.log(banner);
+
+    try {
+      const cwd = process.cwd();
+      const spinner = ora('Saving memory...').start();
+
+      const memory = await remember(content, {
+        type: options.type,
+        importance: options.importance,
+        tags: options.tags ? options.tags.split(',').map(t => t.trim()) : [],
+        files: options.files ? options.files.split(',').map(f => f.trim()) : [],
+        summary: options.summary,
+        source: 'user'
+      }, cwd);
+
+      spinner.succeed(chalk.green('Memory saved!'));
+
+      console.log(chalk.cyan('\n📝 Memory Details:'));
+      console.log(chalk.gray(`   ID: ${memory.id}`));
+      console.log(chalk.gray(`   Type: ${memory.type}`));
+      console.log(chalk.gray(`   Importance: ${memory.importance}`));
+      if (memory.tags.length) {
+        console.log(chalk.gray(`   Tags: ${memory.tags.join(', ')}`));
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to save memory:'), error.message);
+      process.exit(1);
+    }
+  });
+
+memory
+  .command('recall [query]')
+  .description('Recall relevant memories')
+  .option('-l, --limit <n>', 'Number of memories to return', '10')
+  .option('-t, --types <types>', 'Filter by types (comma-separated)', 'decision,pattern,context,learning')
+  .option('-i, --min-importance <level>', 'Minimum importance level', 'low')
+  .option('--json', 'Output as JSON')
+  .action(async (query, options) => {
+    const cwd = process.cwd();
+
+    try {
+      const memories = await recall(query || '', {
+        limit: parseInt(options.limit),
+        types: options.types.split(',').map(t => t.trim()),
+        minImportance: options.minImportance
+      }, cwd);
+
+      if (options.json) {
+        console.log(JSON.stringify(memories, null, 2));
+        return;
+      }
+
+      console.log(banner);
+
+      if (memories.length === 0) {
+        console.log(chalk.yellow('\n⚠️  No memories found.'));
+        if (query) {
+          console.log(chalk.gray(`   Query: "${query}"`));
+        }
+        console.log(chalk.gray('\n   Use `namnam memory remember` to save memories.'));
+        return;
+      }
+
+      console.log(chalk.cyan(`\n🧠 Memories${query ? ` matching "${query}"` : ''} (${memories.length}):\n`));
+
+      const typeIcons = {
+        decision: '⚖️',
+        pattern: '🔄',
+        context: '📝',
+        learning: '💡'
+      };
+
+      const importanceColors = {
+        low: chalk.gray,
+        normal: chalk.white,
+        high: chalk.yellow,
+        critical: chalk.red
+      };
+
+      for (const mem of memories) {
+        const icon = typeIcons[mem.type] || '📝';
+        const colorFn = importanceColors[mem.importance] || chalk.white;
+        const age = getTimeAgo(new Date(mem.createdAt));
+
+        console.log(colorFn(`  ${icon} ${mem.summary || mem.content.substring(0, 60)}...`));
+        console.log(chalk.gray(`     ${mem.type} | ${mem.importance} | ${age}`));
+        if (mem.tags.length) {
+          console.log(chalk.gray(`     Tags: ${mem.tags.join(', ')}`));
+        }
+        console.log();
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to recall memories:'), error.message);
+      process.exit(1);
+    }
+  });
+
+memory
+  .command('list')
+  .description('List all memories')
+  .option('-t, --type <type>', 'Filter by type')
+  .option('-l, --limit <n>', 'Limit results', '20')
+  .action(async (options) => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+
+    try {
+      const index = await loadAutoMemoryIndex(cwd);
+
+      let allMemories = [
+        ...index.memories.map(m => ({ ...m, _category: 'context' })),
+        ...index.decisions.map(m => ({ ...m, _category: 'decision' })),
+        ...index.patterns.map(m => ({ ...m, _category: 'pattern' }))
+      ];
+
+      // Filter by type
+      if (options.type) {
+        allMemories = allMemories.filter(m => m.type === options.type);
+      }
+
+      // Sort by date (newest first)
+      allMemories.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+
+      // Limit
+      const limit = parseInt(options.limit);
+      allMemories = allMemories.slice(0, limit);
+
+      if (allMemories.length === 0) {
+        console.log(chalk.yellow('\n⚠️  No memories found.'));
+        console.log(chalk.gray('\n   Use `namnam memory remember` to save memories.'));
+        return;
+      }
+
+      console.log(chalk.cyan(`\n🧠 All Memories (${allMemories.length}):\n`));
+
+      console.log(chalk.gray('   ID                   | Type      | Importance | Content'));
+      console.log(chalk.gray('   ' + '-'.repeat(70)));
+
+      for (const mem of allMemories) {
+        const content = (mem.summary || mem.content).substring(0, 35);
+        console.log(
+          chalk.gray(`   ${mem.id.padEnd(20)} | `) +
+          chalk.cyan(`${mem.type.padEnd(9)} | `) +
+          chalk.yellow(`${mem.importance.padEnd(10)} | `) +
+          chalk.white(content)
+        );
+      }
+
+      console.log(chalk.gray('\n   Total: ' + allMemories.length + ' memories'));
+    } catch (error) {
+      console.error(chalk.red('Failed to list memories:'), error.message);
+      process.exit(1);
+    }
+  });
+
+memory
+  .command('session')
+  .description('Manage current session')
+  .option('-s, --start [task]', 'Start a new session')
+  .option('-e, --end', 'End current session')
+  .option('-u, --update', 'Update session with a decision or note')
+  .option('-d, --decision <text>', 'Record a decision')
+  .option('-n, --note <text>', 'Add a note/memory')
+  .option('--status', 'Show current session status')
+  .action(async (options) => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+
+    try {
+      if (options.start !== undefined) {
+        const task = typeof options.start === 'string' ? options.start : null;
+        const session = await startSession({ task }, cwd);
+        console.log(chalk.green('\n✅ Session started!'));
+        console.log(chalk.gray(`   ID: ${session.id}`));
+        if (task) {
+          console.log(chalk.gray(`   Task: ${task}`));
+        }
+        console.log(chalk.cyan('\n   Use `namnam memory session --end` when done.'));
+        return;
+      }
+
+      if (options.end) {
+        const session = await endSession({}, cwd);
+        if (!session) {
+          console.log(chalk.yellow('\n⚠️  No active session to end.'));
+          return;
+        }
+        console.log(chalk.green('\n✅ Session ended!'));
+        console.log(chalk.gray(`   ID: ${session.id}`));
+        console.log(chalk.gray(`   Duration: ${getTimeAgo(new Date(session.startedAt))}`));
+        console.log(chalk.gray(`   Decisions saved: ${session.decisions.length}`));
+        console.log(chalk.gray(`   Memories saved: ${session.memories.length}`));
+        return;
+      }
+
+      if (options.decision) {
+        await updateSession({ decision: options.decision }, cwd);
+        console.log(chalk.green('\n✅ Decision recorded!'));
+        console.log(chalk.gray(`   "${options.decision}"`));
+        return;
+      }
+
+      if (options.note) {
+        await updateSession({ memory: options.note }, cwd);
+        console.log(chalk.green('\n✅ Note added!'));
+        console.log(chalk.gray(`   "${options.note}"`));
+        return;
+      }
+
+      // Default: show status
+      const session = await getCurrentSession(cwd);
+      if (!session) {
+        console.log(chalk.yellow('\n⚠️  No active session.'));
+        console.log(chalk.gray('\n   Use `namnam memory session --start` to begin.'));
+        return;
+      }
+
+      console.log(chalk.cyan('\n📋 Current Session:\n'));
+      console.log(chalk.gray(`   ID: ${session.id}`));
+      console.log(chalk.gray(`   Started: ${new Date(session.startedAt).toLocaleString()}`));
+      console.log(chalk.gray(`   Task: ${session.task || '(none)'}`));
+      console.log(chalk.gray(`   Files modified: ${session.filesModified.length}`));
+      console.log(chalk.gray(`   Decisions: ${session.decisions.length}`));
+      console.log(chalk.gray(`   Notes: ${session.memories.length}`));
+
+      if (session.decisions.length > 0) {
+        console.log(chalk.cyan('\n   Recent Decisions:'));
+        for (const d of session.decisions.slice(-3)) {
+          console.log(chalk.white(`     • ${d.content}`));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Session error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+memory
+  .command('context')
+  .description('Generate auto-memory context for AI consumption')
+  .option('-q, --query <query>', 'Query to find relevant memories')
+  .option('-l, --limit <n>', 'Max memories to include', '10')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    const cwd = process.cwd();
+
+    try {
+      const context = await generateAutoMemoryContext({
+        query: options.query,
+        limit: parseInt(options.limit)
+      }, cwd);
+
+      if (!context) {
+        if (!options.json) {
+          console.log(chalk.yellow('No relevant memories found.'));
+        } else {
+          console.log(JSON.stringify({ context: null }));
+        }
+        return;
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({ context }));
+      } else {
+        console.log(context);
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to generate context:'), error.message);
+      process.exit(1);
+    }
+  });
+
+memory
+  .command('init')
+  .description('Initialize auto-memory system for this project')
+  .action(async () => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+
+    try {
+      const spinner = ora('Initializing auto-memory system...').start();
+      await initAutoMemory(cwd);
+      spinner.succeed(chalk.green('Auto-memory system initialized!'));
+
+      console.log(chalk.cyan('\n📝 Memory directory created at:'));
+      console.log(chalk.gray(`   .claude/auto-memories/`));
+
+      console.log(chalk.cyan('\n🚀 Quick Start:'));
+      console.log(chalk.gray('   namnam memory remember "User prefers TypeScript" -t pattern'));
+      console.log(chalk.gray('   namnam memory recall "preferences"'));
+      console.log(chalk.gray('   namnam memory session --start "Implement feature X"'));
+    } catch (error) {
+      console.error(chalk.red('Failed to initialize:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Helper function for time ago
+function getTimeAgo(date) {
+  const seconds = Math.floor((new Date() - date) / 1000);
+
+  if (seconds < 60) return 'just now';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  if (seconds < 604800) return `${Math.floor(seconds / 86400)}d ago`;
+  return date.toLocaleDateString();
+}
+
 program.parse();