memorylink 1.0.0

package/src/commands/protect.ts

@@ -0,0 +1,199 @@
+/**
+ * MemoryLink - Protect/Unprotect Commands
+ * Manage protected files list
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  getFilePath,
+  isInitialized,
+  readLines,
+  getTimestamp,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  findRoot,
+  normalizePathForStorage,
+} from '../utils.js';
+import type { GlobalOptions } from '../types.js';
+
+export async function protectCommand(
+  file: string,
+  options: GlobalOptions & { reason?: string } = {}
+): Promise<void> {
+  const { verbose, reason } = options;
+
+  // Validate input - reject empty file path
+  if (!file || file.trim().length === 0) {
+    error('File path cannot be empty');
+    process.exit(1);
+  }
+
+  // Reject path traversal attempts
+  if (file.includes('..')) {
+    error('Path traversal not allowed. Use paths relative to project root.');
+    process.exit(1);
+  }
+
+  // Reject absolute paths
+  if (path.isAbsolute(file)) {
+    error('Absolute paths not allowed. Use paths relative to project root.');
+    process.exit(1);
+  }
+
+  log(`Protecting file: ${file}`, verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const protectedPath = getFilePath('PROTECTED', root);
+
+  // Read current protected files
+  const currentFiles = readLines(protectedPath).filter(line => !line.startsWith('#'));
+
+  // Normalize the path for storage (forward slashes, Git-compatible)
+  const normalizedPath = normalizePathForStorage(file, root);
+  
+  // Double check normalized path doesn't escape project
+  if (normalizedPath.startsWith('..') || normalizedPath === '.' || normalizedPath.includes('../')) {
+    error('Invalid file path');
+    process.exit(1);
+  }
+
+  // Check if already protected
+  if (currentFiles.includes(normalizedPath)) {
+    warn(`File is already protected: ${normalizedPath}`);
+    return;
+  }
+
+  // Add to protected list
+  const entry = reason
+    ? `${normalizedPath}  # ${reason} (added ${getTimestamp()})`
+    : `${normalizedPath}  # added ${getTimestamp()}`;
+
+  fs.appendFileSync(protectedPath, entry + '\n');
+
+  success(`Protected: ${normalizedPath}`);
+  if (verbose) {
+    info(`Added to: ${protectedPath}`);
+  }
+}
+
+export async function unprotectCommand(
+  file: string,
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log(`Unprotecting file: ${file}`, verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const protectedPath = getFilePath('PROTECTED', root);
+
+  // Read current content
+  const content = fs.readFileSync(protectedPath, 'utf-8');
+  const lines = content.split('\n');
+
+  // Normalize the path for storage (forward slashes, Git-compatible)
+  const normalizedPath = normalizePathForStorage(file, root);
+
+  // Filter out the file (matching the path part before any comment)
+  const newLines = lines.filter(line => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('#') || trimmed === '') return true;
+    const filePart = normalizePathForStorage(trimmed.split('#')[0].trim(), root);
+    return filePart !== normalizedPath;
+  });
+
+  // Check if anything was removed
+  if (newLines.length === lines.length) {
+    warn(`File is not in protected list: ${normalizedPath}`);
+    return;
+  }
+
+  // Write back
+  fs.writeFileSync(protectedPath, newLines.join('\n'));
+
+  success(`Unprotected: ${normalizedPath}`);
+  if (verbose) {
+    info(`Removed from: ${protectedPath}`);
+  }
+}
+
+export async function listProtectedCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Listing protected files', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const protectedPath = getFilePath('PROTECTED', root);
+  const lines = readLines(protectedPath).filter(line => !line.startsWith('#'));
+
+  if (lines.length === 0) {
+    info('No files are protected');
+    console.log('');
+    console.log('Add protected files with: memorylink protect <file>');
+    return;
+  }
+
+  console.log('');
+  info(`Protected files (${lines.length}):`);
+  console.log('');
+
+  for (const line of lines) {
+    const parts = line.split('#');
+    const filePath = parts[0].trim();
+    const comment = parts[1]?.trim();
+
+    // Check if file exists
+    const fullPath = path.join(root, filePath);
+    const exists = fs.existsSync(fullPath);
+    const status = exists ? '✓' : '?';
+    const statusColor = exists ? '\x1b[32m' : '\x1b[33m';
+
+    console.log(`   ${statusColor}${status}\x1b[0m ${filePath}`);
+    if (comment && verbose) {
+      console.log(`     \x1b[90m# ${comment}\x1b[0m`);
+    }
+  }
+
+  console.log('');
+}
+
+export function isFileProtected(file: string, root?: string): boolean {
+  const projectRoot = root || findRoot();
+  if (!projectRoot || !isInitialized(projectRoot)) {
+    return false;
+  }
+
+  const protectedPath = getFilePath('PROTECTED', projectRoot);
+  const lines = readLines(protectedPath).filter(line => !line.startsWith('#'));
+
+  const normalizedFile = normalizePathForStorage(file, projectRoot);
+
+  return lines.some(line => {
+    const filePart = normalizePathForStorage(line.split('#')[0].trim(), projectRoot);
+    // Compare normalized paths (both use forward slashes)
+    return filePart === normalizedFile || normalizedFile.startsWith(filePart + '/');
+  });
+}
+

package/src/commands/quickstart.ts

@@ -0,0 +1,259 @@
+/**
+ * MemoryLink - Quickstart Command
+ * One-command setup for reduced friction (Recommended by Qwen)
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  isInitialized,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  findRoot,
+} from '../utils.js';
+import type { GlobalOptions } from '../types.js';
+import { initCommand } from './init.js';
+import { protectCommand } from './protect.js';
+import { hooksInstallCommand } from './hooks.js';
+import { 
+  setupCursorCommand, 
+  setupClaudeCommand, 
+  setupChatGPTCommand, 
+  setupCopilotCommand,
+  setupAllCommand 
+} from './setup.js';
+import { memoryCommand } from './memory.js';
+import { learnCommand } from './learn.js';
+import { getContextCommand } from './context.js';
+import { getFilePath, readJsonlEntries, isJsonlFormat } from '../utils.js';
+import type { MemoryEntry, LearningEntry } from '../types.js';
+
+export interface QuickstartOptions extends GlobalOptions {
+  tool?: string;
+  skipHooks?: boolean;
+}
+
+export async function quickstartCommand(options: QuickstartOptions = {}): Promise<void> {
+  const { verbose, tool = 'cursor', skipHooks = false } = options;
+
+  console.log('');
+  console.log('\x1b[1m🚀 MemoryLink Quickstart\x1b[0m');
+  console.log('');
+  console.log('\x1b[1mWhat is MemoryLink?\x1b[0m');
+  console.log('\x1b[90mMemoryLink is a universal memory layer that lets your AI tools remember\x1b[0m');
+  console.log('\x1b[90mdecisions, learnings, and preferences across sessions and different AI tools.\x1b[0m');
+  console.log('\x1b[90mIt stores memory in simple text files that any AI can read and write.\x1b[0m');
+  console.log('');
+  console.log('\x1b[90mSetting up MemoryLink in one command...\x1b[0m');
+  console.log('');
+
+  const steps = [
+    { name: 'Initialize .memorylink/', action: 'init' },
+    { name: 'Protect .env files', action: 'protect' },
+    { name: 'Install Git hooks', action: 'hooks' },
+    { name: `Setup for ${tool}`, action: 'setup' },
+    { name: 'Hello World demo', action: 'demo' },
+  ];
+
+  let stepNum = 1;
+
+  // Step 1: Initialize
+  console.log(`\x1b[36m[${stepNum}/${steps.length}]\x1b[0m Initializing MemoryLink...`);
+  try {
+    await initCommand({ verbose });
+    success('Initialized .memorylink/');
+  } catch (e) {
+    // Already initialized is fine
+    info('.memorylink/ already exists');
+  }
+  stepNum++;
+
+  // Step 2: Protect common sensitive files
+  console.log(`\x1b[36m[${stepNum}/${steps.length}]\x1b[0m Protecting sensitive files...`);
+  const filesToProtect = ['.env', '.env.local', '.env.production', 'README.md'];
+  let protectedCount = 0;
+  
+  for (const file of filesToProtect) {
+    const filePath = path.join(process.cwd(), file);
+    if (fs.existsSync(filePath)) {
+      try {
+        await protectCommand(file, { verbose, reason: 'Auto-protected by quickstart' });
+        protectedCount++;
+      } catch {
+        // Already protected is fine
+      }
+    }
+  }
+  
+  if (protectedCount > 0) {
+    success(`Protected ${protectedCount} sensitive file(s)`);
+  } else {
+    info('No common sensitive files found to protect');
+  }
+  stepNum++;
+
+  // Step 3: Install Git hooks
+  if (!skipHooks) {
+    console.log(`\x1b[36m[${stepNum}/${steps.length}]\x1b[0m Installing Git hooks...`);
+    try {
+      await hooksInstallCommand({ verbose });
+      success('Git pre-commit hook installed');
+    } catch (e) {
+      warn('Could not install Git hooks (not a Git repo?)');
+    }
+  } else {
+    console.log(`\x1b[36m[${stepNum}/${steps.length}]\x1b[0m Skipping Git hooks (--skip-hooks)`);
+  }
+  stepNum++;
+
+  // Step 4: Setup for AI tool
+  console.log(`\x1b[36m[${stepNum}/${steps.length}]\x1b[0m Setting up for ${tool}...`);
+  try {
+    switch (tool.toLowerCase()) {
+      case 'cursor':
+        await setupCursorCommand({ verbose });
+        break;
+      case 'claude':
+        await setupClaudeCommand({ verbose });
+        break;
+      case 'chatgpt':
+        await setupChatGPTCommand({ verbose });
+        break;
+      case 'copilot':
+        await setupCopilotCommand({ verbose });
+        break;
+      case 'all':
+        await setupAllCommand({ verbose });
+        break;
+      default:
+        await setupCursorCommand({ verbose });
+    }
+    success(`Created configuration for ${tool}`);
+  } catch (e) {
+    warn(`Could not setup for ${tool}`);
+  }
+
+  // HELLO WORLD LOOP: Create sample entries and demonstrate the full memory loop
+  console.log('');
+  console.log('\x1b[36m[5/5]\x1b[0m Creating "Hello World" demo...');
+  
+  const root = findRoot();
+  if (root) {
+    const memoryPath = getFilePath('MEMORY', root);
+    const learningsPath = getFilePath('LEARNINGS', root);
+    
+    // Check if we already have entries (don't create duplicates)
+    let hasExistingMemory = false;
+    let hasExistingLearnings = false;
+    
+    if (fs.existsSync(memoryPath) && isJsonlFormat(memoryPath)) {
+      const existingMemories = readJsonlEntries<MemoryEntry>(memoryPath);
+      hasExistingMemory = existingMemories.length > 0;
+    }
+    
+    if (fs.existsSync(learningsPath) && isJsonlFormat(learningsPath)) {
+      const existingLearnings = readJsonlEntries<LearningEntry>(learningsPath);
+      hasExistingLearnings = existingLearnings.length > 0;
+    }
+    
+    // Create sample memory entry if none exists
+    if (!hasExistingMemory) {
+      try {
+        await memoryCommand(
+          'This project uses MemoryLink for AI memory management',
+          { 
+            verbose: false, 
+            tags: 'demo,quickstart',
+            type: 'note'
+          }
+        );
+        info('Created sample memory entry');
+      } catch (e) {
+        // Ignore errors (might already exist)
+      }
+    }
+    
+    // Create sample learning entry if none exists
+    if (!hasExistingLearnings) {
+      try {
+        await learnCommand(
+          'MemoryLink setup',
+          'Successfully initialized MemoryLink and configured AI integration',
+          { 
+            verbose: false, 
+            status: 'SUCCESS',
+            tags: 'demo,quickstart'
+          }
+        );
+        info('Created sample learning entry');
+      } catch (e) {
+        // Ignore errors (might already exist)
+      }
+    }
+    
+    // Show get-context output
+    console.log('');
+    console.log('\x1b[1m📋 Sample Context Output:\x1b[0m');
+    console.log('\x1b[90m─────────────────────────────────────────────────────────────\x1b[0m');
+    try {
+      await getContextCommand(undefined, { verbose: false, limit: 5 });
+    } catch (e) {
+      // Ignore errors
+    }
+    console.log('\x1b[90m─────────────────────────────────────────────────────────────\x1b[0m');
+  }
+
+  // Final summary with Agent Contract
+  console.log('');
+  console.log('\x1b[32m\x1b[1m✓ MemoryLink is ready!\x1b[0m');
+  console.log('');
+  console.log('\x1b[1m📋 AGENT CONTRACT (Copy this to your AI tool):\x1b[0m');
+  console.log('');
+  console.log('\x1b[90m─────────────────────────────────────────────────────────────\x1b[0m');
+  console.log('\x1b[36m# MemoryLink Integration\x1b[0m');
+  console.log('');
+  console.log('## Before Making ANY Changes');
+  console.log('');
+  console.log('1. **Read Protected Files**: Check `.memorylink/protected.txt` - DO NOT modify these files.');
+  console.log('2. **Read Project Context**: Check `.memorylink/memory.log` for project decisions.');
+  console.log('3. **Check Past Solutions**: Review `.memorylink/learnings.log` before solving problems.');
+  console.log('   - Entries marked SUCCESS = use these approaches');
+  console.log('   - Entries marked FAILED = DO NOT repeat these');
+  console.log('');
+  console.log('## After Making Changes');
+  console.log('');
+  console.log('1. **Log Changes**: Use `memorylink change <file> "reason"`');
+  console.log('2. **Log Learnings**: Use `memorylink learn "problem" "solution" --status SUCCESS/FAILED`');
+  console.log('');
+  console.log('## Important Rules');
+  console.log('');
+  console.log('- NEVER edit files listed in protected.txt without explicit permission');
+  console.log('- ALWAYS check learnings.log before suggesting solutions');
+  console.log('- Keep memory.log updated with important decisions');
+  console.log('\x1b[90m─────────────────────────────────────────────────────────────\x1b[0m');
+  console.log('');
+  console.log('\x1b[90m💡 Full Agent Contract: See docs/AGENT_CONTRACT.md\x1b[0m');
+  console.log('');
+  console.log('\x1b[1m📝 What to do next (3 essential commands):\x1b[0m');
+  console.log('');
+  console.log('  \x1b[36m1. Add your first memory:\x1b[0m');
+  console.log('     memorylink memory "Your project uses React 18, TypeScript"');
+  console.log('');
+  console.log('  \x1b[36m2. Before each AI chat, inject context:\x1b[0m');
+  console.log('     memorylink inject  (copies to clipboard - paste into AI)');
+  console.log('');
+  console.log('  \x1b[36m3. Track solutions:\x1b[0m');
+  console.log('     memorylink learn "Bug description" "Solution" --status SUCCESS');
+  console.log('');
+  console.log('\x1b[90m💡 Tip: The 2-second "memorylink inject" habit saves hours of debugging!\x1b[0m');
+  console.log('');
+  console.log('\x1b[90m📚 Learn more:\x1b[0m');
+  console.log('  • Full guide: See README.md');
+  console.log('  • Agent instructions: See docs/AGENT_CONTRACT.md');
+  console.log('  • Troubleshooting: See TROUBLESHOOTING.md');
+  console.log('');
+}
+