namnam-skills 1.0.1 → 1.0.2

package/src/conversation.js

@@ -16,6 +16,11 @@ const META_FILE = 'meta.json';
 const CONTEXT_FILE = 'context.md';
 const FULL_LOG_FILE = 'full.md';
 
+// Auto-memory files
+const AUTO_MEMORY_DIR = 'auto-memories';
+const AUTO_MEMORY_INDEX = 'auto-index.json';
+const AUTO_MEMORY_CURRENT = 'current-session.json';
+
 /**
  * Validate conversation options
  */
@@ -445,3 +450,465 @@ export async function resolveConversationRefs(text, cwd = process.cwd()) {
     combined: contexts.join('\n\n')
   };
 }
+
+// ========================================
+// AUTO-MEMORY SYSTEM
+// ========================================
+
+/**
+ * Get auto-memory directory path
+ */
+export function getAutoMemoryDir(cwd = process.cwd()) {
+  return path.join(cwd, '.claude', AUTO_MEMORY_DIR);
+}
+
+/**
+ * Get auto-memory index path
+ */
+export function getAutoMemoryIndexPath(cwd = process.cwd()) {
+  return path.join(getAutoMemoryDir(cwd), AUTO_MEMORY_INDEX);
+}
+
+/**
+ * Get current session path
+ */
+export function getCurrentSessionPath(cwd = process.cwd()) {
+  return path.join(getAutoMemoryDir(cwd), AUTO_MEMORY_CURRENT);
+}
+
+/**
+ * Initialize auto-memory system
+ */
+export async function initAutoMemory(cwd = process.cwd()) {
+  const memoryDir = getAutoMemoryDir(cwd);
+  const indexPath = getAutoMemoryIndexPath(cwd);
+
+  await fs.ensureDir(memoryDir);
+
+  if (!(await fs.pathExists(indexPath))) {
+    await fs.writeJson(indexPath, {
+      version: '1.0.0',
+      memories: [],
+      patterns: [],
+      decisions: [],
+      lastUpdated: new Date().toISOString()
+    }, { spaces: 2 });
+  }
+
+  return memoryDir;
+}
+
+/**
+ * Load auto-memory index
+ */
+export async function loadAutoMemoryIndex(cwd = process.cwd()) {
+  const indexPath = getAutoMemoryIndexPath(cwd);
+
+  if (!(await fs.pathExists(indexPath))) {
+    return { version: '1.0.0', memories: [], patterns: [], decisions: [], lastUpdated: null };
+  }
+
+  return await fs.readJson(indexPath);
+}
+
+/**
+ * Save auto-memory index
+ */
+export async function saveAutoMemoryIndex(index, cwd = process.cwd()) {
+  const indexPath = getAutoMemoryIndexPath(cwd);
+  index.lastUpdated = new Date().toISOString();
+  await fs.writeJson(indexPath, index, { spaces: 2 });
+}
+
+// Validation constants for auto-memory
+const VALID_MEMORY_TYPES = ['decision', 'pattern', 'context', 'learning'];
+const VALID_IMPORTANCE_LEVELS = ['low', 'normal', 'high', 'critical'];
+const VALID_SOURCES = ['auto', 'user', 'agent', 'session'];
+const MAX_CONTENT_SIZE = 10000; // 10KB max per memory
+
+/**
+ * Validate auto-memory input
+ */
+function validateMemoryInput(memory) {
+  const errors = [];
+
+  // Content is required
+  if (!memory.content || typeof memory.content !== 'string') {
+    errors.push('content is required and must be a string');
+  } else if (memory.content.length > MAX_CONTENT_SIZE) {
+    errors.push(`content exceeds maximum size of ${MAX_CONTENT_SIZE} characters`);
+  }
+
+  // Validate type
+  if (memory.type && !VALID_MEMORY_TYPES.includes(memory.type)) {
+    errors.push(`type must be one of: ${VALID_MEMORY_TYPES.join(', ')}`);
+  }
+
+  // Validate importance
+  if (memory.importance && !VALID_IMPORTANCE_LEVELS.includes(memory.importance)) {
+    errors.push(`importance must be one of: ${VALID_IMPORTANCE_LEVELS.join(', ')}`);
+  }
+
+  // Validate source
+  if (memory.source && !VALID_SOURCES.includes(memory.source)) {
+    errors.push(`source must be one of: ${VALID_SOURCES.join(', ')}`);
+  }
+
+  // Validate tags
+  if (memory.tags && !Array.isArray(memory.tags)) {
+    errors.push('tags must be an array');
+  }
+
+  // Validate relatedFiles
+  if (memory.relatedFiles && !Array.isArray(memory.relatedFiles)) {
+    errors.push('relatedFiles must be an array');
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid memory input: ${errors.join('; ')}`);
+  }
+}
+
+/**
+ * Auto-save a memory (decision, pattern, or important context)
+ * This is called automatically during AI interactions
+ */
+export async function autoSaveMemory(memory, cwd = process.cwd()) {
+  // Validate input
+  validateMemoryInput(memory);
+
+  await initAutoMemory(cwd);
+
+  const index = await loadAutoMemoryIndex(cwd);
+  const id = `mem_${Date.now().toString(36)}_${crypto.randomBytes(2).toString('hex')}`;
+
+  const memoryEntry = {
+    id,
+    type: memory.type || 'context', // 'decision', 'pattern', 'context', 'learning'
+    content: memory.content,
+    summary: memory.summary || null,
+    source: memory.source || 'auto', // 'auto', 'user', 'agent'
+    tags: memory.tags || [],
+    importance: memory.importance || 'normal', // 'low', 'normal', 'high', 'critical'
+    relatedFiles: memory.relatedFiles || [],
+    createdAt: new Date().toISOString(),
+    expiresAt: memory.expiresAt || null // null = never expires
+  };
+
+  // Add to appropriate array based on type
+  if (memory.type === 'decision') {
+    index.decisions.push(memoryEntry);
+  } else if (memory.type === 'pattern') {
+    index.patterns.push(memoryEntry);
+  } else {
+    index.memories.push(memoryEntry);
+  }
+
+  // Keep only last 100 memories per type (cleanup old ones)
+  if (index.memories.length > 100) {
+    index.memories = index.memories.slice(-100);
+  }
+  if (index.decisions.length > 50) {
+    index.decisions = index.decisions.slice(-50);
+  }
+  if (index.patterns.length > 50) {
+    index.patterns = index.patterns.slice(-50);
+  }
+
+  await saveAutoMemoryIndex(index, cwd);
+
+  return memoryEntry;
+}
+
+/**
+ * Get relevant memories for a query/context
+ * Uses keyword matching and recency
+ */
+export async function getRelevantMemories(options = {}, cwd = process.cwd()) {
+  const {
+    query = null,
+    files = [],
+    types = ['decision', 'pattern', 'context', 'learning'],
+    limit = 10,
+    minImportance = 'low'
+  } = options;
+
+  const index = await loadAutoMemoryIndex(cwd);
+
+  // Combine all memory types
+  let allMemories = [
+    ...index.memories.map(m => ({ ...m, _type: 'memory' })),
+    ...index.decisions.map(m => ({ ...m, _type: 'decision' })),
+    ...index.patterns.map(m => ({ ...m, _type: 'pattern' }))
+  ];
+
+  // Filter by type
+  allMemories = allMemories.filter(m => types.includes(m.type));
+
+  // Filter by importance
+  const importanceOrder = ['low', 'normal', 'high', 'critical'];
+  const minIdx = importanceOrder.indexOf(minImportance);
+  allMemories = allMemories.filter(m => {
+    const memIdx = importanceOrder.indexOf(m.importance);
+    return memIdx >= minIdx;
+  });
+
+  // Filter expired
+  const now = new Date();
+  allMemories = allMemories.filter(m => {
+    if (!m.expiresAt) return true;
+    return new Date(m.expiresAt) > now;
+  });
+
+  // Score by relevance
+  allMemories = allMemories.map(m => {
+    let score = 0;
+
+    // Recency score (newer = higher)
+    const age = now - new Date(m.createdAt);
+    const hoursSinceCreated = age / (1000 * 60 * 60);
+    score += Math.max(0, 10 - hoursSinceCreated / 24); // Decays over 10 days
+
+    // Importance score
+    score += importanceOrder.indexOf(m.importance) * 2;
+
+    // Query match score
+    if (query) {
+      const queryLower = query.toLowerCase();
+      const content = (m.content + ' ' + (m.summary || '')).toLowerCase();
+      if (content.includes(queryLower)) {
+        score += 5;
+      }
+      // Check for word matches
+      const queryWords = queryLower.split(/\s+/);
+      for (const word of queryWords) {
+        if (word.length > 2 && content.includes(word)) {
+          score += 1;
+        }
+      }
+    }
+
+    // File match score
+    if (files.length > 0 && m.relatedFiles.length > 0) {
+      for (const file of files) {
+        if (m.relatedFiles.some(rf => rf.includes(file) || file.includes(rf))) {
+          score += 3;
+        }
+      }
+    }
+
+    // Tag match score
+    if (query && m.tags.length > 0) {
+      for (const tag of m.tags) {
+        if (query.toLowerCase().includes(tag.toLowerCase())) {
+          score += 2;
+        }
+      }
+    }
+
+    return { ...m, _score: score };
+  });
+
+  // Sort by score and limit
+  allMemories.sort((a, b) => b._score - a._score);
+  allMemories = allMemories.slice(0, limit);
+
+  return allMemories;
+}
+
+/**
+ * Generate auto-memory context for AI consumption
+ */
+export async function generateAutoMemoryContext(options = {}, cwd = process.cwd()) {
+  const memories = await getRelevantMemories(options, cwd);
+
+  if (memories.length === 0) {
+    return null;
+  }
+
+  let context = '<auto-memories>\n';
+
+  // Group by type
+  const decisions = memories.filter(m => m.type === 'decision');
+  const patterns = memories.filter(m => m.type === 'pattern');
+  const others = memories.filter(m => !['decision', 'pattern'].includes(m.type));
+
+  if (decisions.length > 0) {
+    context += '## Prior Decisions\n';
+    for (const d of decisions) {
+      context += `- **${d.summary || 'Decision'}**: ${d.content}\n`;
+    }
+    context += '\n';
+  }
+
+  if (patterns.length > 0) {
+    context += '## Learned Patterns\n';
+    for (const p of patterns) {
+      context += `- ${p.content}\n`;
+    }
+    context += '\n';
+  }
+
+  if (others.length > 0) {
+    context += '## Relevant Context\n';
+    for (const m of others) {
+      context += `- ${m.content}\n`;
+    }
+    context += '\n';
+  }
+
+  context += '</auto-memories>';
+
+  return context;
+}
+
+/**
+ * Start a new session (for tracking current work)
+ */
+export async function startSession(options = {}, cwd = process.cwd()) {
+  await initAutoMemory(cwd);
+
+  const session = {
+    id: `session_${Date.now().toString(36)}`,
+    startedAt: new Date().toISOString(),
+    task: options.task || null,
+    filesModified: [],
+    decisions: [],
+    memories: [],
+    status: 'active'
+  };
+
+  const sessionPath = getCurrentSessionPath(cwd);
+  await fs.writeJson(sessionPath, session, { spaces: 2 });
+
+  return session;
+}
+
+/**
+ * Get current session
+ */
+export async function getCurrentSession(cwd = process.cwd()) {
+  const sessionPath = getCurrentSessionPath(cwd);
+
+  if (!(await fs.pathExists(sessionPath))) {
+    return null;
+  }
+
+  return await fs.readJson(sessionPath);
+}
+
+/**
+ * Update current session
+ */
+export async function updateSession(updates, cwd = process.cwd()) {
+  let session = await getCurrentSession(cwd);
+
+  if (!session) {
+    session = await startSession({}, cwd);
+  }
+
+  // Merge updates
+  if (updates.task) session.task = updates.task;
+  if (updates.fileModified) {
+    if (!session.filesModified.includes(updates.fileModified)) {
+      session.filesModified.push(updates.fileModified);
+    }
+  }
+  if (updates.decision) {
+    session.decisions.push({
+      content: updates.decision,
+      timestamp: new Date().toISOString()
+    });
+  }
+  if (updates.memory) {
+    session.memories.push({
+      content: updates.memory,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  session.lastUpdatedAt = new Date().toISOString();
+
+  const sessionPath = getCurrentSessionPath(cwd);
+  await fs.writeJson(sessionPath, session, { spaces: 2 });
+
+  return session;
+}
+
+/**
+ * End session and save memories
+ */
+export async function endSession(options = {}, cwd = process.cwd()) {
+  const session = await getCurrentSession(cwd);
+
+  if (!session) {
+    return null;
+  }
+
+  // Save important decisions as permanent memories
+  for (const decision of session.decisions) {
+    await autoSaveMemory({
+      type: 'decision',
+      content: decision.content,
+      relatedFiles: session.filesModified,
+      importance: 'high',
+      source: 'session'
+    }, cwd);
+  }
+
+  // Save session memories
+  for (const memory of session.memories) {
+    await autoSaveMemory({
+      type: 'context',
+      content: memory.content,
+      relatedFiles: session.filesModified,
+      importance: 'normal',
+      source: 'session'
+    }, cwd);
+  }
+
+  // Mark session as complete
+  session.status = 'completed';
+  session.endedAt = new Date().toISOString();
+  session.summary = options.summary || null;
+
+  // Archive session
+  const archivePath = path.join(getAutoMemoryDir(cwd), `sessions/${session.id}.json`);
+  await fs.ensureDir(path.dirname(archivePath));
+  await fs.writeJson(archivePath, session, { spaces: 2 });
+
+  // Clear current session
+  const sessionPath = getCurrentSessionPath(cwd);
+  await fs.remove(sessionPath);
+
+  return session;
+}
+
+/**
+ * Quick memory save (for inline use)
+ * Usage: await remember("User prefers tabs over spaces", { type: 'pattern' })
+ */
+export async function remember(content, options = {}, cwd = process.cwd()) {
+  return await autoSaveMemory({
+    content,
+    type: options.type || 'context',
+    summary: options.summary,
+    importance: options.importance || 'normal',
+    tags: options.tags || [],
+    relatedFiles: options.files || [],
+    source: options.source || 'user'
+  }, cwd);
+}
+
+/**
+ * Recall memories (for inline use)
+ * Usage: const memories = await recall("authentication")
+ */
+export async function recall(query, options = {}, cwd = process.cwd()) {
+  return await getRelevantMemories({
+    query,
+    limit: options.limit || 5,
+    types: options.types,
+    minImportance: options.minImportance
+  }, cwd);
+}

package/src/indexer.js

@@ -791,3 +791,154 @@ export async function getIndexStats(cwd = process.cwd()) {
     indexAge: Date.now() - new Date(meta.updatedAt).getTime()
   };
 }
+
+/**
+ * Incremental index update - only process changed files
+ */
+export async function updateIndexIncremental(changedFiles, cwd = process.cwd(), options = {}) {
+  const { onProgress = () => {} } = options;
+
+  const indexDir = getIndexDir(cwd);
+  const summariesDir = path.join(indexDir, SUMMARIES_DIR);
+
+  // Load existing index data
+  const filesPath = path.join(indexDir, FILES_FILE);
+  const symbolsPath = path.join(indexDir, SYMBOLS_FILE);
+  const importsPath = path.join(indexDir, IMPORTS_FILE);
+
+  if (!(await fs.pathExists(filesPath))) {
+    // No existing index, do full build
+    return await buildIndex(cwd, options);
+  }
+
+  let filesIndex = await fs.readJson(filesPath);
+  let allSymbols = await fs.readJson(symbolsPath);
+  let allImports = await fs.readJson(importsPath);
+
+  onProgress({ phase: 'incremental', message: `Processing ${changedFiles.length} changed files...` });
+
+  let processed = 0;
+
+  for (const change of changedFiles) {
+    const { path: filePath, fullPath, type } = change;
+
+    if (type === 'delete' || type === 'rename') {
+      // Remove from index
+      filesIndex = filesIndex.filter(f => f.path !== filePath);
+      delete allSymbols[filePath];
+      delete allImports[filePath];
+
+      // Remove summary
+      const summaryPath = path.join(summariesDir, filePath.replace(/\//g, '_').replace(/\\/g, '_') + '.md');
+      if (await fs.pathExists(summaryPath)) {
+        await fs.remove(summaryPath);
+      }
+    } else {
+      // Add or update file
+      try {
+        const resolvedPath = fullPath || path.join(cwd, filePath);
+
+        if (!(await fs.pathExists(resolvedPath))) {
+          // File was deleted
+          filesIndex = filesIndex.filter(f => f.path !== filePath);
+          delete allSymbols[filePath];
+          delete allImports[filePath];
+          continue;
+        }
+
+        const content = await fs.readFile(resolvedPath, 'utf-8');
+        const stats = await fs.stat(resolvedPath);
+        const hash = crypto.createHash('md5').update(content).digest('hex');
+
+        // Extract symbols and imports
+        const symbols = extractSymbols(content, filePath);
+        const imports = extractImports(content, filePath);
+
+        // Update file entry
+        const existingIdx = filesIndex.findIndex(f => f.path === filePath);
+        const fileEntry = {
+          path: filePath,
+          size: stats.size,
+          hash,
+          mtime: stats.mtime.toISOString(),
+          lines: content.split('\n').length,
+          hasSymbols: symbols.functions.length > 0 || symbols.classes.length > 0
+        };
+
+        if (existingIdx >= 0) {
+          filesIndex[existingIdx] = fileEntry;
+        } else {
+          filesIndex.push(fileEntry);
+        }
+
+        // Update symbols and imports
+        if (symbols.functions.length > 0 || symbols.classes.length > 0 || symbols.types.length > 0) {
+          allSymbols[filePath] = symbols;
+        } else {
+          delete allSymbols[filePath];
+        }
+
+        if (imports.length > 0) {
+          allImports[filePath] = imports;
+        } else {
+          delete allImports[filePath];
+        }
+
+        // Update summary
+        const summary = generateFileSummary(filePath, content, symbols, imports);
+        const summaryPath = path.join(summariesDir, filePath.replace(/\//g, '_').replace(/\\/g, '_') + '.md');
+        await fs.writeFile(summaryPath, summary);
+
+      } catch (err) {
+        // Skip files that can't be read
+        console.error(`Skipping ${filePath}: ${err.message}`);
+      }
+    }
+
+    processed++;
+    onProgress({
+      phase: 'incremental',
+      message: `Processed ${processed}/${changedFiles.length}`,
+      current: processed,
+      total: changedFiles.length
+    });
+  }
+
+  // Re-detect patterns
+  onProgress({ phase: 'analyzing', message: 'Analyzing patterns...' });
+  const patterns = detectPatterns(filesIndex);
+
+  // Update meta
+  const meta = {
+    version: '1.0.0',
+    createdAt: (await getIndexMeta(cwd))?.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    stats: {
+      totalFiles: filesIndex.length,
+      totalLines: filesIndex.reduce((sum, f) => sum + f.lines, 0),
+      filesWithSymbols: Object.keys(allSymbols).length,
+      totalFunctions: Object.values(allSymbols).reduce((sum, s) => sum + s.functions.length, 0),
+      totalClasses: Object.values(allSymbols).reduce((sum, s) => sum + s.classes.length, 0)
+    },
+    patterns,
+    lastIncrementalUpdate: {
+      timestamp: new Date().toISOString(),
+      filesProcessed: changedFiles.length
+    }
+  };
+
+  // Save updated index
+  onProgress({ phase: 'saving', message: 'Saving index...' });
+  await fs.writeJson(path.join(indexDir, META_FILE), meta, { spaces: 2 });
+  await fs.writeJson(filesPath, filesIndex, { spaces: 2 });
+  await fs.writeJson(symbolsPath, allSymbols, { spaces: 2 });
+  await fs.writeJson(importsPath, allImports, { spaces: 2 });
+  await fs.writeJson(path.join(indexDir, PATTERNS_FILE), patterns, { spaces: 2 });
+
+  onProgress({
+    phase: 'complete',
+    message: `Incremental update complete: ${changedFiles.length} files processed`
+  });
+
+  return meta;
+}