memorylink 1.0.0

package/src/commands/setup.ts

@@ -0,0 +1,430 @@
+/**
+ * Setup Commands
+ * 
+ * AI-specific setup for Cursor, Claude, ChatGPT, etc.
+ * Creates configuration files that teach AI tools to use MemoryLink
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  findRoot,
+  isInitialized,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  getFilePath,
+  readJsonlEntries,
+  isJsonlFormat,
+} from '../utils.js';
+import type { GlobalOptions, MemoryEntry } from '../types.js';
+
+// ===========================================
+// CURSOR SETUP
+// ===========================================
+
+const CURSOR_RULES = `# MemoryLink Integration for Cursor AI
+
+## Before Making ANY Changes
+
+1. **Read Protected Files**: Check \`.memorylink/protected.txt\` - DO NOT modify these files.
+2. **Read Project Context**: Check \`.memorylink/memory.log\` for project decisions and context.
+3. **Check Past Solutions**: Review \`.memorylink/learnings.log\` before solving problems.
+   - Entries marked SUCCESS = use these approaches
+   - Entries marked FAILED = DO NOT repeat these
+
+## After Making Changes
+
+1. **Log Changes**: Record what you changed and why
+2. **Log Learnings**: If you solved a problem, note whether it worked (SUCCESS/FAILED)
+
+## File Locations
+
+\`\`\`
+.memorylink/
+├── protected.txt    # Files I cannot modify
+├── memory.log       # Project context and decisions
+├── changes.log      # Audit trail of all changes
+└── learnings.log    # Past solutions (SUCCESS/FAILED)
+\`\`\`
+
+## Example Workflow
+
+Before editing \`api.ts\`:
+1. Check if \`api.ts\` is in protected.txt → If yes, ask permission first
+2. Read memory.log for API-related context
+3. Check learnings.log for past API solutions
+
+After fixing a bug:
+1. Note the change in changes.log
+2. If the fix worked, add to learnings.log with SUCCESS
+3. If the fix failed, add to learnings.log with FAILED
+
+## Important Rules
+
+- NEVER edit files listed in protected.txt without explicit permission
+- ALWAYS check learnings.log before suggesting solutions to avoid repeating failures
+- Keep memory.log updated with important decisions
+
+## MemoryLink-First Workflow (Optimize Document Creation)
+
+### Before Creating Documents:
+1. **Check MemoryLink First:** Use \`memorylink get-context\` instead of creating planning docs
+2. **Use MemoryLink for State:** Store decisions in memory.log, not in separate docs
+3. **Log Learnings:** Use learnings.log instead of creating "what worked" docs
+
+### When to Create Documents:
+- **User-Requested:** Only if user explicitly asks for a document
+- **External Sharing:** Documents for humans (README, guides, etc.)
+- **Complex Analysis:** Multi-step analysis that needs structure
+
+### When to Use MemoryLink:
+- **Project Decisions:** Use memory.log (not decision docs)
+- **What Worked/Failed:** Use learnings.log (not summary docs)
+- **Change Tracking:** Use changes.log (not change logs)
+- **Context for Next Session:** Use get-context command (not reading old docs)
+
+### Document Creation Guidelines:
+- **Avoid:** Creating "planning" documents (use MemoryLink memory.log)
+- **Avoid:** Creating "summary" documents (use MemoryLink learnings.log)
+- **Avoid:** Creating "state" documents (use MemoryLink get-context)
+- **Create:** Only user-facing documentation (README, guides, troubleshooting)
+
+### Workflow Optimization:
+1. **Start Session:** Run \`memorylink get-context\` (don't read old planning docs)
+2. **During Work:** Log to MemoryLink (don't create summary docs)
+3. **End Session:** MemoryLink remembers (no need for summary doc)
+4. **Next Session:** MemoryLink provides context (no need to read old docs)
+
+### Why This Matters:
+- **Document Creation = Memory Workaround:** Creating docs because you lack memory
+- **MemoryLink = Solution:** Use MemoryLink instead of creating redundant docs
+- **Efficiency:** Reduces document proliferation and redundant reading
+`;
+
+export async function setupCursorCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+  
+  log('Setting up MemoryLink for Cursor', verbose);
+  
+  const root = findRoot() || process.cwd();
+  
+  if (!isInitialized(root)) {
+    error('MemoryLink not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+  
+  // Get active rules/preferences from memory.log (Qwen's Hello World requirement)
+  const memoryPath = getFilePath('MEMORY', root);
+  let activeRules: MemoryEntry[] = [];
+  
+  if (fs.existsSync(memoryPath) && isJsonlFormat(memoryPath)) {
+    const entries = readJsonlEntries<MemoryEntry>(memoryPath);
+    activeRules = entries.filter(e => 
+      e.status === 'ACTIVE' && 
+      (e.type === 'rule' || e.type === 'preference')
+    );
+  }
+  
+  // Generate active rules section
+  let activeRulesSection = '';
+  if (activeRules.length > 0) {
+    activeRulesSection = '## 🚨 ACTIVE RULES & PREFERENCES (OVERRIDE DEFAULT BEHAVIOR)\n\n';
+    activeRulesSection += '**These rules MUST be followed. They override default assistant behavior.**\n\n';
+    activeRules.forEach((rule, index) => {
+      const tagsStr = rule.tags?.length ? ` [${rule.tags.join(', ')}]` : '';
+      activeRulesSection += `${index + 1}. **${rule.type.toUpperCase()}**: ${rule.details}${tagsStr}\n`;
+    });
+    activeRulesSection += '\n---\n\n';
+    if (verbose) {
+      info(`Found ${activeRules.length} active rule(s)/preference(s) to inject`);
+    }
+  }
+  
+  const cursorrules = path.join(root, '.cursorrules');
+  
+  // Check if .cursorrules exists
+  if (fs.existsSync(cursorrules)) {
+    const existing = fs.readFileSync(cursorrules, 'utf-8');
+    
+    // Check if already has MemoryLink
+    if (existing.includes('MemoryLink')) {
+      warn('.cursorrules already contains MemoryLink configuration');
+      info('Run `memorylink sync-rules` to update with latest rules/preferences');
+      return;
+    }
+    
+    // Append to existing with active rules at the top
+    const updated = activeRulesSection + existing + '\n\n' + CURSOR_RULES;
+    fs.writeFileSync(cursorrules, updated);
+    success('Added MemoryLink rules to existing .cursorrules');
+    if (activeRules.length > 0) {
+      info(`Injected ${activeRules.length} active rule(s)/preference(s) at the top`);
+    }
+  } else {
+    // Create new with active rules at the top
+    const content = activeRulesSection + CURSOR_RULES;
+    fs.writeFileSync(cursorrules, content);
+    success('Created .cursorrules with MemoryLink integration');
+    if (activeRules.length > 0) {
+      info(`Injected ${activeRules.length} active rule(s)/preference(s) at the top`);
+    }
+  }
+  
+  console.log('');
+  info('Cursor AI will now:');
+  console.log('  • See active rules/preferences at the top of .cursorrules');
+  console.log('  • Check protected.txt before editing files');
+  console.log('  • Read memory.log for project context');
+  console.log('  • Check learnings.log before solving problems');
+  console.log('');
+  if (activeRules.length > 0) {
+    info('✅ Hello World test ready: Active rules are now in .cursorrules');
+    info('   Cursor will see these rules automatically on next chat');
+  } else {
+    info('💡 Add rules with: memorylink memory "rule" --type rule');
+    info('   Then run: memorylink sync-rules (or setup cursor again)');
+  }
+  console.log('');
+}
+
+// ===========================================
+// CLAUDE SETUP
+// ===========================================
+
+const CLAUDE_INSTRUCTIONS = `# MemoryLink Project Context
+
+## How to Use This Project
+
+This project uses MemoryLink for AI memory management. Before making any changes:
+
+### 1. Check Protected Files
+Read \`.memorylink/protected.txt\` - these files should NOT be modified without explicit permission.
+
+### 2. Read Project Context  
+Check \`.memorylink/memory.log\` for important decisions and context about this project.
+
+### 3. Learn from Past Solutions
+Review \`.memorylink/learnings.log\`:
+- SUCCESS entries = approaches that worked
+- FAILED entries = approaches that did NOT work - do not repeat these
+
+### 4. After Making Changes
+- Log significant changes to \`.memorylink/changes.log\`
+- Log problem solutions to \`.memorylink/learnings.log\` with SUCCESS or FAILED
+
+## Quick Reference
+
+\`\`\`
+.memorylink/protected.txt  → Files I cannot edit
+.memorylink/memory.log     → Project context
+.memorylink/learnings.log  → What worked/didn't work
+.memorylink/changes.log    → Audit trail
+\`\`\`
+
+## Rules
+1. NEVER edit protected files
+2. Check learnings BEFORE suggesting solutions
+3. Ask if unsure about a file's protection status
+`;
+
+export async function setupClaudeCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+  
+  log('Setting up MemoryLink for Claude', verbose);
+  
+  const root = findRoot() || process.cwd();
+  
+  if (!isInitialized(root)) {
+    error('MemoryLink not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+  
+  const claudeFile = path.join(root, 'CLAUDE_INSTRUCTIONS.md');
+  
+  if (fs.existsSync(claudeFile)) {
+    warn('CLAUDE_INSTRUCTIONS.md already exists');
+    info('Skipping to avoid overwrite. Delete it first if you want to regenerate.');
+    return;
+  }
+  
+  fs.writeFileSync(claudeFile, CLAUDE_INSTRUCTIONS);
+  success('Created CLAUDE_INSTRUCTIONS.md');
+  
+  console.log('');
+  info('To use with Claude:');
+  console.log('  1. Upload CLAUDE_INSTRUCTIONS.md at the start of your chat');
+  console.log('  2. Or paste its contents into your first message');
+  console.log('  3. Or add to Claude\'s custom instructions (Pro feature)');
+  console.log('');
+}
+
+// ===========================================
+// CHATGPT SETUP
+// ===========================================
+
+const CHATGPT_INSTRUCTIONS = `# MemoryLink Integration
+
+This project uses MemoryLink for AI memory management.
+
+## Before ANY code changes:
+
+1. **Protected Files**: Check .memorylink/protected.txt
+   - Files listed here should NOT be modified
+   - Ask permission before touching protected files
+
+2. **Project Context**: Read .memorylink/memory.log
+   - Contains project decisions and important context
+   - Use this information when making suggestions
+
+3. **Past Solutions**: Check .memorylink/learnings.log
+   - SUCCESS = this approach worked, use it
+   - FAILED = this approach did NOT work, avoid it
+
+## After making changes:
+
+- Note what changed and why
+- If you solved a problem, remember if it worked (SUCCESS) or not (FAILED)
+
+## File Structure:
+.memorylink/
+├── protected.txt    → DO NOT edit these files
+├── memory.log       → Project context
+├── changes.log      → What was changed
+└── learnings.log    → What worked/failed
+
+## Key Rules:
+1. Check protected.txt FIRST
+2. Never repeat FAILED solutions
+3. Use SUCCESS solutions as templates
+`;
+
+export async function setupChatGPTCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+  
+  log('Setting up MemoryLink for ChatGPT', verbose);
+  
+  const root = findRoot() || process.cwd();
+  
+  if (!isInitialized(root)) {
+    error('MemoryLink not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+  
+  const chatgptFile = path.join(root, 'CHATGPT_INSTRUCTIONS.md');
+  
+  if (fs.existsSync(chatgptFile)) {
+    warn('CHATGPT_INSTRUCTIONS.md already exists');
+    info('Skipping to avoid overwrite. Delete it first if you want to regenerate.');
+    return;
+  }
+  
+  fs.writeFileSync(chatgptFile, CHATGPT_INSTRUCTIONS);
+  success('Created CHATGPT_INSTRUCTIONS.md');
+  
+  console.log('');
+  info('To use with ChatGPT:');
+  console.log('  1. Upload CHATGPT_INSTRUCTIONS.md to your chat');
+  console.log('  2. ChatGPT will follow the MemoryLink rules');
+  console.log('  3. For ChatGPT Plus: Add to "Custom Instructions"');
+  console.log('');
+}
+
+// ===========================================
+// COPILOT SETUP
+// ===========================================
+
+const COPILOT_INSTRUCTIONS = `# MemoryLink Integration for GitHub Copilot
+
+## Project Memory System
+
+This project uses MemoryLink for cross-AI memory. Key files:
+
+- .memorylink/protected.txt - Files that should not be auto-completed/modified
+- .memorylink/memory.log - Project context and decisions
+- .memorylink/learnings.log - Past solutions (SUCCESS/FAILED)
+
+## For Copilot Users
+
+1. Before accepting suggestions for protected files, check protected.txt
+2. Use memory.log context when writing new code
+3. Check learnings.log when debugging similar issues
+
+## Integration Notes
+
+Copilot cannot directly read these files, but you can:
+1. Open .memorylink files in a split pane for reference
+2. Use comments to remind yourself of context
+3. Use memorylink CLI to check before major changes
+`;
+
+export async function setupCopilotCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+  
+  log('Setting up MemoryLink for Copilot', verbose);
+  
+  const root = findRoot() || process.cwd();
+  
+  if (!isInitialized(root)) {
+    error('MemoryLink not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+  
+  const copilotFile = path.join(root, '.github', 'copilot-instructions.md');
+  const githubDir = path.join(root, '.github');
+  
+  // Create .github directory if needed
+  if (!fs.existsSync(githubDir)) {
+    fs.mkdirSync(githubDir, { recursive: true });
+  }
+  
+  if (fs.existsSync(copilotFile)) {
+    warn('.github/copilot-instructions.md already exists');
+    info('Skipping to avoid overwrite. Delete it first if you want to regenerate.');
+    return;
+  }
+  
+  fs.writeFileSync(copilotFile, COPILOT_INSTRUCTIONS);
+  success('Created .github/copilot-instructions.md');
+  
+  console.log('');
+  info('Copilot will now see these instructions in your project.');
+  console.log('');
+}
+
+// ===========================================
+// SETUP ALL
+// ===========================================
+
+export async function setupAllCommand(options: GlobalOptions = {}): Promise<void> {
+  console.log('');
+  console.log('\x1b[36m╔══════════════════════════════════════════════════════════╗\x1b[0m');
+  console.log('\x1b[36m║                                                          ║\x1b[0m');
+  console.log('\x1b[36m║   🔧 Setting up MemoryLink for ALL AI tools              ║\x1b[0m');
+  console.log('\x1b[36m║                                                          ║\x1b[0m');
+  console.log('\x1b[36m╚══════════════════════════════════════════════════════════╝\x1b[0m');
+  console.log('');
+  
+  console.log('\x1b[1m[1/4] Cursor AI\x1b[0m');
+  await setupCursorCommand({ ...options, verbose: false });
+  
+  console.log('\x1b[1m[2/4] Claude\x1b[0m');
+  await setupClaudeCommand({ ...options, verbose: false });
+  
+  console.log('\x1b[1m[3/4] ChatGPT\x1b[0m');
+  await setupChatGPTCommand({ ...options, verbose: false });
+  
+  console.log('\x1b[1m[4/4] GitHub Copilot\x1b[0m');
+  await setupCopilotCommand({ ...options, verbose: false });
+  
+  console.log('');
+  console.log('\x1b[32m╔══════════════════════════════════════════════════════════╗\x1b[0m');
+  console.log('\x1b[32m║                                                          ║\x1b[0m');
+  console.log('\x1b[32m║   ✅ All AI tools configured!                            ║\x1b[0m');
+  console.log('\x1b[32m║                                                          ║\x1b[0m');
+  console.log('\x1b[32m╚══════════════════════════════════════════════════════════╝\x1b[0m');
+  console.log('');
+}
+

package/src/commands/snippet.ts

@@ -0,0 +1,271 @@
+/**
+ * MemoryLink - Code Snippet Command
+ * Store actual code snippets (not just file references)
+ * 
+ * Critical feature: Users need to store reusable code patterns and examples
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  getFilePath,
+  isInitialized,
+  getTimestamp,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  findRoot,
+  parseTags,
+  generateId,
+  appendJsonlEntry,
+  checkSecretsBeforeWrite,
+  normalizePathForStorage,
+} from '../utils.js';
+import type { 
+  GlobalOptions, 
+  MemoryEntry, 
+  MemoryType,
+} from '../types.js';
+import { checkMigrationRequired, showMigrationWarning } from './migrate.js';
+
+interface SnippetOptions extends GlobalOptions {
+  code?: string;
+  file?: string;
+  lines?: string;
+  language?: string;
+  context?: string;
+  tags?: string;
+  force?: boolean;
+}
+
+const MAX_SNIPPET_SIZE = 1024; // 1KB limit
+
+/**
+ * Detect programming language from file extension
+ */
+function detectLanguage(filePath: string): string | undefined {
+  const ext = path.extname(filePath).toLowerCase();
+  const languageMap: Record<string, string> = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.py': 'python',
+    '.java': 'java',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.cpp': 'cpp',
+    '.c': 'c',
+    '.cs': 'csharp',
+    '.php': 'php',
+    '.rb': 'ruby',
+    '.swift': 'swift',
+    '.kt': 'kotlin',
+    '.scala': 'scala',
+    '.sh': 'bash',
+    '.bash': 'bash',
+    '.zsh': 'bash',
+    '.sql': 'sql',
+    '.html': 'html',
+    '.css': 'css',
+    '.scss': 'scss',
+    '.json': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.xml': 'xml',
+    '.md': 'markdown',
+    '.vue': 'vue',
+    '.svelte': 'svelte',
+  };
+  return languageMap[ext];
+}
+
+/**
+ * Read code from file, optionally extracting specific lines
+ */
+function readCodeFromFile(
+  filePath: string,
+  root: string,
+  lineRange?: string
+): { code: string; language?: string } {
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(root, filePath);
+  
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const stats = fs.statSync(fullPath);
+  if (stats.size > 10 * 1024 * 1024) { // 10MB limit
+    throw new Error(`File too large (${Math.round(stats.size / 1024)}KB). Use doc_ref for large files.`);
+  }
+
+  let content = fs.readFileSync(fullPath, 'utf-8');
+  const language = detectLanguage(filePath);
+
+  // Extract specific lines if requested
+  if (lineRange) {
+    const lines = content.split('\n');
+    const match = lineRange.match(/^(\d+)(?:-(\d+))?$/);
+    
+    if (!match) {
+      throw new Error(`Invalid line range format. Use: '42' or '42-50'`);
+    }
+
+    const start = parseInt(match[1], 10) - 1; // Convert to 0-based
+    const end = match[2] ? parseInt(match[2], 10) : start + 1; // End is 1-based
+    
+    if (start < 0 || start >= lines.length) {
+      throw new Error(`Line ${start + 1} is out of range (file has ${lines.length} lines)`);
+    }
+    if (end < start || end > lines.length) {
+      throw new Error(`Line range ${start + 1}-${end} is invalid (file has ${lines.length} lines)`);
+    }
+
+    content = lines.slice(start, end).join('\n');
+  }
+
+  return { code: content, language };
+}
+
+/**
+ * Validate code snippet size
+ */
+function validateCodeSize(code: string): void {
+  const size = Buffer.byteLength(code, 'utf-8');
+  if (size > MAX_SNIPPET_SIZE) {
+    throw new Error(
+      `Code snippet too large (${Math.round(size / 1024 * 100) / 100}KB, max ${MAX_SNIPPET_SIZE / 1024}KB). ` +
+      `Use doc_ref for larger files or split into multiple snippets.`
+    );
+  }
+}
+
+/**
+ * Code Snippet Command
+ * Store code snippets in memory.log
+ */
+export async function snippetCommand(
+  description: string,
+  options: SnippetOptions = {}
+): Promise<void> {
+  const { 
+    verbose, 
+    code, 
+    file, 
+    lines, 
+    language, 
+    context, 
+    tags: tagString,
+    force = false 
+  } = options;
+
+  // Validate input
+  if (!description || description.trim().length === 0) {
+    error('Description cannot be empty');
+    process.exit(1);
+  }
+
+  log(`Adding code snippet: ${description}`, verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Check if migration is required
+  if (checkMigrationRequired(root)) {
+    showMigrationWarning();
+    process.exit(1);
+  }
+
+  // Get code content
+  let codeContent: string;
+  let detectedLanguage: string | undefined = language;
+
+  if (code) {
+    // Code provided directly
+    codeContent = code;
+  } else if (file) {
+    // Read from file
+    try {
+      const result = readCodeFromFile(file, root, lines);
+      codeContent = result.code;
+      if (!detectedLanguage && result.language) {
+        detectedLanguage = result.language;
+      }
+    } catch (err: any) {
+      error(`Failed to read file: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    error('Code required. Use --code "<code>" or --file <path>');
+    process.exit(1);
+  }
+
+  // Validate code is not empty
+  if (!codeContent || codeContent.trim().length === 0) {
+    error('Code cannot be empty');
+    process.exit(1);
+  }
+
+  // Validate code size
+  try {
+    validateCodeSize(codeContent);
+  } catch (err: any) {
+    error(err.message);
+    process.exit(1);
+  }
+
+  // Secret detection
+  const contentToCheck = description + ' ' + codeContent;
+  if (!checkSecretsBeforeWrite(contentToCheck, force)) {
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+  const tags = parseTags(tagString);
+
+  // Normalize file path for storage (forward slashes, Git-compatible)
+  const normalizedFile = file ? normalizePathForStorage(file, root) : undefined;
+
+  // Create code snippet entry
+  const entry: MemoryEntry = {
+    id: generateId(),
+    ts: getTimestamp(),
+    agent: 'user',
+    type: 'code_snippet' as MemoryType,
+    details: description,
+    code: codeContent,
+    language: detectedLanguage,
+    file: normalizedFile,
+    lines: lines,
+    context: context,
+    tags,
+    status: 'ACTIVE',
+    forcedSecretCheck: force && checkSecretsBeforeWrite(contentToCheck, true) ? true : undefined,
+  };
+
+  // Append with file locking
+  try {
+    await appendJsonlEntry(memoryPath, entry);
+    success(`Code snippet added (${Math.round(Buffer.byteLength(codeContent, 'utf-8'))} bytes)`);
+    
+    if (verbose) {
+      info(`Language: ${detectedLanguage || 'auto-detected'}`);
+      if (file) {
+        info(`File: ${file}${lines ? ` (lines ${lines})` : ''}`);
+      }
+      if (context) {
+        info(`Context: ${context}`);
+      }
+    }
+  } catch (err: any) {
+    error(`Failed to add code snippet: ${err.message}`);
+    process.exit(1);
+  }
+}
+