namnam-skills 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "namnam-skills",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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",
@@ -47,6 +47,7 @@
     "commander": "^12.1.0",
     "fs-extra": "^11.2.0",
     "inquirer": "^9.2.15",
+    "namnam-skills": "^1.0.0",
     "ora": "^8.0.1"
   },
   "engines": {

package/src/cli.js

@@ -7,6 +7,25 @@ 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
+} 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 +476,529 @@ 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')
+  .action(async (options) => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+
+    // 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')
+  .action(async () => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+
+    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);
+    }
+  });
+
 program.parse();