@lmaksym/agent-mem 0.1.0

package/src/commands/resolve.js

@@ -0,0 +1,230 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { commitContext } from '../core/git.js';
+import { execSync } from 'node:child_process';
+
+/**
+ * Find files with merge conflict markers in .context/.
+ */
+function findConflicted(ctxDir, verbose = false) {
+  const conflicted = [];
+  const walk = (dir) => {
+    if (!existsSync(dir)) return;
+    for (const name of readdirSync(dir)) {
+      if (name.startsWith('.')) continue;
+      const full = join(dir, name);
+      try {
+        const stat = statSync(full);
+        if (stat.isDirectory()) {
+          walk(full);
+        } else {
+          const content = readFileSync(full, 'utf-8');
+          // Check for actual conflict block structure (not just substrings)
+          if (
+            /^<<<<<<<\s/m.test(content) &&
+            /^=======/m.test(content) &&
+            /^>>>>>>>\s/m.test(content)
+          ) {
+            const relPath = full.slice(ctxDir.length + 1);
+            conflicted.push({ path: relPath, fullPath: full, content });
+          }
+        }
+      } catch (err) {
+        if (verbose) console.error(`  ⚠️  Could not read ${full}: ${err.message}`);
+      }
+    }
+  };
+  walk(ctxDir);
+  return conflicted;
+}
+
+/**
+ * Resolve a single file's merge conflicts.
+ *
+ * Strategy for .context/ files:
+ * - Memory files (append-only entries): keep BOTH sides, deduplicate
+ * - Config files: prefer "ours" (local) for settings
+ * - Other files: keep both sides concatenated with separator
+ */
+function resolveFile(relPath, content) {
+  const isMemory = relPath.startsWith('memory/') || relPath.startsWith('archive/');
+  const isConfig = relPath === 'config.yaml';
+
+  if (isConfig) {
+    return resolveConfigConflict(content);
+  }
+
+  if (isMemory) {
+    return resolveAppendOnly(content);
+  }
+
+  // Default: keep both sides
+  return resolveKeepBoth(content);
+}
+
+/**
+ * Resolve append-only files (memory) by merging both sides.
+ * Deduplicates entries that are exact matches (preserves blank lines and whitespace).
+ */
+function resolveAppendOnly(content) {
+  const lines = content.split('\n');
+  const resolved = [];
+  let inConflict = false;
+  let oursLines = [];
+  let theirsLines = [];
+  let side = null;
+
+  for (const line of lines) {
+    if (line.startsWith('<<<<<<<')) {
+      inConflict = true;
+      side = 'ours';
+      oursLines = [];
+      theirsLines = [];
+      continue;
+    }
+    if (line === '=======' && inConflict) {
+      side = 'theirs';
+      continue;
+    }
+    if (line.startsWith('>>>>>>>') && inConflict) {
+      // Merge: keep all lines from ours, then unique lines from theirs
+      // Exact string match for dedup (not trimmed)
+      const seen = new Set(oursLines);
+      const merged = [...oursLines];
+
+      for (const l of theirsLines) {
+        if (!seen.has(l)) {
+          seen.add(l);
+          merged.push(l);
+        }
+      }
+
+      resolved.push(...merged);
+      inConflict = false;
+      side = null;
+      continue;
+    }
+
+    if (inConflict) {
+      if (side === 'ours') oursLines.push(line);
+      else theirsLines.push(line);
+    } else {
+      resolved.push(line);
+    }
+  }
+
+  return resolved.join('\n');
+}
+
+/**
+ * Resolve config conflicts by preferring "ours" (local) values.
+ */
+function resolveConfigConflict(content) {
+  const lines = content.split('\n');
+  const resolved = [];
+  let inConflict = false;
+  let side = null;
+
+  for (const line of lines) {
+    if (line.startsWith('<<<<<<<')) {
+      inConflict = true;
+      side = 'ours';
+      continue;
+    }
+    if (line === '=======' && inConflict) {
+      side = 'theirs';
+      continue;
+    }
+    if (line.startsWith('>>>>>>>') && inConflict) {
+      inConflict = false;
+      side = null;
+      continue;
+    }
+
+    if (inConflict) {
+      // Keep only "ours" lines
+      if (side === 'ours') {
+        resolved.push(line);
+      }
+    } else {
+      resolved.push(line);
+    }
+  }
+
+  return resolved.join('\n');
+}
+
+/**
+ * Fallback: keep both sides separated.
+ */
+function resolveKeepBoth(content) {
+  // Just strip conflict markers and keep everything
+  return content
+    .replace(/^<<<<<<<.*\n/gm, '')
+    .replace(/^=======\n/gm, '\n--- merged ---\n\n')
+    .replace(/^>>>>>>>.*\n/gm, '');
+}
+
+/**
+ * Get resolution strategy label for a file path.
+ */
+function getStrategy(relPath) {
+  if (relPath.startsWith('memory/') || relPath.startsWith('archive/')) {
+    return 'append-only (merge both, deduplicate)';
+  }
+  if (relPath === 'config.yaml') {
+    return 'prefer-ours (keep local config)';
+  }
+  return 'keep-both (concatenate)';
+}
+
+export default async function resolve({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+  const isDryRun = flags['dry-run'] === true;
+
+  const verbose = flags.verbose === true;
+  const conflicted = findConflicted(ctxDir, verbose);
+
+  if (conflicted.length === 0) {
+    console.log('✅ No merge conflicts in .context/');
+    return;
+  }
+
+  console.log(`🔀 RESOLVE${isDryRun ? ' (dry run)' : ''}`);
+  console.log(`Found ${conflicted.length} conflicted file${conflicted.length > 1 ? 's' : ''}:`);
+  console.log('');
+
+  for (const file of conflicted) {
+    const strategy = getStrategy(file.path);
+
+    console.log(`  ${file.path} — ${strategy}`);
+
+    if (!isDryRun) {
+      const resolved = resolveFile(file.path, file.content);
+      writeFileSync(file.fullPath, resolved, 'utf-8');
+    }
+  }
+
+  if (!isDryRun) {
+    // Stage resolved files
+    try {
+      execSync('git add .', { cwd: ctxDir, stdio: 'ignore' });
+    } catch (err) {
+      if (verbose) console.error(`  ⚠️  git add failed: ${err.message}`);
+    }
+
+    const hash = commitContext(
+      ctxDir,
+      `resolve: auto-resolved ${conflicted.length} conflict${conflicted.length > 1 ? 's' : ''}`,
+    );
+
+    console.log('');
+    console.log(`✅ Resolved ${conflicted.length} file${conflicted.length > 1 ? 's' : ''}`);
+    if (hash) console.log(`Committed: ${hash}`);
+  } else {
+    console.log('');
+    console.log('Run without --dry-run to apply resolutions.');
+  }
+}

package/src/commands/resolve.test.js

@@ -0,0 +1,167 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+
+const CLI = join(import.meta.dirname, '../../bin/agent-context.js');
+
+function run(args, cwd) {
+  return execSync(`node ${CLI} ${args}`, { cwd, encoding: 'utf-8', timeout: 10000 });
+}
+
+function makeConflict(ours, theirs) {
+  return `<<<<<<< HEAD\n${ours}\n=======\n${theirs}\n>>>>>>> branch-b`;
+}
+
+describe('resolve', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-resolve-'));
+    execSync('git init', { cwd: dir, stdio: 'ignore' });
+    execSync('git config user.name "test"', { cwd: dir, stdio: 'ignore' });
+    execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'ignore' });
+    run('init', dir);
+  });
+
+  after(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('reports no conflicts when clean', () => {
+    const out = run('resolve', dir);
+    assert.match(out, /No merge conflicts/);
+  });
+
+  it('resolves memory file conflicts by keeping both sides deduplicated', () => {
+    const memFile = join(dir, '.context', 'memory', 'decisions.md');
+    writeFileSync(
+      memFile,
+      [
+        '# Decisions',
+        '',
+        '- [2026-01-01] Shared decision',
+        makeConflict('- [2026-02-01] Our local decision', '- [2026-02-01] Their remote decision'),
+      ].join('\n'),
+    );
+
+    const out = run('resolve', dir);
+    assert.match(out, /Resolved/);
+    assert.match(out, /append-only/);
+
+    const resolved = readFileSync(memFile, 'utf-8');
+    assert.ok(!resolved.includes('<<<<<<<'));
+    assert.ok(!resolved.includes('>>>>>>>'));
+    assert.match(resolved, /Our local decision/);
+    assert.match(resolved, /Their remote decision/);
+    assert.match(resolved, /Shared decision/);
+  });
+
+  it('deduplicates exact matches in append-only merge', () => {
+    const memFile = join(dir, '.context', 'memory', 'patterns.md');
+    mkdirSync(join(dir, '.context', 'memory'), { recursive: true });
+    writeFileSync(
+      memFile,
+      [
+        '# Patterns',
+        makeConflict(
+          '- [2026-01-01] Same entry\n- [2026-01-02] Only ours',
+          '- [2026-01-01] Same entry\n- [2026-01-03] Only theirs',
+        ),
+      ].join('\n'),
+    );
+
+    run('resolve', dir);
+    const resolved = readFileSync(memFile, 'utf-8');
+
+    // "Same entry" should appear exactly once
+    const count = (resolved.match(/Same entry/g) || []).length;
+    assert.equal(count, 1, 'duplicate entry should appear only once');
+    assert.match(resolved, /Only ours/);
+    assert.match(resolved, /Only theirs/);
+  });
+
+  it('preserves whitespace differences (no trim-based dedupe)', () => {
+    const memFile = join(dir, '.context', 'memory', 'ws-test.md');
+    writeFileSync(
+      memFile,
+      makeConflict('- [2026-01-01]   spaced entry', '- [2026-01-01] spaced entry'),
+    );
+
+    run('resolve', dir);
+    const resolved = readFileSync(memFile, 'utf-8');
+    // Both should be kept — different exact strings
+    const count = (resolved.match(/spaced entry/g) || []).length;
+    assert.equal(count, 2, 'whitespace-different lines should both be kept');
+  });
+
+  it('resolves config.yaml with prefer-ours strategy', () => {
+    const configFile = join(dir, '.context', 'config.yaml');
+    writeFileSync(
+      configFile,
+      [
+        'auto_commit: true',
+        makeConflict('branch: feature-a', 'branch: feature-b'),
+        'system_files_max: 10',
+      ].join('\n'),
+    );
+
+    run('resolve', dir);
+    const resolved = readFileSync(configFile, 'utf-8');
+    assert.ok(!resolved.includes('<<<<<<<'));
+    assert.match(resolved, /feature-a/, 'should keep ours');
+    assert.ok(!resolved.includes('feature-b'), 'should drop theirs');
+    assert.match(resolved, /auto_commit: true/);
+    assert.match(resolved, /system_files_max: 10/);
+  });
+
+  it('resolves other files with keep-both strategy', () => {
+    const otherFile = join(dir, '.context', 'main.md');
+    writeFileSync(
+      otherFile,
+      ['# Project', makeConflict('## Our section', '## Their section')].join('\n'),
+    );
+
+    run('resolve', dir);
+    const resolved = readFileSync(otherFile, 'utf-8');
+    assert.ok(!resolved.includes('<<<<<<<'));
+    assert.match(resolved, /Our section/);
+    assert.match(resolved, /Their section/);
+    assert.match(resolved, /merged/);
+  });
+
+  it('handles multiple conflict blocks in one file', () => {
+    const memFile = join(dir, '.context', 'memory', 'multi.md');
+    writeFileSync(
+      memFile,
+      [
+        '# Multi',
+        makeConflict('- block1-ours', '- block1-theirs'),
+        '- shared middle line',
+        makeConflict('- block2-ours', '- block2-theirs'),
+      ].join('\n'),
+    );
+
+    run('resolve', dir);
+    const resolved = readFileSync(memFile, 'utf-8');
+    assert.ok(!resolved.includes('<<<<<<<'));
+    assert.match(resolved, /block1-ours/);
+    assert.match(resolved, /block1-theirs/);
+    assert.match(resolved, /shared middle line/);
+    assert.match(resolved, /block2-ours/);
+    assert.match(resolved, /block2-theirs/);
+  });
+
+  it('dry-run shows strategy without modifying files', () => {
+    const memFile = join(dir, '.context', 'memory', 'drytest.md');
+    writeFileSync(memFile, makeConflict('ours', 'theirs'));
+
+    const out = run('resolve --dry-run', dir);
+    assert.match(out, /dry run/);
+
+    const content = readFileSync(memFile, 'utf-8');
+    assert.ok(content.includes('<<<<<<<'), 'should not modify file in dry-run');
+  });
+});

