namnam-skills 1.0.0 → 1.0.2

package/src/templates/platforms/AGENTS.md

@@ -285,6 +285,53 @@ When using Cursor, Windsurf, Cline, or other agents:
 - Reference previous work
 - Store important context
 
+### @conversation System
+
+The project supports cross-conversation context via the `@conversation` feature.
+
+#### Recognizing References
+When users include `@conversation:<id>` in their messages:
+```
+Pattern: @conversation[:\s]+([a-zA-Z0-9_-]+)
+Examples:
+  - @conversation:abc123
+  - @conversation abc123
+  - Based on @conversation:auth01, implement...
+```
+
+#### Loading Context
+Load referenced conversation context:
+```bash
+# Get formatted context
+namnam conv context <id>
+
+# Or read directly from
+.claude/conversations/<full-id>/context.md
+```
+
+#### Using Context
+When conversation context is loaded:
+1. Treat it as authoritative prior decisions
+2. Build upon the context, don't contradict it
+3. Reference specific points when relevant
+4. Ask for clarification if context seems outdated
+
+#### Saving Conversations
+When a session contains important decisions, suggest saving:
+```bash
+namnam conv save -t "Title" -s "Brief summary"
+```
+
+#### Storage Location
+```
+.claude/conversations/
+├── index.json           # Conversation index
+└── conv_xxx_yyy/        # Individual conversation
+    ├── meta.json        # Metadata
+    ├── context.md       # Loadable context
+    └── full.md          # Full log (optional)
+```
+
 ---
 
 ## Error Handling

package/src/watcher.js

