memorylink 1.0.0

package/src/commands/resolve.ts

@@ -0,0 +1,373 @@
+/**
+ * MemoryLink - Conflict Resolution Helper
+ * Detect and help resolve Git merge conflicts in JSONL files
+ * 
+ * v1.1: Conflict Resolution feature
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import {
+  findRoot,
+  isInitialized,
+  getFilePath,
+  getMemoryLinkDir,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  readJsonlEntries,
+  isJsonlFormat,
+} from '../utils.js';
+import type { GlobalOptions, MemoryEntry, LearningEntry, ChangeEntry } from '../types.js';
+
+interface ConflictInfo {
+  file: string;
+  conflicts: Array<{
+    line: number;
+    ours: string;
+    theirs: string;
+    base?: string;
+  }>;
+}
+
+interface ResolveOptions extends GlobalOptions {
+  file?: string;        // Specific file to resolve
+  strategy?: 'ours' | 'theirs' | 'both' | 'merge'; // Resolution strategy
+  interactive?: boolean; // Interactive mode
+  list?: boolean;       // List conflicts only
+}
+
+/**
+ * Detect Git merge conflicts in .memorylink/ files
+ */
+function detectConflicts(root: string): ConflictInfo[] {
+  const conflicts: ConflictInfo[] = [];
+  const memoryLinkDir = getMemoryLinkDir(root);
+
+  try {
+    // Get list of conflicted files
+    const conflictFiles = execSync('git diff --name-only --diff-filter=U', {
+      cwd: root,
+      stdio: 'pipe',
+      encoding: 'utf-8',
+    })
+      .trim()
+      .split('\n')
+      .filter(f => f.startsWith('.memorylink/') && f.endsWith('.log'));
+
+    for (const file of conflictFiles) {
+      const filePath = path.join(root, file);
+      if (!fs.existsSync(filePath)) continue;
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const fileConflicts: ConflictInfo['conflicts'] = [];
+
+      let conflictStart = -1;
+      let conflictMarker = '';
+      let oursLines: string[] = [];
+      let theirsLines: string[] = [];
+      let baseLines: string[] = [];
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Detect conflict markers
+        if (line.startsWith('<<<<<<<')) {
+          conflictStart = i;
+          conflictMarker = line.substring(7).trim(); // Get branch name
+          oursLines = [];
+          theirsLines = [];
+          baseLines = [];
+        } else if (line.startsWith('=======')) {
+          // Separator between ours and theirs
+          continue;
+        } else if (line.startsWith('>>>>>>>')) {
+          // End of conflict
+          if (conflictStart >= 0) {
+            fileConflicts.push({
+              line: conflictStart + 1,
+              ours: oursLines.join('\n'),
+              theirs: theirsLines.join('\n'),
+              base: baseLines.length > 0 ? baseLines.join('\n') : undefined,
+            });
+          }
+          conflictStart = -1;
+        } else if (conflictStart >= 0) {
+          // Collect conflict content
+          if (line.startsWith('|||||||')) {
+            // Base version (3-way merge)
+            continue;
+          } else if (oursLines.length === 0 && !line.startsWith('=======')) {
+            // Ours (before separator)
+            oursLines.push(line);
+          } else {
+            // Theirs (after separator)
+            theirsLines.push(line);
+          }
+        }
+      }
+
+      if (fileConflicts.length > 0) {
+        conflicts.push({
+          file,
+          conflicts: fileConflicts,
+        });
+      }
+    }
+  } catch (err) {
+    // No conflicts or git error
+  }
+
+  return conflicts;
+}
+
+/**
+ * Resolve conflict using strategy
+ */
+function resolveConflict(
+  root: string,
+  file: string,
+  conflictLine: number,
+  strategy: 'ours' | 'theirs' | 'both' | 'merge'
+): void {
+  const filePath = path.join(root, file);
+  if (!fs.existsSync(filePath)) {
+    error(`File not found: ${file}`);
+    return;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const resolved: string[] = [];
+  
+  let inConflict = false;
+  let conflictStart = -1;
+  let oursLines: string[] = [];
+  let theirsLines: string[] = [];
+  let conflictIndex = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.startsWith('<<<<<<<')) {
+      inConflict = true;
+      conflictStart = i;
+      oursLines = [];
+      theirsLines = [];
+      conflictIndex++;
+      
+      // Check if this is the conflict we want to resolve
+      if (conflictIndex === conflictLine) {
+        continue; // Skip marker
+      } else {
+        resolved.push(line); // Keep other conflicts
+      }
+    } else if (line.startsWith('=======')) {
+      if (conflictIndex === conflictLine) {
+        continue; // Skip separator
+      } else {
+        resolved.push(line);
+      }
+    } else if (line.startsWith('>>>>>>>')) {
+      if (conflictIndex === conflictLine) {
+        // Resolve this conflict
+        switch (strategy) {
+          case 'ours':
+            resolved.push(...oursLines);
+            break;
+          case 'theirs':
+            resolved.push(...theirsLines);
+            break;
+          case 'both':
+            // Keep both (merge entries)
+            resolved.push(...oursLines);
+            resolved.push(...theirsLines);
+            break;
+          case 'merge':
+            // Smart merge: deduplicate JSONL entries
+            const oursEntries = oursLines
+              .filter(l => l.trim() && !l.startsWith('#'))
+              .map(l => {
+                try {
+                  return JSON.parse(l);
+                } catch {
+                  return null;
+                }
+              })
+              .filter(Boolean);
+            
+            const theirsEntries = theirsLines
+              .filter(l => l.trim() && !l.startsWith('#'))
+              .map(l => {
+                try {
+                  return JSON.parse(l);
+                } catch {
+                  return null;
+                }
+              })
+              .filter(Boolean);
+
+            // Merge: keep unique entries by ID
+            const mergedIds = new Set<string>();
+            const merged: any[] = [];
+
+            // Add ours first
+            for (const entry of oursEntries) {
+              if (entry.id && !mergedIds.has(entry.id)) {
+                merged.push(entry);
+                mergedIds.add(entry.id);
+              }
+            }
+
+            // Add theirs (skip duplicates)
+            for (const entry of theirsEntries) {
+              if (entry.id && !mergedIds.has(entry.id)) {
+                merged.push(entry);
+                mergedIds.add(entry.id);
+              }
+            }
+
+            // Write merged entries
+            for (const entry of merged) {
+              resolved.push(JSON.stringify(entry));
+            }
+            break;
+        }
+      } else {
+        resolved.push(line); // Keep other conflicts
+      }
+      inConflict = false;
+    } else if (inConflict && conflictIndex === conflictLine) {
+      // Collect conflict content
+      if (line.startsWith('|||||||')) {
+        continue; // Skip base marker
+      } else if (oursLines.length === 0 || line !== '=======') {
+        if (line.startsWith('=======')) {
+          // Separator
+        } else {
+          oursLines.push(line);
+        }
+      } else {
+        theirsLines.push(line);
+      }
+    } else {
+      resolved.push(line);
+    }
+  }
+
+  // Write resolved content
+  fs.writeFileSync(filePath, resolved.join('\n'), 'utf-8');
+}
+
+/**
+ * Auto-resolve conflicts in a file using merge strategy
+ */
+function autoResolveFile(root: string, file: string): boolean {
+  const conflicts = detectConflicts(root);
+  const fileConflicts = conflicts.find(c => c.file === file);
+
+  if (!fileConflicts || fileConflicts.conflicts.length === 0) {
+    return false;
+  }
+
+  // Resolve all conflicts in the file using merge strategy
+  for (let i = 0; i < fileConflicts.conflicts.length; i++) {
+    resolveConflict(root, file, i + 1, 'merge');
+  }
+
+  // Stage the resolved file
+  try {
+    execSync(`git add "${file}"`, {
+      cwd: root,
+      stdio: 'pipe',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Conflict Resolution Command
+ */
+export async function resolveCommand(options: ResolveOptions = {}): Promise<void> {
+  const { verbose, file, strategy = 'merge', interactive = false, list = false } = options;
+
+  log('Checking for conflicts', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Detect conflicts
+  const conflicts = detectConflicts(root);
+
+  if (conflicts.length === 0) {
+    success('No merge conflicts detected');
+    return;
+  }
+
+  // List conflicts
+  if (list) {
+    console.log('');
+    info(`Found ${conflicts.length} file(s) with conflicts:`);
+    console.log('');
+    
+    for (const conflict of conflicts) {
+      console.log(`  📄 ${conflict.file}`);
+      console.log(`     ${conflict.conflicts.length} conflict(s)`);
+      for (const c of conflict.conflicts) {
+        console.log(`     - Line ${c.line}: ${c.ours.split('\n').length} vs ${c.theirs.split('\n').length} entries`);
+      }
+      console.log('');
+    }
+    return;
+  }
+
+  // Resolve specific file
+  if (file) {
+    const fileConflict = conflicts.find(c => c.file === file || c.file.endsWith(file));
+    
+    if (!fileConflict) {
+      error(`No conflicts found in ${file}`);
+      return;
+    }
+
+    info(`Resolving conflicts in ${fileConflict.file} using ${strategy} strategy...`);
+    
+    if (autoResolveFile(root, fileConflict.file)) {
+      success(`Conflicts resolved in ${fileConflict.file}`);
+      info('File staged. Run: git commit to complete merge');
+    } else {
+      error(`Failed to resolve conflicts in ${fileConflict.file}`);
+    }
+    return;
+  }
+
+  // Resolve all conflicts
+  console.log('');
+  info(`Found ${conflicts.length} file(s) with conflicts`);
+  console.log('');
+
+  for (const conflict of conflicts) {
+    info(`Resolving ${conflict.file} (${conflict.conflicts.length} conflict(s))...`);
+    
+    if (autoResolveFile(root, conflict.file)) {
+      success(`✓ Resolved ${conflict.file}`);
+    } else {
+      warn(`⚠ Failed to resolve ${conflict.file}`);
+    }
+  }
+
+  console.log('');
+  success('Conflict resolution complete');
+  info('Review changes and run: git commit to complete merge');
+}
+

package/src/commands/roadmap.ts

@@ -0,0 +1,25 @@
+import { info } from '../utils.js';
+import { DEFAULT_THRESHOLDS } from '../config/thresholds.js';
+
+export interface RoadmapOptions {
+  verbose?: boolean;
+}
+
+export async function roadmapCommand(): Promise<void> {
+  info('MemoryLink Roadmap:');
+  console.log('');
+  info('v1.3 (shipping): JS/TS optimized, CLI-first, MCP, structure memory, read-only viewer, minimal website.');
+  info(`v1.4 (target 1–2 weeks): VS Code extension (in progress).`);
+  info(`v1.5 (2–4 weeks): Python/Go (Tree-sitter) + lightweight read-only dashboard (pre-announced).`);
+  console.log('');
+  info(`Thresholds:`);
+  info(`- Tree-sitter: build at ${DEFAULT_THRESHOLDS.treeSitter} requests (urgent path ${DEFAULT_THRESHOLDS.treeSitterUrgent}); defer if < ${DEFAULT_THRESHOLDS.deferIfLow} signals in 30 days.`);
+  info(`- Dashboard: build at ${DEFAULT_THRESHOLDS.dashboard} requests; defer if < ${DEFAULT_THRESHOLDS.deferIfLow} signals in 30 days.`);
+  info(`- VS Code: in progress now (target v1.4).`);
+  console.log('');
+  info(`Tell us what to build first: open a GitHub issue with labels:`);
+  info(`- Tree-sitter: lang:python / lang:go`);
+  info(`- Dashboard: ui:dashboard`);
+  info(`- VS Code: ide:vscode`);
+}
+

package/src/commands/scopes.ts

@@ -0,0 +1,113 @@
+/**
+ * MemoryLink - Scopes Command (v1.5 Phase 2 Enhancement)
+ * List and manage project scopes
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  findRoot,
+  isInitialized,
+  getFilePath,
+  readJsonlEntries,
+  success,
+  error,
+  info,
+  log,
+} from '../utils.js';
+import type { GlobalOptions, MemoryEntry } from '../types.js';
+
+interface ScopeInfo {
+  name: string;
+  count: number;
+  lastUsed: string;
+}
+
+/**
+ * List all scopes with counts
+ */
+export async function scopesListCommand(
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log('Listing project scopes', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+  const entries = readJsonlEntries<MemoryEntry>(memoryPath);
+
+  // Collect scope information
+  const scopeMap = new Map<string, { count: number; lastUsed: Date }>();
+
+  for (const entry of entries) {
+    // Check for projectScope (v1.5 Phase 2 field)
+    if (entry.projectScope) {
+      const existing = scopeMap.get(entry.projectScope);
+      const entryDate = new Date(entry.ts);
+      
+      if (existing) {
+        existing.count++;
+        if (entryDate > existing.lastUsed) {
+          existing.lastUsed = entryDate;
+        }
+      } else {
+        scopeMap.set(entry.projectScope, {
+          count: 1,
+          lastUsed: entryDate,
+        });
+      }
+    }
+  }
+
+  if (scopeMap.size === 0) {
+    info('No scoped entries found. Use --scope when adding memory.');
+    return;
+  }
+
+  // Convert to array and sort
+  const scopes: ScopeInfo[] = Array.from(scopeMap.entries())
+    .map(([name, data]) => ({
+      name,
+      count: data.count,
+      lastUsed: data.lastUsed.toISOString(),
+    }))
+    .sort((a, b) => b.count - a.count); // Sort by count (most used first)
+
+  // Display
+  console.log('');
+  console.log('\x1b[1m📁 Project Scopes\x1b[0m');
+  console.log('');
+
+  const totalScoped = scopes.reduce((sum, s) => sum + s.count, 0);
+  const totalEntries = entries.length;
+  const unscoped = totalEntries - totalScoped;
+
+  console.log(`  Total entries: ${totalEntries}`);
+  console.log(`  Scoped entries: ${totalScoped}`);
+  console.log(`  Unscoped entries: ${unscoped}`);
+  console.log(`  Unique scopes: ${scopes.length}`);
+  console.log('');
+
+  console.log('  Scope Name          | Count | Last Used');
+  console.log('  --------------------|-------|-------------------');
+
+  for (const scope of scopes) {
+    const name = scope.name.padEnd(20);
+    const count = scope.count.toString().padStart(5);
+    const lastUsed = new Date(scope.lastUsed).toLocaleDateString();
+    console.log(`  ${name} | ${count} | ${lastUsed}`);
+  }
+
+  console.log('');
+
+  if (unscoped > 0) {
+    info(`💡 Tip: ${unscoped} entries have no scope. Add --scope when creating memory.`);
+  }
+}
+