package/src/commands/search.js

@@ -0,0 +1,70 @@
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { buildTree, readContextFile } from '../core/fs.js';
+import { readConfig } from '../core/config.js';
+
+export default async function search({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+
+  if (!args.length) {
+    console.error('❌ Usage: agent-mem search <query>');
+    process.exit(1);
+  }
+
+  const config = readConfig(ctxDir);
+  const branch = config.branch || 'main';
+  const query = args.join(' ').toLowerCase();
+  const tree = buildTree(ctxDir);
+
+  // When on a branch, search branch memory first, then system/ and global memory
+  // Skip global memory/ duplicates to avoid noise
+  const files = tree.filter((e) => !e.isDir);
+  const branchMemPrefix = branch !== 'main' ? `branches/${branch}/memory/` : null;
+
+  const searchFiles = branchMemPrefix
+    ? files.filter((f) => {
+        // Include branch memory, system/, reflections, config — skip global memory/
+        if (f.path.startsWith(branchMemPrefix)) return true;
+        if (f.path.startsWith('memory/')) return false;
+        return true;
+      })
+    : files;
+
+  const results = [];
+
+  for (const file of searchFiles) {
+    const content = readContextFile(ctxDir, file.path);
+    if (!content) continue;
+
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].toLowerCase().includes(query)) {
+        results.push({
+          path: file.path,
+          line: i + 1,
+          text: lines[i].trim(),
+        });
+      }
+    }
+  }
+
+  if (!results.length) {
+    console.log(`🔍 SEARCH: "${args.join(' ')}"\nNo results found.`);
+    return;
+  }
+
+  const branchLabel = branchMemPrefix ? ` [branch: ${branch}]` : '';
+  console.log(`🔍 SEARCH${branchLabel}: "${args.join(' ')}" (${results.length} matches)\n`);
+
+  // Group by file, show top 20
+  const shown = results.slice(0, 20);
+  for (let i = 0; i < shown.length; i++) {
+    const r = shown[i];
+    const preview = r.text.length > 100 ? r.text.slice(0, 97) + '...' : r.text;
+    console.log(`${i + 1}. ${r.path}:${r.line} — ${preview}`);
+  }
+
+  if (results.length > 20) {
+    console.log(`\n... and ${results.length - 20} more matches`);
+  }
+}