@@ -0,0 +1,356 @@
+/**
+ * File Watcher for Live Indexing
+ *
+ * Watches for file changes and triggers incremental index updates.
+ * Uses Node.js native fs.watch with debouncing for efficiency.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { EventEmitter } from 'events';
+import {
+  buildIndex,
+  hasIndex,
+  getIndexDir,
+  checkIndexChanges,
+  getIndexMeta,
+  updateIndexIncremental
+} from './indexer.js';
+
+// Constants
+const DEBOUNCE_MS = 1000;  // Wait 1 second after last change
+const BATCH_INTERVAL_MS = 5000;  // Process batch every 5 seconds max
+
+// File patterns to watch
+const WATCH_EXTENSIONS = new Set([
+  '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
+  '.py', '.rb', '.go', '.rs', '.java', '.kt',
+  '.c', '.cpp', '.h', '.hpp', '.cs',
+  '.vue', '.svelte', '.astro',
+  '.json', '.yaml', '.yml', '.toml',
+  '.md', '.mdx',
+  '.css', '.scss', '.less',
+  '.html', '.xml',
+  '.sql', '.graphql', '.prisma'
+]);
+
+// Directories to skip
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '.svn', '.hg',
+  'dist', 'build', 'out', '.next', '.nuxt',
+  'coverage', '.nyc_output',
+  '__pycache__', '.pytest_cache',
+  'vendor', 'target',
+  '.claude', '.cursor', '.vscode'
+]);
+
+/**
+ * IndexWatcher - Watches filesystem and triggers index updates
+ */
+export class IndexWatcher extends EventEmitter {
+  constructor(cwd = process.cwd(), options = {}) {
+    super();
+    this.cwd = cwd;
+    this.options = {
+      debounceMs: options.debounceMs || DEBOUNCE_MS,
+      batchIntervalMs: options.batchIntervalMs || BATCH_INTERVAL_MS,
+      autoRebuild: options.autoRebuild !== false,
+      verbose: options.verbose || false,
+      ...options
+    };
+
+    this.watchers = new Map();
+    this.pendingChanges = new Map();
+    this.debounceTimer = null;
+    this.batchTimer = null;
+    this.isIndexing = false;
+    this.isRunning = false;
+    this.stats = {
+      filesChanged: 0,
+      indexUpdates: 0,
+      lastUpdate: null
+    };
+  }
+
+  /**
+   * Start watching the directory
+   */
+  async start() {
+    if (this.isRunning) {
+      this.log('Watcher already running');
+      return;
+    }
+
+    this.log('Starting file watcher...');
+    this.isRunning = true;
+
+    // Ensure index exists
+    if (!(await hasIndex(this.cwd))) {
+      this.log('No index found, building initial index...');
+      this.emit('indexing', { type: 'initial' });
+      await buildIndex(this.cwd, {
+        onProgress: (progress) => this.emit('progress', progress)
+      });
+      this.emit('indexed', { type: 'initial' });
+    }
+
+    // Start watching
+    await this.watchDirectory(this.cwd);
+
+    // Start batch processor
+    this.batchTimer = setInterval(() => {
+      this.processPendingChanges();
+    }, this.options.batchIntervalMs);
+
+    this.emit('started');
+    this.log(`Watching ${this.watchers.size} directories`);
+  }
+
+  /**
+   * Stop watching
+   */
+  stop() {
+    if (!this.isRunning) return;
+
+    this.log('Stopping file watcher...');
+    this.isRunning = false;
+
+    // Clear timers
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    if (this.batchTimer) clearInterval(this.batchTimer);
+
+    // Close all watchers
+    for (const [dir, watcher] of this.watchers) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.pendingChanges.clear();
+
+    this.emit('stopped');
+  }
+
+  /**
+   * Watch a directory recursively
+   */
+  async watchDirectory(dir) {
+    try {
+      const items = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const item of items) {
+        if (item.isDirectory() && !SKIP_DIRS.has(item.name) && !item.name.startsWith('.')) {
+          const subDir = path.join(dir, item.name);
+          await this.watchDirectory(subDir);
+        }
+      }
+
+      // Watch this directory
+      const watcher = fs.watch(dir, (eventType, filename) => {
+        if (filename) {
+          this.handleFileChange(eventType, path.join(dir, filename));
+        }
+      });
+
+      watcher.on('error', (err) => {
+        this.log(`Watcher error for ${dir}: ${err.message}`);
+        // Try to recover by removing and re-adding watcher
+        this.watchers.delete(dir);
+      });
+
+      this.watchers.set(dir, watcher);
+    } catch (err) {
+      this.log(`Error watching ${dir}: ${err.message}`);
+    }
+  }
+
+  /**
+   * Handle a file change event
+   */
+  handleFileChange(eventType, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const relativePath = path.relative(this.cwd, filePath).replace(/\\/g, '/');
+
+    // Check if we should watch this file
+    if (!WATCH_EXTENSIONS.has(ext)) return;
+
+    // Skip if in ignored directory
+    const parts = relativePath.split('/');
+    if (parts.some(part => SKIP_DIRS.has(part))) return;
+
+    this.log(`File ${eventType}: ${relativePath}`);
+
+    // Add to pending changes
+    this.pendingChanges.set(relativePath, {
+      type: eventType,
+      path: relativePath,
+      fullPath: filePath,
+      timestamp: Date.now()
+    });
+
+    this.stats.filesChanged++;
+    this.emit('change', { type: eventType, path: relativePath });
+
+    // Debounce the index update
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.processPendingChanges();
+    }, this.options.debounceMs);
+  }
+
+  /**
+   * Process all pending changes
+   */
+  async processPendingChanges() {
+    if (this.isIndexing || this.pendingChanges.size === 0) return;
+
+    const changes = Array.from(this.pendingChanges.values());
+    this.pendingChanges.clear();
+
+    if (this.options.autoRebuild) {
+      await this.updateIndex(changes);
+    } else {
+      this.emit('changes-pending', { changes });
+    }
+  }
+
+  /**
+   * Update the index with changes
+   */
+  async updateIndex(changes) {
+    if (this.isIndexing) return;
+
+    this.isIndexing = true;
+    this.emit('indexing', { type: 'incremental', changes });
+
+    try {
+      // Normalize changes to the format expected by updateIndexIncremental
+      const normalizedChanges = changes.map(change => ({
+        path: change.path,
+        fullPath: change.fullPath,
+        type: change.type === 'rename' ? 'add' : change.type // rename could be add or delete
+      }));
+
+      // Use incremental indexing for better performance
+      await updateIndexIncremental(normalizedChanges, this.cwd, {
+        onProgress: (progress) => this.emit('progress', progress)
+      });
+
+      this.stats.indexUpdates++;
+      this.stats.lastUpdate = new Date().toISOString();
+
+      this.emit('indexed', {
+        type: 'incremental',
+        changesProcessed: changes.length,
+        stats: this.stats
+      });
+
+      this.log(`Index updated (${changes.length} files changed)`);
+    } catch (err) {
+      this.log(`Index update failed: ${err.message}`);
+      this.emit('error', err);
+    } finally {
+      this.isIndexing = false;
+    }
+  }
+
+  /**
+   * Force a full index rebuild
+   */
+  async forceRebuild() {
+    this.pendingChanges.clear();
+    this.isIndexing = true;
+    this.emit('indexing', { type: 'full' });
+
+    try {
+      await buildIndex(this.cwd, {
+        onProgress: (progress) => this.emit('progress', progress)
+      });
+
+      this.stats.indexUpdates++;
+      this.stats.lastUpdate = new Date().toISOString();
+
+      this.emit('indexed', { type: 'full', stats: this.stats });
+      this.log('Full index rebuild complete');
+    } catch (err) {
+      this.emit('error', err);
+      throw err;
+    } finally {
+      this.isIndexing = false;
+    }
+  }
+
+  /**
+   * Get watcher status
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      indexing: this.isIndexing,
+      watchedDirectories: this.watchers.size,
+      pendingChanges: this.pendingChanges.size,
+      stats: this.stats
+    };
+  }
+
+  /**
+   * Log message if verbose mode
+   */
+  log(message) {
+    if (this.options.verbose) {
+      console.log(`[IndexWatcher] ${message}`);
+    }
+  }
+}
+
+/**
+ * Create and start a watcher daemon
+ */
+export async function startWatcherDaemon(cwd = process.cwd(), options = {}) {
+  const watcher = new IndexWatcher(cwd, options);
+
+  // Set up event handlers for CLI output
+  if (options.verbose) {
+    watcher.on('started', () => console.log('File watcher started'));
+    watcher.on('stopped', () => console.log('File watcher stopped'));
+    watcher.on('change', ({ type, path }) => console.log(`  ${type}: ${path}`));
+    watcher.on('indexing', ({ type }) => console.log(`Indexing (${type})...`));
+    watcher.on('indexed', ({ type, changesProcessed }) => {
+      console.log(`Index updated (${type}${changesProcessed ? `, ${changesProcessed} files` : ''})`);
+    });
+    watcher.on('error', (err) => console.error(`Error: ${err.message}`));
+  }
+
+  await watcher.start();
+  return watcher;
+}
+
+/**
+ * Watch status file for IPC with VS Code extension
+ */
+const STATUS_FILE = '.claude/watcher-status.json';
+
+export async function writeWatcherStatus(cwd, status) {
+  const statusPath = path.join(cwd, STATUS_FILE);
+  await fs.ensureDir(path.dirname(statusPath));
+  await fs.writeJson(statusPath, {
+    ...status,
+    pid: process.pid,
+    updatedAt: new Date().toISOString()
+  }, { spaces: 2 });
+}
+
+export async function readWatcherStatus(cwd) {
+  const statusPath = path.join(cwd, STATUS_FILE);
+  if (await fs.pathExists(statusPath)) {
+    return await fs.readJson(statusPath);
+  }
+  return null;
+}
+
+export async function clearWatcherStatus(cwd) {
+  const statusPath = path.join(cwd, STATUS_FILE);
+  if (await fs.pathExists(statusPath)) {
+    await fs.remove(statusPath);
+  }
+}
+
+export default IndexWatcher;

