memorylink 1.0.0

package/src/commands/export.ts

@@ -0,0 +1,77 @@
+import * as fs from 'fs';
+import {
+  getFilePath,
+  isInitialized,
+  error,
+  success,
+  findRoot,
+  isJsonlFormat,
+} from '../utils.js';
+import { streamJsonlEntries } from '../utils/streaming.js';
+import type { BaseEntry, ExportOptions } from '../types.js';
+
+export async function exportContextCommand(
+  outputFile?: string,
+  options: ExportOptions = {}
+): Promise<void> {
+  const { verbose, format = 'json', limit } = options;
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+  const changesPath = getFilePath('CHANGES', root);
+  const learningsPath = getFilePath('LEARNINGS', root);
+  const protectedPath = getFilePath('PROTECTED', root);
+
+  const result: Record<string, BaseEntry[]> = {
+    memory: [],
+    changes: [],
+    learnings: [],
+    protected: [],
+  };
+
+  const pushCapped = <T>(arr: T[], item: T) => {
+    arr.push(item);
+    if (limit && arr.length > limit) {
+      arr.shift();
+    }
+  };
+
+  if (isJsonlFormat(memoryPath)) {
+    for await (const entry of streamJsonlEntries(memoryPath)) {
+      pushCapped(result.memory, entry as BaseEntry);
+    }
+  }
+  if (isJsonlFormat(changesPath)) {
+    for await (const entry of streamJsonlEntries(changesPath)) {
+      pushCapped(result.changes, entry as BaseEntry);
+    }
+  }
+  if (isJsonlFormat(learningsPath)) {
+    for await (const entry of streamJsonlEntries(learningsPath)) {
+      pushCapped(result.learnings, entry as BaseEntry);
+    }
+  }
+  if (fs.existsSync(protectedPath)) {
+    const lines = fs.readFileSync(protectedPath, 'utf-8').split('\n').filter(l => l.trim());
+    lines.forEach(l => pushCapped(result.protected, { path: l } as any));
+  }
+
+  const payload = format === 'jsonl'
+    ? Object.entries(result)
+        .map(([k, arr]) => arr.map(e => JSON.stringify({ type: k, ...e })).join('\n'))
+        .join('\n')
+    : JSON.stringify(result, null, 2);
+
+  if (outputFile) {
+    fs.writeFileSync(outputFile, payload);
+    success(`Context exported to ${outputFile}`);
+  } else {
+    console.log(payload);
+  }
+}
+

package/src/commands/graph.ts