package/src/commands/share.js

@@ -0,0 +1,65 @@
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { createHash } from 'node:crypto';
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { buildTree, readContextFile } from '../core/fs.js';
+import { readConfig } from '../core/config.js';
+import { commitCount, lastCommit } from '../core/git.js';
+
+/**
+ * Generate a portable context snapshot that can be shared with anyone.
+ *
+ * agent-mem share                    — generate snapshot file
+ * agent-mem share --output <path>    — custom output path
+ * agent-mem import <file-or-url>     — import a shared snapshot
+ */
+export default async function share({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+
+  const config = readConfig(ctxDir);
+  const projectName = basename(root);
+  const commits = commitCount(ctxDir);
+  const last = lastCommit(ctxDir);
+
+  // Gather all context into a single portable object
+  const tree = buildTree(ctxDir);
+  const files = {};
+
+  for (const entry of tree) {
+    if (entry.isDir) continue;
+    const content = readContextFile(ctxDir, entry.path);
+    if (content !== null) {
+      files[entry.path] = content;
+    }
+  }
+
+  const snapshot = {
+    version: 1,
+    tool: 'agent-mem',
+    project: projectName,
+    branch: config.branch || 'main',
+    commits,
+    lastCommit: last,
+    createdAt: new Date().toISOString(),
+    files,
+  };
+
+  const json = JSON.stringify(snapshot, null, 2);
+  const hash = createHash('sha256').update(json).digest('hex').slice(0, 8);
+  const filename = `context-${projectName}-${hash}.json`;
+
+  const outputPath = flags.output || join(root, filename);
+  writeFileSync(outputPath, json);
+
+  const fileCount = Object.keys(files).length;
+  const sizeKb = (Buffer.byteLength(json) / 1024).toFixed(1);
+
+  console.log(`✅ SHARED: ${filename}`);
+  console.log(`  Project: ${projectName}`);
+  console.log(`  Files: ${fileCount} | Size: ${sizeKb} KB | Commits: ${commits}`);
+  console.log(`  Path: ${outputPath}`);
+  console.log('');
+  console.log('To import on another machine:');
+  console.log(`  agent-mem import ${filename}`);
+}

package/src/commands/snapshot.js

@@ -0,0 +1,106 @@
+import { join } from 'node:path';
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { buildTree, readContextFile, countFiles } from '../core/fs.js';
+import { readConfig } from '../core/config.js';
+import { commitCount, lastCommit, hasChanges } from '../core/git.js';
+
+export default async function snapshot({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+  const config = readConfig(ctxDir);
+  const projectName = root.split('/').pop();
+
+  const commits = commitCount(ctxDir);
+  const last = lastCommit(ctxDir);
+  const dirty = hasChanges(ctxDir);
+  const branch = config.branch || 'main';
+
+  const tree = buildTree(ctxDir);
+
+  // Header
+  const lines = [
+    `📋 CONTEXT SNAPSHOT`,
+    `Project: ${projectName} | Branch: ${branch} | Commits: ${commits}${dirty ? ' (uncommitted changes)' : ''}`,
+    last ? `Last commit: "${last.message}" (${last.timeAgo})` : '',
+    '',
+  ];
+
+  // System files (pinned — show full content)
+  const systemFiles = tree.filter((e) => e.path.startsWith('system/') && !e.isDir);
+  if (systemFiles.length) {
+    lines.push('PINNED (system/) — always in agent context:');
+    for (const f of systemFiles) {
+      const content = readContextFile(ctxDir, f.path);
+      if (content) {
+        // Strip frontmatter for display
+        const stripped = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+        const preview = stripped.length > 500 ? stripped.slice(0, 497) + '...' : stripped;
+        lines.push(`  --- ${f.path} ---`);
+        lines.push(`  ${preview.split('\n').join('\n  ')}`);
+        lines.push('');
+      }
+    }
+  }
+
+  // Memory files — branch-scoped when on a branch
+  const branchMemPrefix = branch !== 'main' ? `branches/${branch}/memory/` : null;
+  const branchMemFiles = branchMemPrefix
+    ? tree.filter((e) => e.path.startsWith(branchMemPrefix) && !e.isDir)
+    : [];
+  const globalMemFiles = tree.filter((e) => e.path.startsWith('memory/') && !e.isDir);
+
+  if (branchMemPrefix && branchMemFiles.length) {
+    lines.push(`MEMORY [branch: ${branch}] (${branchMemFiles.length} files):`);
+    for (const f of branchMemFiles) {
+      lines.push(`  ${f.name} — ${f.description || '(no description)'}`);
+    }
+    lines.push('');
+  }
+
+  if (branchMemPrefix && globalMemFiles.length) {
+    lines.push(
+      `MEMORY [main] (${globalMemFiles.length} files — use 'amem read memory/<file>' for global):`,
+    );
+    for (const f of globalMemFiles) {
+      lines.push(`  ${f.name} — ${f.description || '(no description)'}`);
+    }
+    lines.push('');
+  } else if (!branchMemPrefix && globalMemFiles.length) {
+    lines.push(`MEMORY (${globalMemFiles.length} files):`);
+    for (const f of globalMemFiles) {
+      lines.push(`  ${f.name} — ${f.description || '(no description)'}`);
+    }
+    lines.push('');
+  }
+
+  // Branches
+  const branchEntries = tree.filter(
+    (e) => e.path.startsWith('branches/') && e.isDir && e.depth === 1,
+  );
+  if (branchEntries.length) {
+    lines.push(`BRANCHES (${branchEntries.length}):`);
+    for (const b of branchEntries) {
+      const purpose = readContextFile(ctxDir, `${b.path}/purpose.md`);
+      const purposeLine =
+        purpose?.split('\n').find((l) => l.trim() && !l.startsWith('#') && !l.startsWith('---')) ||
+        '';
+      lines.push(`  ${b.name} — ${purposeLine.trim() || '(no purpose set)'}`);
+    }
+    lines.push('');
+  }
+
+  // Reflections
+  const reflectionFiles = tree.filter((e) => e.path.startsWith('reflections/') && !e.isDir);
+  if (reflectionFiles.length) {
+    const latest = reflectionFiles[reflectionFiles.length - 1];
+    lines.push(`REFLECTIONS: ${reflectionFiles.length} total, latest: ${latest.name}`);
+    lines.push('');
+  }
+
+  // Config summary
+  lines.push(
+    `CONFIG: auto_commit=${config.auto_commit} | reflection=${config.reflection?.trigger || 'manual'}`,
+  );
+
+  console.log(lines.filter((l) => l !== undefined).join('\n'));
+}

package/src/commands/status.js

@@ -0,0 +1,37 @@
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { readConfig } from '../core/config.js';
+import { commitCount, lastCommit, hasChanges } from '../core/git.js';
+import { countFiles, listFiles } from '../core/fs.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export default async function status({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+  const config = readConfig(ctxDir);
+  const projectName = root.split('/').pop();
+
+  const commits = commitCount(ctxDir);
+  const last = lastCommit(ctxDir);
+  const dirty = hasChanges(ctxDir);
+  const systemCount = countFiles(ctxDir, 'system');
+  const memoryCount = countFiles(ctxDir, 'memory');
+  const reflectionCount = countFiles(ctxDir, 'reflections');
+
+  // Count branches
+  const branchDir = join(ctxDir, 'branches');
+  const branchCount = existsSync(branchDir) ? listFiles(ctxDir, 'branches').length : 0;
+
+  console.log(`📊 STATUS: ${projectName}`);
+  console.log(
+    `Branch: ${config.branch || 'main'} | Commits: ${commits}${dirty ? ' ⚠️ uncommitted changes' : ''}`,
+  );
+  if (last) console.log(`Last: "${last.message}" (${last.timeAgo})`);
+  console.log(
+    `Files: ${systemCount} pinned, ${memoryCount} memory, ${reflectionCount} reflections`,
+  );
+  console.log(`Branches: ${branchCount}`);
+  console.log(
+    `Config: auto_commit=${config.auto_commit} | reflection=${config.reflection?.trigger || 'manual'}`,
+  );
+}