package/src/templates/core/code-review.md

@@ -1,70 +0,0 @@
-# /code-review - Multi-Aspect Code Review
-
-> Comprehensive code review using parallel expert agents
-
-## Usage
-
-```
-/code-review
-/code-review src/auth
-/code-review --focus security
-```
-
-## Instructions
-
-When the user invokes `/code-review`:
-
-### Step 1: Identify Target
-
-If no path provided, review recent changes:
-```bash
-git diff --name-only HEAD~1
-```
-
-### Step 2: Spawn Review Agents
-
-Run these in parallel:
-
-| Agent | Focus |
-|-------|-------|
-| Architecture Reviewer | Design patterns, coupling |
-| Code Quality Reviewer | Readability, duplication |
-| Security Reviewer | Vulnerabilities, OWASP |
-| Performance Reviewer | Bottlenecks, optimization |
-| Testing Reviewer | Coverage, quality |
-| Documentation Reviewer | Comments, API docs |
-
-### Step 3: Aggregate Results
-
-```markdown
-## Code Review Report
-
-### Summary
-- **Files reviewed**: 12
-- **Issues found**: 8
-- **Severity**: 2 Critical, 3 High, 3 Medium
-
-### Critical Issues 🔴
-| File:Line | Issue | Recommendation |
-|-----------|-------|----------------|
-| auth.ts:42 | SQL injection risk | Use parameterized query |
-
-### High Priority 🟡
-| File:Line | Issue | Recommendation |
-|-----------|-------|----------------|
-| utils.ts:15 | No input validation | Add validation |
-
-### Medium Priority 🟢
-| File:Line | Issue | Recommendation |
-|-----------|-------|----------------|
-| form.tsx:88 | Missing error handling | Add try-catch |
-
-### Strengths ✨
-- Good separation of concerns
-- Consistent naming conventions
-
-### Recommendations
-1. Address critical security issues immediately
-2. Add input validation to all user inputs
-3. Increase test coverage to 80%
-```

