namnam-skills 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "namnam-skills",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Ultimate AI Skills Installer - Universal support for Claude, Codex, Cursor, Windsurf, Cline, Aider, and more. 150+ agents, workflows, and skills.",
   "author": "NamNam",
   "license": "MIT",

package/src/cli.js

@@ -15,7 +15,19 @@ import {
   deleteConversation,
   exportConversation,
   getConversationContext,
-  updateConversation
+  updateConversation,
+  // Auto-memory functions
+  initAutoMemory,
+  loadAutoMemoryIndex,
+  autoSaveMemory,
+  getRelevantMemories,
+  generateAutoMemoryContext,
+  startSession,
+  getCurrentSession,
+  updateSession,
+  endSession,
+  remember,
+  recall
 } from './conversation.js';
 import {
   buildIndex,
@@ -809,11 +821,36 @@ 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) => {
-    console.log(banner);
-
     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);
@@ -879,11 +916,38 @@ index
 index
   .command('status')
   .description('Show index status and statistics')
-  .action(async () => {
-    console.log(banner);
-
+  .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.'));
@@ -1001,4 +1065,408 @@ index
     }
   });
 
+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();