@@ -0,0 +1,214 @@
+/**
+ * MemoryLink - Graph Commands
+ * Code structure memory: dependency graph building and querying
+ * 
+ * v1.2: Code Structure Memory feature
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  buildDependencyGraph,
+  loadGraph,
+  saveGraph,
+  analyzeImpact,
+  type CodeGraph,
+  type FileNode,
+} from '../utils/code-structure.js';
+import { findRoot, getFilePath, colorize } from '../utils.js';
+
+export interface GlobalOptions {
+  verbose?: boolean;
+}
+
+export interface GraphOptions extends GlobalOptions {
+  rebuild?: boolean;
+  silent?: boolean;
+  visual?: boolean;  // Visual tree output
+}
+
+/**
+ * Build code dependency graph
+ */
+export async function graphBuildCommand(options: GraphOptions = {}): Promise<void> {
+  const rootDir = findRoot();
+  if (!rootDir) {
+    console.error(colorize('❌ Not in a MemoryLink project. Run: memorylink init', 'red'));
+    process.exit(1);
+  }
+  
+  const graphFile = path.join(rootDir, '.memorylink', 'code-graph.json');
+  
+  // Check if graph exists and is recent
+  if (!options.rebuild && fs.existsSync(graphFile)) {
+    const stats = fs.statSync(graphFile);
+    const age = Date.now() - stats.mtimeMs;
+    const oneDay = 24 * 60 * 60 * 1000;
+    
+    if (age < oneDay) {
+      if (!options.silent) {
+        console.log(colorize('⚠️  Graph exists and is less than 1 day old. Use --rebuild to force rebuild.', 'yellow'));
+      }
+      return;
+    }
+  }
+  
+  if (!options.silent) {
+    console.log(colorize('📊 Building code dependency graph...', 'cyan'));
+  }
+  
+  try {
+    const graph = await buildDependencyGraph(rootDir);
+    
+    // Save graph
+    saveGraph(graph, graphFile);
+    
+    if (!options.silent) {
+      console.log(colorize('✅ Graph built successfully!', 'green'));
+      console.log(`   Files analyzed: ${graph.files.size}`);
+      console.log(`   Dependencies: ${Array.from(graph.dependencies.values()).flat().length}`);
+      console.log(`   Graph saved to: .memorylink/code-graph.json`);
+    }
+  } catch (error) {
+    console.error(colorize(`❌ Error building graph: ${error}`, 'red'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Query file dependencies
+ */
+export async function graphQueryCommand(
+  file: string,
+  options: GlobalOptions & { visual?: boolean } = {}
+): Promise<void> {
+  if (!file || file.trim().length === 0) {
+    console.error(colorize('❌ File path is required', 'red'));
+    process.exit(1);
+  }
+  const rootDir = findRoot();
+  if (!rootDir) {
+    console.error(colorize('❌ Not in a MemoryLink project. Run: memorylink init', 'red'));
+    process.exit(1);
+  }
+  
+  const graphFile = path.join(rootDir, '.memorylink', 'code-graph.json');
+  
+  // Load or build graph
+  let graph = loadGraph(graphFile);
+  if (!graph) {
+    console.log(colorize('⚠️  Graph not found. Building...', 'yellow'));
+    graph = await buildDependencyGraph(rootDir);
+    saveGraph(graph, graphFile);
+  }
+  
+  // Normalize file path
+  const normalizedFile = path.relative(rootDir, path.resolve(rootDir, file)).replace(/\\/g, '/');
+  
+  const node = graph.files.get(normalizedFile);
+  if (!node) {
+    console.error(colorize(`❌ File not found in graph: ${file}`, 'red'));
+    console.log(colorize('💡 Run: memorylink graph build --rebuild', 'yellow'));
+    process.exit(1);
+  }
+  
+  // Display file information
+  console.log(colorize(`\n📁 ${normalizedFile}`, 'cyan'));
+  console.log(`   Complexity: ${node.complexity} (${node.complexity < 20 ? 'LOW' : node.complexity < 50 ? 'MEDIUM' : 'HIGH'})`);
+  console.log(`   Lines: ${node.lines}`);
+  console.log(`   Functions: ${node.functions.length}`);
+  console.log(`   Classes: ${node.classes.length}`);
+  console.log(`   Risk Score: ${node.risk_score} (${node.risk_score === 0 ? 'LOW' : node.risk_score < 5 ? 'MEDIUM' : 'HIGH'} RISK)`);
+  
+  // Visual tree output if requested
+  if (options.visual) {
+    visualizeDependencies(normalizedFile, graph, rootDir);
+    return;
+  }
+  
+  // Show dependencies
+  const dependencies = graph.dependencies.get(normalizedFile) || [];
+  if (dependencies.length > 0) {
+    console.log(colorize(`\n📥 Depends on (${dependencies.length}):`, 'cyan'));
+    dependencies.forEach((dep, idx) => {
+      const isLast = idx === dependencies.length - 1;
+      const prefix = isLast ? '   └── ' : '   ├── ';
+      console.log(`${prefix}${dep}`);
+    });
+  } else {
+    console.log(colorize('\n📥 Depends on: (none)', 'gray'));
+  }
+  
+  // Show dependents
+  const dependents = graph.dependents.get(normalizedFile) || [];
+  if (dependents.length > 0) {
+    console.log(colorize(`\n📤 Imported by (${dependents.length}):`, 'cyan'));
+    dependents.forEach((dep, idx) => {
+      const isLast = idx === dependents.length - 1;
+      const prefix = isLast ? '   └── ' : '   ├── ';
+      console.log(`${prefix}${dep}`);
+    });
+    
+    if (dependents.length > 5) {
+      console.log(colorize(`\n⚠️  HIGH RISK: ${dependents.length} files depend on this file.`, 'yellow'));
+      console.log(colorize(`   Changes here will affect ${dependents.length} files.`, 'yellow'));
+    }
+  } else {
+    console.log(colorize('\n📤 Imported by: (none)', 'gray'));
+  }
+  
+  console.log('');
+}
+
+/**
+ * Visualize dependencies as a tree
+ */
+function visualizeDependencies(file: string, graph: CodeGraph, rootDir: string): void {
+  const dependencies = graph.dependencies.get(file) || [];
+  const dependents = graph.dependents.get(file) || [];
+  const node = graph.files.get(file);
+  
+  console.log(colorize('\n📊 DEPENDENCY TREE', 'cyan'));
+  console.log('═══════════════════════════════════════════════════════════\n');
+  
+  // Show what this file depends on
+  if (dependencies.length > 0) {
+    console.log(colorize('📥 Dependencies:', 'cyan'));
+    dependencies.forEach((dep, idx) => {
+      const isLast = idx === dependencies.length - 1;
+      const prefix = isLast ? '   └── ' : '   ├── ';
+      const depNode = graph.files.get(dep);
+      const risk = depNode && depNode.risk_score > 5 ? colorize(' ⚠️', 'yellow') : '';
+      console.log(`${prefix}${dep}${risk}`);
+    });
+    console.log('');
+  }
+  
+  // Show the file itself
+  console.log(colorize(`📁 ${file}`, 'cyan'));
+  if (node) {
+    console.log(`   Complexity: ${node.complexity} | Lines: ${node.lines} | Risk: ${node.risk_score}`);
+  }
+  console.log('');
+  
+  // Show what depends on this file
+  if (dependents.length > 0) {
+    console.log(colorize('📤 Dependents:', 'cyan'));
+    dependents.forEach((dep, idx) => {
+      const isLast = idx === dependents.length - 1;
+      const prefix = isLast ? '   └── ' : '   ├── ';
+      const depNode = graph.files.get(dep);
+      const risk = depNode && depNode.risk_score > 5 ? colorize(' ⚠️', 'yellow') : '';
+      console.log(`${prefix}${dep}${risk}`);
+    });
+    
+    if (dependents.length > 5) {
+      console.log(colorize(`\n⚠️  HIGH RISK: ${dependents.length} files depend on this file`, 'yellow'));
+    }
+  } else {
+    console.log(colorize('📤 Dependents: (none)', 'gray'));
+  }
+  
+  console.log('\n═══════════════════════════════════════════════════════════\n');
+}
+

package/src/commands/hooks.ts

@@ -0,0 +1,245 @@
+/**
+ * MemoryLink - Git Hooks Command
+ * Install/uninstall Git hooks for protection enforcement
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import {
+  isInitialized,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  findRoot,
+} from '../utils.js';
+import type { GlobalOptions } from '../types.js';
+
+const PRE_COMMIT_HOOK = `#!/bin/sh
+# MemoryLink Pre-commit Hook
+# Prevents committing changes to protected files
+
+# Find the project root
+ROOT=$(git rev-parse --show-toplevel)
+MEMORYLINK_DIR="$ROOT/.memorylink"
+PROTECTED_FILE="$MEMORYLINK_DIR/protected.txt"
+
+# Check if MemoryLink is initialized
+if [ ! -f "$PROTECTED_FILE" ]; then
+  exit 0
+fi
+
+# Get list of staged files
+STAGED_FILES=$(git diff --cached --name-only)
+
+# Check each staged file against protected list
+BLOCKED=0
+BLOCKED_FILES=""
+
+while IFS= read -r protected_path; do
+  # Skip comments and empty lines
+  case "$protected_path" in
+    "#"*|"") continue ;;
+  esac
+  
+  # Extract just the path (before any comment)
+  protected_path=$(echo "$protected_path" | cut -d'#' -f1 | xargs)
+  
+  # Check if any staged file matches
+  for staged_file in $STAGED_FILES; do
+    if [ "$staged_file" = "$protected_path" ] || echo "$staged_file" | grep -q "^$protected_path/"; then
+      BLOCKED=1
+      BLOCKED_FILES="$BLOCKED_FILES\\n  - $staged_file"
+    fi
+  done
+done < "$PROTECTED_FILE"
+
+if [ $BLOCKED -eq 1 ]; then
+  echo ""
+  echo "\\033[31m✗ COMMIT BLOCKED BY MEMORYLINK\\033[0m"
+  echo ""
+  echo "The following protected files were modified:"
+  echo -e "$BLOCKED_FILES"
+  echo ""
+  echo "To commit anyway, use: git commit --no-verify"
+  echo "To unprotect a file: memorylink unprotect <file>"
+  echo ""
+  
+  # Log the blocked commit
+  TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+  echo "[$TIMESTAMP] ⚠️ COMMIT BLOCKED: Protected files modified$BLOCKED_FILES" >> "$MEMORYLINK_DIR/changes.log"
+  
+  exit 1
+fi
+
+exit 0
+`;
+
+export async function hooksInstallCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Installing Git hooks', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Check if this is a Git repository
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    error('Not a Git repository. Initialize Git first: git init');
+    process.exit(1);
+  }
+
+  const hooksDir = path.join(gitDir, 'hooks');
+  const preCommitPath = path.join(hooksDir, 'pre-commit');
+
+  // Ensure hooks directory exists
+  if (!fs.existsSync(hooksDir)) {
+    fs.mkdirSync(hooksDir, { recursive: true });
+  }
+
+  // Check for existing hook
+  if (fs.existsSync(preCommitPath)) {
+    const existingContent = fs.readFileSync(preCommitPath, 'utf-8');
+    
+    if (existingContent.includes('MemoryLink')) {
+      warn('MemoryLink hook is already installed');
+      return;
+    }
+
+    // Append to existing hook
+    const updatedContent = existingContent + '\n\n' + PRE_COMMIT_HOOK.replace('#!/bin/sh\n', '');
+    fs.writeFileSync(preCommitPath, updatedContent);
+    fs.chmodSync(preCommitPath, '755');
+    
+    success('MemoryLink hook added to existing pre-commit hook');
+    info('Protected files will be blocked from commits');
+  } else {
+    // Create new hook
+    fs.writeFileSync(preCommitPath, PRE_COMMIT_HOOK);
+    fs.chmodSync(preCommitPath, '755');
+    
+    success('Git pre-commit hook installed');
+    info('Protected files will now be blocked from commits');
+  }
+
+  console.log('');
+  info('Test the hook by modifying a protected file and trying to commit.');
+  info('To bypass: git commit --no-verify');
+}
+
+export async function hooksUninstallCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Uninstalling Git hooks', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root) {
+    error('Not in a MemoryLink project');
+    process.exit(1);
+  }
+
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    error('Not a Git repository');
+    process.exit(1);
+  }
+
+  const preCommitPath = path.join(gitDir, 'hooks', 'pre-commit');
+
+  if (!fs.existsSync(preCommitPath)) {
+    info('No pre-commit hook found');
+    return;
+  }
+
+  const content = fs.readFileSync(preCommitPath, 'utf-8');
+
+  if (!content.includes('MemoryLink')) {
+    info('MemoryLink hook is not installed');
+    return;
+  }
+
+  // Remove MemoryLink section
+  const lines = content.split('\n');
+  const newLines: string[] = [];
+  let inMemoryLinkSection = false;
+
+  for (const line of lines) {
+    if (line.includes('MemoryLink Pre-commit Hook')) {
+      inMemoryLinkSection = true;
+      continue;
+    }
+    if (inMemoryLinkSection && line === 'exit 0') {
+      inMemoryLinkSection = false;
+      continue;
+    }
+    if (!inMemoryLinkSection) {
+      newLines.push(line);
+    }
+  }
+
+  const newContent = newLines.join('\n').trim();
+
+  if (newContent === '' || newContent === '#!/bin/sh') {
+    // Remove the hook file entirely
+    fs.unlinkSync(preCommitPath);
+    success('Git pre-commit hook removed');
+  } else {
+    fs.writeFileSync(preCommitPath, newContent);
+    success('MemoryLink hook removed from pre-commit');
+  }
+
+  info('Protected files will no longer be blocked from commits');
+}
+
+export async function hooksStatusCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Checking Git hooks status', verbose);
+
+  const root = findRoot();
+  if (!root) {
+    info('Not in a MemoryLink project');
+    return;
+  }
+
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    info('Not a Git repository');
+    return;
+  }
+
+  const preCommitPath = path.join(gitDir, 'hooks', 'pre-commit');
+
+  console.log('');
+  info('Git Hooks Status:');
+  console.log('');
+
+  if (!fs.existsSync(preCommitPath)) {
+    console.log('   Pre-commit hook: \x1b[33mNot installed\x1b[0m');
+    console.log('');
+    console.log('   Install with: memorylink hooks install');
+  } else {
+    const content = fs.readFileSync(preCommitPath, 'utf-8');
+    const hasMemoryLink = content.includes('MemoryLink');
+    
+    console.log(`   Pre-commit hook: ${hasMemoryLink ? '\x1b[32mInstalled\x1b[0m' : '\x1b[33mExists (no MemoryLink)\x1b[0m'}`);
+    
+    if (hasMemoryLink) {
+      console.log('   Protection: \x1b[32mActive\x1b[0m');
+    } else {
+      console.log('');
+      console.log('   Add MemoryLink with: memorylink hooks install');
+    }
+  }
+
+  console.log('');
+}
+

package/src/commands/impact.ts

@@ -0,0 +1,163 @@
+/**
+ * MemoryLink - Impact Analysis Command
+ * Predict change impact for files
+ * 
+ * v1.2: Code Structure Memory feature
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  loadGraph,
+  buildDependencyGraph,
+  saveGraph,
+  analyzeImpact,
+  type ChangeImpact,
+} from '../utils/code-structure.js';
+import { findRoot, colorize } from '../utils.js';
+
+export interface GlobalOptions {
+  verbose?: boolean;
+}
+
+export interface ImpactOptions extends GlobalOptions {
+  change?: string;
+  rebuild?: boolean;
+}
+
+/**
+ * Analyze impact of changing a file
+ */
+export async function impactCommand(
+  file: string,
+  options: ImpactOptions = {}
+): Promise<void> {
+  const rootDir = findRoot();
+  if (!rootDir) {
+    console.error(colorize('❌ Not in a MemoryLink project. Run: memorylink init', 'red'));
+    process.exit(1);
+  }
+  
+  const graphFile = path.join(rootDir, '.memorylink', 'code-graph.json');
+  
+  // Load or build graph
+  let graph = loadGraph(graphFile);
+  if (!graph || options.rebuild) {
+    if (!graph) {
+      console.log(colorize('⚠️  Graph not found. Building...', 'yellow'));
+    } else {
+      console.log(colorize('🔄 Rebuilding graph...', 'yellow'));
+    }
+    graph = await buildDependencyGraph(rootDir);
+    saveGraph(graph, graphFile);
+  }
+  
+  // Normalize file path
+  const normalizedFile = path.relative(rootDir, path.resolve(rootDir, file)).replace(/\\/g, '/');
+  
+  // Analyze impact
+  const impact = analyzeImpact(normalizedFile, graph, options.change);
+  
+  // Display results
+  displayImpactAnalysis(impact);
+  
+  // Save impact to changes.log if significant
+  if (impact.risk_level !== 'LOW' || impact.breaking_changes.length > 0) {
+    await saveImpactToChanges(impact, rootDir);
+  }
+}
+
+/**
+ * Display impact analysis results
+ */
+function displayImpactAnalysis(impact: ChangeImpact): void {
+  console.log(`\n${colorize('📋 Change Impact Analysis for ' + impact.file, 'cyan')}`);
+  
+  if (impact.proposed_change) {
+    console.log(`   ${colorize('Proposed change: ' + impact.proposed_change, 'gray')}`);
+  }
+  
+  console.log(`\n${colorize('📊 Impact Summary:', 'cyan')}`);
+  console.log(`   Direct dependents: ${impact.affected_files.filter(f => {
+    // Direct dependents are those that directly import this file
+    // This is a simplified check - in real implementation, we'd track this
+    return true; // For now, show all affected
+  }).length} files`);
+  console.log(`   Total affected files: ${impact.affected_files.length} files`);
+  console.log(`   Breaking changes: ${impact.breaking_changes.length}`);
+  console.log(`   Risk level: ${colorizeRiskLevel(impact.risk_level)}`);
+  
+  if (impact.affected_files.length > 0) {
+    console.log(`\n${colorize('📁 Affected Files:', 'cyan')}`);
+    impact.affected_files.slice(0, 20).forEach(file => {
+      console.log(`   └── ${file}`);
+    });
+    if (impact.affected_files.length > 20) {
+      console.log(`   ${colorize('... and ' + (impact.affected_files.length - 20) + ' more', 'gray')}`);
+    }
+  }
+  
+  if (impact.breaking_changes.length > 0) {
+    console.log(`\n${colorize('🔴 Breaking Changes:', 'red')}`);
+    impact.breaking_changes.forEach(breaking => {
+      console.log(`   ${colorize('⚠️', 'red')} ${breaking.file}`);
+      console.log(`      Reason: ${breaking.reason}`);
+      if (breaking.migration_needed) {
+        console.log(`      Migration: ${breaking.estimated_effort}`);
+      }
+    });
+  }
+  
+  if (impact.recommendations.length > 0) {
+    console.log(`\n${colorize('💡 Recommendations:', 'yellow')}`);
+    impact.recommendations.forEach(rec => {
+      console.log(`   ${rec}`);
+    });
+  }
+  
+  console.log('');
+}
+
+/**
+ * Colorize risk level
+ */
+function colorizeRiskLevel(risk: 'LOW' | 'MEDIUM' | 'HIGH'): string {
+  switch (risk) {
+    case 'LOW':
+      return colorize('LOW', 'green');
+    case 'MEDIUM':
+      return colorize('MEDIUM', 'yellow');
+    case 'HIGH':
+      return colorize('HIGH', 'red');
+  }
+}
+
+/**
+ * Save impact analysis to changes.log
+ */
+async function saveImpactToChanges(impact: ChangeImpact, rootDir: string): Promise<void> {
+  const changesFile = path.join(rootDir, '.memorylink', 'changes.log');
+  
+  const entry = {
+    id: `impact_${Date.now()}`,
+    ts: new Date().toISOString(),
+    type: 'change_impact',
+    agent: 'memorylink',
+    status: 'ACTIVE' as const,
+    file: impact.file,
+    action: 'edited' as const,
+    reason: impact.proposed_change || 'Change impact analysis',
+    impact: {
+      direct_dependents: impact.affected_files.length, // Simplified
+      indirect_dependents: 0,
+      breaking_changes: impact.breaking_changes.map(bc => bc.reason),
+      migration_required: impact.breaking_changes.some(bc => bc.migration_needed),
+    },
+    tags: ['impact-analysis', impact.risk_level.toLowerCase()],
+  };
+  
+  // Append to changes.log
+  const line = JSON.stringify(entry) + '\n';
+  fs.appendFileSync(changesFile, line);
+}
+