package/src/templates/core/git-commit.md

@@ -1,57 +0,0 @@
-# /git:commit - Smart Git Commit
-
-> Create intelligent git commits with conventional commit format
-
-## Usage
-
-```
-/git:commit
-/git:commit fix login validation
-```
-
-## Instructions
-
-When the user invokes `/git:commit`:
-
-1. **Check git status**:
-   ```bash
-   git status --porcelain
-   git diff --staged --stat
-   ```
-
-2. **If no staged changes**:
-   - Show modified/untracked files
-   - Ask what to stage
-
-3. **Analyze changes**:
-   - Parse diff to understand changes
-   - Identify commit type: feat, fix, refactor, docs, test, chore
-
-4. **Generate commit message**:
-   - Follow conventional commits: `<type>(<scope>): <subject>`
-   - Keep subject under 50 chars
-   - Add body for complex changes
-
-5. **Execute**:
-   ```bash
-   git commit -m "$(cat <<'EOF'
-   <type>(<scope>): <subject>
-
-   <body>
-
-   Co-Authored-By: Claude <noreply@anthropic.com>
-   EOF
-   )"
-   ```
-
-## Commit Types
-
-| Type | When to use |
-|------|-------------|
-| `feat` | New feature |
-| `fix` | Bug fix |
-| `docs` | Documentation |
-| `style` | Formatting |
-| `refactor` | Code restructure |
-| `test` | Tests |
-| `chore` | Maintenance |

package/src/templates/core/git-push.md

@@ -1,53 +0,0 @@
-# /git:push - Safe Git Push
-
-> Push commits to remote with safety checks
-
-## Usage
-
-```
-/git:push
-/git:push origin main
-```
-
-## Instructions
-
-When the user invokes `/git:push`:
-
-1. **Pre-push checks**:
-   ```bash
-   git status
-   git log origin/HEAD..HEAD --oneline
-   ```
-
-2. **Safety validations**:
-   - Check if branch is protected
-   - Warn if pushing to main/master
-   - Check for uncommitted changes
-
-3. **Execute push**:
-   ```bash
-   git push -u origin <branch>
-   ```
-
-4. **Post-push summary**:
-   ```markdown
-   ## Push Complete
-
-   **Branch**: feature/auth → origin/feature/auth
-   **Commits pushed**: 3
-
-   ### Commits
-   - abc123 feat(auth): add login
-   - def456 fix(auth): validate email
-   - ghi789 test(auth): add tests
-
-   ### Next Steps
-   - Create PR: `gh pr create`
-   - Or use `/commit-push-pr` for full workflow
-   ```
-
-## Safety
-
-- Never force push without explicit request
-- Warn before pushing to protected branches
-- Show what will be pushed before confirming

package/src/templates/core/git-status.md

@@ -1,48 +0,0 @@
-# /git:status - Enhanced Git Status
-
-> Intelligent git status with insights
-
-## Usage
-
-```
-/git:status
-```
-
-## Instructions
-
-When the user invokes `/git:status`:
-
-1. **Get status**:
-   ```bash
-   git status
-   git diff --stat
-   ```
-
-2. **Analyze and present**:
-   ```markdown
-   ## Git Status
-
-   ### Branch
-   **Current**: feature/auth
-   **Tracking**: origin/feature/auth (2 ahead, 1 behind)
-
-   ### Changes
-
-   #### Staged (ready to commit)
-   - ✅ src/auth/login.ts (+42, -15)
-   - ✅ src/utils/validate.ts (+10, -2)
-
-   #### Modified (not staged)
-   - 📝 src/components/Form.tsx
-   - 📝 src/hooks/useAuth.ts
-
-   #### Untracked
-   - ❓ src/new-file.ts
-   - ❓ tests/auth.test.ts
-
-   ### Suggestions
-   - Run `git add .` to stage all changes
-   - Run `/git:commit` to commit staged changes
-   ```
-
-3. **Provide actionable insights**