namnam-skills 1.0.0 → 1.0.2

package/src/conversation.js

@@ -0,0 +1,914 @@
+/**
+ * Conversation Management Utilities
+ *
+ * Handles saving, loading, and managing conversation context
+ * for the @conversation feature
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+
+// Default conversation directory
+const CONV_DIR_NAME = 'conversations';
+const INDEX_FILE = 'index.json';
+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
+ */
+function validateConversationOptions(options) {
+  const errors = [];
+
+  if (options.title !== undefined && typeof options.title !== 'string') {
+    errors.push('title must be a string');
+  }
+
+  if (options.summary !== undefined && typeof options.summary !== 'string') {
+    errors.push('summary must be a string');
+  }
+
+  if (options.context !== undefined && typeof options.context !== 'string') {
+    errors.push('context must be a string');
+  }
+
+  if (options.fullLog !== undefined && typeof options.fullLog !== 'string') {
+    errors.push('fullLog must be a string');
+  }
+
+  if (options.tags !== undefined && !Array.isArray(options.tags)) {
+    errors.push('tags must be an array');
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid conversation options: ${errors.join(', ')}`);
+  }
+}
+
+/**
+ * Escape XML special characters
+ */
+function escapeXml(str) {
+  if (!str) return '';
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Get the conversations directory path
+ */
+export function getConversationsDir(cwd = process.cwd()) {
+  return path.join(cwd, '.claude', CONV_DIR_NAME);
+}
+
+/**
+ * Get the index file path
+ */
+export function getIndexPath(cwd = process.cwd()) {
+  return path.join(getConversationsDir(cwd), INDEX_FILE);
+}
+
+/**
+ * Generate a unique conversation ID
+ */
+export function generateConvId() {
+  const timestamp = Date.now().toString(36);
+  const random = crypto.randomBytes(3).toString('hex');
+  return `conv_${timestamp}_${random}`;
+}
+
+/**
+ * Generate a short ID for easy reference
+ */
+export function generateShortId() {
+  return crypto.randomBytes(4).toString('hex');
+}
+
+/**
+ * Initialize conversations directory
+ */
+export async function initConversations(cwd = process.cwd()) {
+  const convDir = getConversationsDir(cwd);
+  const indexPath = getIndexPath(cwd);
+
+  await fs.ensureDir(convDir);
+
+  if (!(await fs.pathExists(indexPath))) {
+    await fs.writeJson(indexPath, {
+      version: '1.0.0',
+      conversations: [],
+      lastUpdated: new Date().toISOString()
+    }, { spaces: 2 });
+  }
+
+  return convDir;
+}
+
+/**
+ * Load the conversation index
+ */
+export async function loadIndex(cwd = process.cwd()) {
+  const indexPath = getIndexPath(cwd);
+
+  if (!(await fs.pathExists(indexPath))) {
+    return { version: '1.0.0', conversations: [], lastUpdated: null };
+  }
+
+  return await fs.readJson(indexPath);
+}
+
+/**
+ * Save the conversation index
+ */
+export async function saveIndex(index, cwd = process.cwd()) {
+  const indexPath = getIndexPath(cwd);
+  index.lastUpdated = new Date().toISOString();
+  await fs.writeJson(indexPath, index, { spaces: 2 });
+}
+
+/**
+ * Save a new conversation
+ */
+export async function saveConversation(options, cwd = process.cwd()) {
+  validateConversationOptions(options);
+
+  const {
+    title,
+    summary,
+    context,
+    fullLog = null,
+    tags = [],
+    metadata = {}
+  } = options;
+
+  await initConversations(cwd);
+
+  const id = generateConvId();
+  const shortId = generateShortId();
+  const convDir = path.join(getConversationsDir(cwd), id);
+
+  await fs.ensureDir(convDir);
+
+  // Create metadata file
+  const meta = {
+    id,
+    shortId,
+    title: title || 'Untitled Conversation',
+    summary: summary || '',
+    tags,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...metadata
+  };
+
+  await fs.writeJson(path.join(convDir, META_FILE), meta, { spaces: 2 });
+
+  // Create context file (loadable summary)
+  if (context) {
+    await fs.writeFile(path.join(convDir, CONTEXT_FILE), context);
+  }
+
+  // Create full log if provided
+  if (fullLog) {
+    await fs.writeFile(path.join(convDir, FULL_LOG_FILE), fullLog);
+  }
+
+  // Update index
+  const index = await loadIndex(cwd);
+  index.conversations.push({
+    id,
+    shortId,
+    title: meta.title,
+    summary: meta.summary,
+    tags,
+    createdAt: meta.createdAt
+  });
+  await saveIndex(index, cwd);
+
+  return { id, shortId, path: convDir };
+}
+
+/**
+ * Get a conversation by ID (full or short)
+ */
+export async function getConversation(convId, cwd = process.cwd()) {
+  const index = await loadIndex(cwd);
+
+  // Find by full ID or short ID
+  const entry = index.conversations.find(
+    c => c.id === convId || c.shortId === convId || c.id.includes(convId)
+  );
+
+  if (!entry) {
+    return null;
+  }
+
+  const convDir = path.join(getConversationsDir(cwd), entry.id);
+
+  if (!(await fs.pathExists(convDir))) {
+    return null;
+  }
+
+  const meta = await fs.readJson(path.join(convDir, META_FILE));
+
+  let context = null;
+  let fullLog = null;
+
+  const contextPath = path.join(convDir, CONTEXT_FILE);
+  const fullPath = path.join(convDir, FULL_LOG_FILE);
+
+  if (await fs.pathExists(contextPath)) {
+    context = await fs.readFile(contextPath, 'utf-8');
+  }
+
+  if (await fs.pathExists(fullPath)) {
+    fullLog = await fs.readFile(fullPath, 'utf-8');
+  }
+
+  return { ...meta, context, fullLog };
+}
+
+/**
+ * List all conversations
+ */
+export async function listConversations(options = {}, cwd = process.cwd()) {
+  const { limit = 20, tag = null, search = null } = options;
+  const index = await loadIndex(cwd);
+
+  let conversations = index.conversations || [];
+
+  // Filter by tag
+  if (tag) {
+    conversations = conversations.filter(c =>
+      c.tags && c.tags.includes(tag)
+    );
+  }
+
+  // Filter by search term
+  if (search) {
+    const term = search.toLowerCase();
+    conversations = conversations.filter(c =>
+      c.title.toLowerCase().includes(term) ||
+      c.summary.toLowerCase().includes(term) ||
+      c.id.includes(term) ||
+      c.shortId.includes(term)
+    );
+  }
+
+  // Sort by date (newest first)
+  conversations.sort((a, b) =>
+    new Date(b.createdAt) - new Date(a.createdAt)
+  );
+
+  // Limit results
+  if (limit > 0) {
+    conversations = conversations.slice(0, limit);
+  }
+
+  return conversations;
+}
+
+/**
+ * Update a conversation
+ */
+export async function updateConversation(convId, updates, cwd = process.cwd()) {
+  validateConversationOptions(updates);
+
+  const conversation = await getConversation(convId, cwd);
+
+  if (!conversation) {
+    return null;
+  }
+
+  const convDir = path.join(getConversationsDir(cwd), conversation.id);
+
+  // Store context and fullLog before processing
+  const newContext = updates.context;
+  const newFullLog = updates.fullLog;
+
+  // Prepare metadata updates (exclude file content fields)
+  const metaUpdates = { ...updates };
+  delete metaUpdates.id;
+  delete metaUpdates.context;
+  delete metaUpdates.fullLog;
+
+  // Update metadata
+  const meta = await fs.readJson(path.join(convDir, META_FILE));
+  const updatedMeta = {
+    ...meta,
+    ...metaUpdates,
+    updatedAt: new Date().toISOString()
+  };
+
+  await fs.writeJson(path.join(convDir, META_FILE), updatedMeta, { spaces: 2 });
+
+  // Update context if provided
+  if (newContext !== undefined) {
+    await fs.writeFile(path.join(convDir, CONTEXT_FILE), newContext);
+  }
+
+  // Update full log if provided
+  if (newFullLog !== undefined) {
+    await fs.writeFile(path.join(convDir, FULL_LOG_FILE), newFullLog);
+  }
+
+  // Update index
+  const index = await loadIndex(cwd);
+  const idx = index.conversations.findIndex(c => c.id === conversation.id);
+  if (idx !== -1) {
+    index.conversations[idx] = {
+      ...index.conversations[idx],
+      title: updatedMeta.title,
+      summary: updatedMeta.summary,
+      tags: updatedMeta.tags
+    };
+    await saveIndex(index, cwd);
+  }
+
+  return updatedMeta;
+}
+
+/**
+ * Delete a conversation
+ */
+export async function deleteConversation(convId, cwd = process.cwd()) {
+  const conversation = await getConversation(convId, cwd);
+
+  if (!conversation) {
+    return false;
+  }
+
+  const convDir = path.join(getConversationsDir(cwd), conversation.id);
+
+  // Remove directory
+  await fs.remove(convDir);
+
+  // Update index
+  const index = await loadIndex(cwd);
+  index.conversations = index.conversations.filter(c => c.id !== conversation.id);
+  await saveIndex(index, cwd);
+
+  return true;
+}
+
+/**
+ * Export conversation to a single markdown file
+ */
+export async function exportConversation(convId, outputPath, cwd = process.cwd()) {
+  const conversation = await getConversation(convId, cwd);
+
+  if (!conversation) {
+    return null;
+  }
+
+  const content = `# ${conversation.title}
+
+**ID:** ${conversation.shortId}
+**Created:** ${conversation.createdAt}
+**Tags:** ${conversation.tags?.join(', ') || 'none'}
+
+## Summary
+
+${conversation.summary || 'No summary available.'}
+
+## Context
+
+${conversation.context || 'No context available.'}
+
+${conversation.fullLog ? `## Full Log\n\n${conversation.fullLog}` : ''}
+`;
+
+  await fs.writeFile(outputPath, content);
+  return outputPath;
+}
+
+/**
+ * Get conversation context for AI consumption
+ * This is what gets loaded when @conversation:id is used
+ */
+export async function getConversationContext(convId, cwd = process.cwd()) {
+  const conversation = await getConversation(convId, cwd);
+
+  if (!conversation) {
+    return null;
+  }
+
+  const id = escapeXml(conversation.shortId);
+  const title = escapeXml(conversation.title);
+  const content = conversation.context || conversation.summary || 'No context available.';
+
+  return `
+<conversation-context id="${id}" title="${title}">
+${content}
+</conversation-context>
+`.trim();
+}
+
+/**
+ * Parse @conversation references from text
+ */
+export function parseConversationRefs(text) {
+  const pattern = /@conversation[:\s]+([a-zA-Z0-9_-]+)/gi;
+  const matches = [];
+  let match;
+
+  while ((match = pattern.exec(text)) !== null) {
+    matches.push(match[1]);
+  }
+
+  return [...new Set(matches)]; // Remove duplicates
+}
+
+/**
+ * Resolve all @conversation references in text
+ */
+export async function resolveConversationRefs(text, cwd = process.cwd()) {
+  const refs = parseConversationRefs(text);
+  const contexts = [];
+
+  for (const ref of refs) {
+    const context = await getConversationContext(ref, cwd);
+    if (context) {
+      contexts.push(context);
+    }
+  }
+
+  return {
+    refs,
+    contexts,
+    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);
+}