@lmaksym/agent-mem 0.1.0

package/src/commands/compact.js

@@ -0,0 +1,307 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { readContextFile, writeContextFile, listFiles } from '../core/fs.js';
+import { commitContext, hasChanges } from '../core/git.js';
+import { readConfig } from '../core/config.js';
+
+/**
+ * Calculate total byte size of all readable files in .context/.
+ */
+function contextByteSize(ctxDir) {
+  let total = 0;
+  const walk = (dir) => {
+    if (!existsSync(dir)) return;
+    for (const name of readdirSync(dir)) {
+      if (name.startsWith('.')) continue;
+      const full = join(dir, name);
+      const stat = statSync(full);
+      if (stat.isDirectory()) walk(full);
+      else total += stat.size;
+    }
+  };
+  walk(ctxDir);
+  return total;
+}
+
+/**
+ * Collect all entry lines from a memory file with dates.
+ * Handles both bullet entries (- [date]) and block entries (### [date] for lessons).
+ * Returns { header: string, entries: Array<{ line: string, date: Date|null, raw: string }> }
+ */
+function parseMemoryFile(content) {
+  const lines = content.split('\n');
+  const headerLines = [];
+  const entries = [];
+  let inHeader = true;
+  let currentBlock = null;
+
+  for (const line of lines) {
+    // Block entry (lessons): ### [2026-02-21 14:30] Title
+    const blockMatch = line.match(/^### \[(\d{4}-\d{2}-\d{2})[\s\d:]*\]\s*.+/);
+    if (blockMatch) {
+      // Push previous block if any
+      if (currentBlock) {
+        entries.push(currentBlock);
+      }
+      inHeader = false;
+      currentBlock = {
+        line: line,
+        date: new Date(blockMatch[1]),
+        raw: line,
+        isStale: false,
+        _blockLines: [line],
+      };
+      continue;
+    }
+
+    // If we're inside a block, accumulate lines
+    if (currentBlock) {
+      currentBlock._blockLines.push(line);
+      currentBlock.line = currentBlock._blockLines.join('\n');
+      currentBlock.raw = currentBlock.line;
+      continue;
+    }
+
+    const entryMatch = line.match(/^- \[(\d{4}-\d{2}-\d{2})[\s\d:]*\]\s*.+/);
+    // Also catch stale markers
+    const staleMarker = line.match(/^- \[\d{4}-\d{2}-\d{2} STALE\]/);
+
+    if (entryMatch) {
+      inHeader = false;
+      entries.push({
+        line,
+        date: new Date(entryMatch[1]),
+        raw: line,
+        isStale: false,
+      });
+    } else if (staleMarker) {
+      inHeader = false;
+      // Skip stale markers — they'll be dropped in compact
+    } else if (inHeader || (!entryMatch && entries.length === 0)) {
+      headerLines.push(line);
+    }
+    // Lines after entries that aren't entries (blank lines between entries, etc.)
+  }
+
+  // Push last block if any
+  if (currentBlock) {
+    entries.push(currentBlock);
+  }
+
+  return { header: headerLines.join('\n'), entries };
+}
+
+/**
+ * Determine which memory entries to keep based on mode.
+ * Default: keep entries from last 7 days + pinned file entries always kept.
+ * Hard: discard all non-pinned memory entries.
+ */
+function selectEntries(entries, mode, config) {
+  if (mode === 'hard') return []; // Hard mode: archive everything
+
+  const retainDays = config.compact?.retain_days || 7;
+  const cutoff = new Date(Date.now() - retainDays * 24 * 60 * 60 * 1000);
+
+  return entries.filter((e) => e.date && e.date >= cutoff);
+}
+
+export default async function compact({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+  const config = readConfig(ctxDir);
+
+  const isDryRun = flags['dry-run'] === true;
+  const isHard = flags.hard === true;
+  const mode = isHard ? 'hard' : 'default';
+
+  // 1. Measure before size
+  const beforeBytes = contextByteSize(ctxDir);
+
+  // 2. Safety checkpoint (auto-commit before compact)
+  if (!isDryRun && hasChanges(ctxDir)) {
+    const hash = commitContext(ctxDir, 'compact: pre-compact checkpoint');
+    if (hash) {
+      console.log(`💾 Pre-compact checkpoint: ${hash}`);
+    }
+  }
+
+  // 3. Identify what to keep vs archive
+  const kept = [];
+  const archived = [];
+
+  // 3a. System/ (pinned) — ALWAYS kept
+  const systemFiles = listFiles(ctxDir, 'system');
+  for (const name of systemFiles) {
+    kept.push({ path: `system/${name}`, reason: 'pinned' });
+  }
+
+  // 3b. Memory files — filter entries by recency (or archive all in hard mode)
+  const memDir = join(ctxDir, 'memory');
+  if (existsSync(memDir)) {
+    const memFiles = readdirSync(memDir).filter((n) => n.endsWith('.md') && !n.startsWith('.'));
+
+    for (const name of memFiles) {
+      const relPath = `memory/${name}`;
+      const content = readContextFile(ctxDir, relPath);
+      if (!content) continue;
+
+      const { header, entries } = parseMemoryFile(content);
+      const keepEntries = selectEntries(entries, mode, config);
+      const dropEntries = entries.filter((e) => !keepEntries.includes(e));
+
+      if (dropEntries.length > 0) {
+        archived.push({
+          path: relPath,
+          entriesDropped: dropEntries.length,
+          entriesKept: keepEntries.length,
+          reason: mode === 'hard' ? 'hard mode' : 'stale (older than retain window)',
+        });
+      }
+
+      if (keepEntries.length > 0) {
+        kept.push({
+          path: relPath,
+          entries: keepEntries.length,
+          reason: mode === 'hard' ? 'n/a' : 'recent',
+        });
+      }
+
+      // Apply changes (if not dry run)
+      if (!isDryRun && dropEntries.length > 0) {
+        // Archive dropped entries
+        const archivePath = `archive/compact-${new Date().toISOString().slice(0, 10)}/${name}`;
+        const archiveContent = header + '\n' + dropEntries.map((e) => e.line).join('\n') + '\n';
+        writeContextFile(ctxDir, archivePath, archiveContent);
+
+        if (keepEntries.length > 0) {
+          // Rewrite memory file with only kept entries
+          const newContent = header + '\n' + keepEntries.map((e) => e.line).join('\n') + '\n';
+          writeContextFile(ctxDir, relPath, newContent);
+        } else {
+          // Archive entire file — rewrite as empty with header only
+          writeContextFile(ctxDir, relPath, header + '\n');
+        }
+      }
+    }
+  }
+
+  // 3c. Reflections — archive all except latest in default, archive all in hard
+  const refDir = join(ctxDir, 'reflections');
+  if (existsSync(refDir)) {
+    const refFiles = readdirSync(refDir)
+      .filter((n) => n.endsWith('.md'))
+      .sort();
+    const keepCount = mode === 'hard' ? 0 : 1;
+    const toArchive = refFiles.slice(0, refFiles.length - keepCount);
+    const toKeep = refFiles.slice(refFiles.length - keepCount);
+
+    for (const name of toKeep) {
+      kept.push({ path: `reflections/${name}`, reason: 'latest reflection' });
+    }
+
+    for (const name of toArchive) {
+      archived.push({ path: `reflections/${name}`, reason: 'older reflection' });
+
+      if (!isDryRun) {
+        const relPath = `reflections/${name}`;
+        const content = readContextFile(ctxDir, relPath);
+        const archivePath = `archive/compact-${new Date().toISOString().slice(0, 10)}/${relPath}`;
+        writeContextFile(ctxDir, archivePath, content);
+        // Remove original after archiving
+        const fullPath = join(ctxDir, relPath);
+        if (existsSync(fullPath)) {
+          unlinkSync(fullPath);
+        }
+      }
+    }
+  }
+
+  // 3d. Branches metadata — always kept (lightweight)
+  const branchDir = join(ctxDir, 'branches');
+  if (existsSync(branchDir)) {
+    const branches = readdirSync(branchDir).filter((n) => {
+      const full = join(branchDir, n);
+      return existsSync(full) && statSync(full).isDirectory();
+    });
+    if (branches.length > 0) {
+      kept.push({ path: 'branches/', reason: 'branch metadata', count: branches.length });
+    }
+  }
+
+  // 3e. Config — always kept
+  if (existsSync(join(ctxDir, 'config.yaml'))) {
+    kept.push({ path: 'config.yaml', reason: 'configuration' });
+  }
+
+  // 4. Measure after size
+  const afterBytes = isDryRun ? beforeBytes : contextByteSize(ctxDir);
+
+  // 5. Commit compaction
+  let commitHash = null;
+  if (!isDryRun && archived.length > 0) {
+    const msg =
+      mode === 'hard'
+        ? `compact --hard: archived ${archived.length} items, kept pins only`
+        : `compact: archived ${archived.length} items, kept recent + pins`;
+    commitHash = commitContext(ctxDir, msg);
+  }
+
+  // 6. Output report
+  const marker = isDryRun ? ' (dry run)' : '';
+  const modeLabel = mode === 'hard' ? ' --hard' : '';
+  console.log(`🗜️  COMPACT${modeLabel}${marker}`);
+  console.log('');
+
+  if (kept.length > 0) {
+    console.log('KEPT:');
+    for (const k of kept) {
+      const extra = k.entries ? ` (${k.entries} entries)` : k.count ? ` (${k.count})` : '';
+      console.log(`  ✅ ${k.path}${extra} — ${k.reason}`);
+    }
+    console.log('');
+  }
+
+  if (archived.length > 0) {
+    console.log('ARCHIVED:');
+    for (const a of archived) {
+      const extra = a.entriesDropped
+        ? ` (${a.entriesDropped} entries dropped, ${a.entriesKept} kept)`
+        : '';
+      console.log(`  📦 ${a.path}${extra} — ${a.reason}`);
+    }
+    console.log('');
+  }
+
+  if (archived.length === 0) {
+    console.log('Nothing to compact — context is already lean.');
+    console.log('');
+  }
+
+  // Token delta (byte-based approximation)
+  const delta = beforeBytes - afterBytes;
+  const pct = beforeBytes > 0 ? ((delta / beforeBytes) * 100).toFixed(1) : '0.0';
+  console.log(
+    `SIZE: ${formatBytes(beforeBytes)} → ${formatBytes(afterBytes)} (${delta > 0 ? '-' : '+'}${formatBytes(Math.abs(delta))}, ${pct}% reduction)`,
+  );
+
+  if (!isDryRun && archived.length > 0) {
+    const today = new Date().toISOString().slice(0, 10);
+    console.log(`ARCHIVE: .context/archive/compact-${today}/`);
+  }
+
+  if (commitHash) {
+    console.log(`COMMIT: ${commitHash}`);
+  }
+
+  if (isDryRun && archived.length > 0) {
+    console.log('');
+    console.log('Run without --dry-run to apply.');
+  }
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/src/commands/compact.test.js

@@ -0,0 +1,110 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, 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 });
+}
+
+describe('compact', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-compact-'));
+    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' });
+
+    // Init context
+    run('init', dir);
+
+    // Add some memory entries — mix of old and recent
+    const ctxDir = join(dir, '.context');
+    const memDir = join(ctxDir, 'memory');
+
+    const oldDate = '2025-01-01';
+    const recentDate = new Date().toISOString().slice(0, 10);
+
+    const decisionsContent = [
+      '---',
+      'description: "Decisions"',
+      '---',
+      '',
+      '# Decisions',
+      '',
+      `- [${oldDate} 10:00] Use PostgreSQL for primary storage`,
+      `- [${oldDate} 11:00] Choose FastAPI over Flask`,
+      `- [${recentDate} 09:00] Switch to connection pooling`,
+    ].join('\n');
+
+    writeFileSync(join(memDir, 'decisions.md'), decisionsContent);
+
+    // Add a pinned file
+    mkdirSync(join(ctxDir, 'system'), { recursive: true });
+    writeFileSync(join(ctxDir, 'system', 'task.md'), '# Current Task\nBuild compact command');
+
+    // Commit so we have a clean state
+    execSync("git add -A && git commit -m 'setup'", { cwd: dir, stdio: 'ignore' });
+  });
+
+  after(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('dry-run shows what would be archived without changes', () => {
+    const out = run('compact --dry-run', dir);
+    assert.match(out, /COMPACT/);
+    assert.match(out, /dry run/);
+    assert.match(out, /system\/task\.md/);
+    assert.match(out, /pinned/);
+    // Should not create archive directory
+    assert.ok(!existsSync(join(dir, '.context', 'archive')));
+  });
+
+  it('default compact archives old entries, keeps recent + pins', () => {
+    const out = run('compact', dir);
+    assert.match(out, /COMPACT/);
+    assert.match(out, /KEPT/);
+    assert.match(out, /ARCHIVED/);
+    assert.match(out, /system\/task\.md.*pinned/);
+
+    // Archive should exist
+    assert.ok(existsSync(join(dir, '.context', 'archive')));
+
+    // Decisions file should still have the recent entry
+    const decisions = readFileSync(join(dir, '.context', 'memory', 'decisions.md'), 'utf-8');
+    assert.match(decisions, /connection pooling/);
+    // Old entries should be gone from the file
+    assert.ok(!decisions.includes('Use PostgreSQL'));
+  });
+
+  it('--hard keeps only pins, archives everything else', () => {
+    // Re-add some entries
+    const ctxDir = join(dir, '.context');
+    const recentDate = new Date().toISOString().slice(0, 10);
+    const content = [
+      '---',
+      'description: "Patterns"',
+      '---',
+      '',
+      '# Patterns',
+      '',
+      `- [${recentDate} 10:00] Always use typed responses`,
+    ].join('\n');
+    writeFileSync(join(ctxDir, 'memory', 'patterns.md'), content);
+    execSync("git add -A && git commit -m 'add patterns'", { cwd: dir, stdio: 'ignore' });
+
+    const out = run('compact --hard', dir);
+    assert.match(out, /--hard/);
+    assert.match(out, /system\/task\.md.*pinned/);
+
+    // Patterns file should be emptied (entries archived)
+    const patterns = readFileSync(join(ctxDir, 'memory', 'patterns.md'), 'utf-8');
+    assert.ok(!patterns.includes('Always use typed responses'));
+  });
+});

package/src/commands/config.js

@@ -0,0 +1,47 @@
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { readConfig, writeConfig } from '../core/config.js';
+
+export default async function config({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+  const cfg = readConfig(ctxDir);
+
+  // config set <key> <value>
+  if (args[0] === 'set' && args.length >= 3) {
+    const key = args[1];
+    const val = args[2];
+
+    // Handle nested keys (e.g., reflection.trigger)
+    const parts = key.split('.');
+    if (parts.length === 2 && cfg[parts[0]] && typeof cfg[parts[0]] === 'object') {
+      cfg[parts[0]][parts[1]] = parseConfigVal(val);
+    } else {
+      cfg[key] = parseConfigVal(val);
+    }
+
+    writeConfig(ctxDir, cfg);
+    console.log(`✅ CONFIG: ${key} = ${val}`);
+    return;
+  }
+
+  // Show config
+  console.log(`⚙️  CONFIG (.context/config.yaml):\n`);
+  for (const [key, val] of Object.entries(cfg)) {
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+      console.log(`  ${key}:`);
+      for (const [k, v] of Object.entries(val)) {
+        console.log(`    ${k}: ${v}`);
+      }
+    } else {
+      console.log(`  ${key}: ${val}`);
+    }
+  }
+}
+
+function parseConfigVal(s) {
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  if (s === 'null') return null;
+  if (/^\d+$/.test(s)) return parseInt(s, 10);
+  return s;
+}

package/src/commands/core.test.js

@@ -0,0 +1,166 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } 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');
+const run = (args, cwd) =>
+  execSync(`node ${CLI} ${args}`, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+
+describe('snapshot', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-test-snap-'));
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify({ name: 'snap-test', dependencies: { express: '4' } }),
+    );
+    run('init', dir);
+  });
+
+  after(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('shows context snapshot', () => {
+    const out = run('snapshot', dir);
+    assert.ok(out.includes('CONTEXT SNAPSHOT'));
+    assert.ok(out.includes('PINNED'));
+  });
+
+  it('shows stack in pinned files', () => {
+    const out = run('snapshot', dir);
+    assert.ok(out.includes('Express'));
+  });
+});
+
+describe('read / write', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-test-rw-'));
+    writeFileSync(join(dir, 'package.json'), '{}');
+    run('init', dir);
+  });
+
+  after(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('reads existing files', () => {
+    const out = run('read system/project.md', dir);
+    assert.ok(out.includes('rw-')); // part of temp dir name in project name
+  });
+
+  it('writes new files', () => {
+    run('write memory/test.md --content "hello world"', dir);
+    const content = readFileSync(join(dir, '.context/memory/test.md'), 'utf-8');
+    assert.equal(content, 'hello world');
+  });
+
+  it('fails on nonexistent file', () => {
+    assert.throws(() => run('read nonexistent.md', dir));
+  });
+});
+
+describe('commit', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-test-commit-'));
+    writeFileSync(join(dir, 'package.json'), '{}');
+    run('init', dir);
+  });
+
+  after(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('reports nothing to commit when clean', () => {
+    const out = run('commit', dir);
+    assert.ok(out.includes('No changes'));
+  });
+
+  it('commits after changes', () => {
+    run('write memory/test.md --content "test data"', dir);
+    const out = run('commit test checkpoint', dir);
+    assert.ok(out.includes('COMMITTED'));
+    assert.ok(out.includes('test checkpoint'));
+  });
+});
+
+describe('status', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-test-status-'));
+    writeFileSync(join(dir, 'package.json'), '{}');
+    run('init', dir);
+  });
+
+  after(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('shows status', () => {
+    const out = run('status', dir);
+    assert.ok(out.includes('STATUS'));
+    assert.ok(out.includes('Commits: 1'));
+    assert.ok(out.includes('pinned'));
+  });
+});
+
+describe('remember', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-test-rem-'));
+    writeFileSync(join(dir, 'package.json'), '{}');
+    run('init', dir);
+  });
+
+  after(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('remembers decisions', () => {
+    run('remember --decision "chose X over Y"', dir);
+    const content = readFileSync(join(dir, '.context/memory/decisions.md'), 'utf-8');
+    assert.ok(content.includes('chose X over Y'));
+  });
+
+  it('remembers patterns', () => {
+    run('remember --pattern "always check logs"', dir);
+    const content = readFileSync(join(dir, '.context/memory/patterns.md'), 'utf-8');
+    assert.ok(content.includes('always check logs'));
+  });
+
+  it('remembers mistakes', () => {
+    run('remember --mistake "never force push"', dir);
+    const content = readFileSync(join(dir, '.context/memory/mistakes.md'), 'utf-8');
+    assert.ok(content.includes('never force push'));
+  });
+
+  it('defaults to notes', () => {
+    run('remember just a note', dir);
+    const content = readFileSync(join(dir, '.context/memory/notes.md'), 'utf-8');
+    assert.ok(content.includes('just a note'));
+  });
+});
+
+describe('search', () => {
+  let dir;
+
+  before(() => {
+    dir = mkdtempSync(join(tmpdir(), 'amem-test-search-'));
+    writeFileSync(join(dir, 'package.json'), '{}');
+    run('init', dir);
+    run('remember --decision "chose PostgreSQL for persistence"', dir);
+  });
+
+  after(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('finds matching text', () => {
+    const out = run('search PostgreSQL', dir);
+    assert.ok(out.includes('PostgreSQL'));
+    assert.ok(out.includes('decisions.md'));
+  });
+
+  it('reports no results for missing query', () => {
+    const out = run('search zzzznonexistent', dir);
+    assert.ok(out.includes('No results'));
+  });
+});