@lmaksym/agent-mem 0.1.0

package/src/commands/switch.js

@@ -0,0 +1,31 @@
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { readConfig, writeConfig } from '../core/config.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export default async function switchBranch({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+
+  if (!args.length) {
+    console.error('❌ Usage: agent-mem switch <branch-name>');
+    process.exit(1);
+  }
+
+  const name = args[0];
+
+  if (name !== 'main') {
+    const branchDir = join(ctxDir, 'branches', name);
+    if (!existsSync(branchDir)) {
+      console.error(`❌ Branch "${name}" not found. Run 'agent-mem branches' to see available.`);
+      process.exit(1);
+    }
+  }
+
+  const config = readConfig(ctxDir);
+  const prev = config.branch || 'main';
+  config.branch = name;
+  writeConfig(ctxDir, config);
+
+  console.log(`✅ SWITCHED: ${prev} → ${name}`);
+}

package/src/commands/sync.js

@@ -0,0 +1,328 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { buildTree, readContextFile } from '../core/fs.js';
+import { readConfig } from '../core/config.js';
+
+const TARGETS = {
+  claude: { file: 'CLAUDE.md', description: 'Claude Code' },
+  gemini: { file: 'GEMINI.md', description: 'Gemini CLI' },
+  codex: { file: 'AGENTS.md', description: 'Codex' },
+  cursor: { dir: '.cursor/rules', description: 'Cursor' },
+  windsurf: { file: '.windsurfrules', dir: '.windsurf/rules', description: 'Windsurf' },
+};
+
+export default async function sync({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+  const config = readConfig(ctxDir);
+
+  // Determine targets
+  let targets = [];
+
+  if (flags.all) {
+    targets = Object.keys(TARGETS);
+  } else {
+    for (const key of Object.keys(TARGETS)) {
+      if (flags[key]) targets.push(key);
+    }
+  }
+
+  // Auto-detect if no flags: sync to whatever already exists in the project
+  if (!targets.length) {
+    for (const [key, target] of Object.entries(TARGETS)) {
+      const fileExists = target.file && existsSync(join(root, target.file));
+      const dirExists = target.dir && existsSync(join(root, target.dir));
+      if (fileExists || dirExists) targets.push(key);
+    }
+    if (!targets.length) {
+      console.log('ℹ️  No sync targets detected. Use flags to specify:');
+      console.log('  agent-mem sync --claude     → CLAUDE.md');
+      console.log('  agent-mem sync --gemini     → GEMINI.md');
+      console.log('  agent-mem sync --codex      → AGENTS.md');
+      console.log('  agent-mem sync --cursor     → .cursor/rules/');
+      console.log('  agent-mem sync --windsurf   → .windsurfrules');
+      console.log('  agent-mem sync --all        → all of the above');
+      return;
+    }
+    console.log(
+      `🔍 Auto-detected targets: ${targets.map((t) => TARGETS[t].description).join(', ')}\n`,
+    );
+  }
+
+  // Gather system/ content
+  const systemContent = gatherSystemContent(ctxDir);
+  const memoryContent = gatherMemorySummary(ctxDir);
+
+  for (const target of targets) {
+    switch (target) {
+      case 'claude':
+        syncSingleFile(root, 'CLAUDE.md', buildClaudeMd(systemContent, memoryContent, config));
+        break;
+      case 'gemini':
+        syncSingleFile(root, 'GEMINI.md', buildGeminiMd(systemContent, memoryContent, config));
+        break;
+      case 'codex':
+        syncSingleFile(root, 'AGENTS.md', buildAgentsMd(systemContent, memoryContent, config));
+        break;
+      case 'cursor':
+        syncCursorRules(root, ctxDir);
+        break;
+      case 'windsurf':
+        syncWindsurf(root, ctxDir, systemContent, memoryContent);
+        break;
+    }
+  }
+
+  console.log(`\n✅ SYNCED .context/ → ${targets.map((t) => TARGETS[t].description).join(', ')}`);
+  console.log("Tip: run after 'agent-mem commit' to keep IDE rules up to date.");
+}
+
+/**
+ * Read all system/ files and return as structured content.
+ */
+function gatherSystemContent(ctxDir) {
+  const tree = buildTree(ctxDir);
+  const files = tree.filter((e) => !e.isDir && e.path.startsWith('system/'));
+  const sections = [];
+
+  for (const f of files) {
+    const raw = readContextFile(ctxDir, f.path);
+    if (!raw) continue;
+    // Strip frontmatter
+    const content = raw.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+    if (content) {
+      sections.push({ name: f.name, path: f.path, content });
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Build a short summary of memory/ files for inclusion.
+ */
+function gatherMemorySummary(ctxDir) {
+  const tree = buildTree(ctxDir);
+  const files = tree.filter((e) => !e.isDir && e.path.startsWith('memory/'));
+  if (!files.length) return '';
+
+  const lines = [
+    '## Key Decisions & Patterns',
+    '',
+    'From `.context/memory/` — run `agent-mem read <path>` for details:',
+    '',
+  ];
+
+  for (const f of files) {
+    const raw = readContextFile(ctxDir, f.path);
+    if (!raw) continue;
+    // Extract entries (bullet entries or lesson headings)
+    const bullets = raw.split('\n').filter((l) => l.startsWith('- [') || l.startsWith('### ['));
+    if (bullets.length) {
+      const lastThree = bullets.slice(-3);
+      lines.push(`### ${f.name.replace('.md', '')}`);
+      lines.push(...lastThree);
+      if (bullets.length > 3)
+        lines.push(`_(${bullets.length - 3} more — run \`agent-mem read ${f.path}\`)_`);
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ─── Shared trigger instructions ─────────────────────────────────────────────
+
+function buildTriggerInstructions() {
+  return [
+    '## agent-mem — when to use',
+    '',
+    '**Starting this session →** `amem snapshot` (load context + memory)',
+    '**You chose between alternatives →** `amem remember --decision "chose X because Y"`',
+    '**You noticed a repeatable approach →** `amem remember --pattern "always do X"`',
+    '**You did something wrong →** `amem remember --mistake "never do X"`',
+    '**You solved a problem after investigation →** `amem lesson "problem -> fix"`',
+    '**You completed meaningful work →** `amem commit "what you did"`',
+    '**You\'re about to try something risky →** `amem branch name "purpose"`',
+    '**Checking prior context →** `amem search "query"`',
+    '',
+  ].join('\n');
+}
+
+// ─── Target-specific builders ────────────────────────────────────────────────
+
+function buildClaudeMd(systemContent, memorySummary, config) {
+  const sections = [
+    '# Project Context',
+    '',
+    '_Auto-generated by agent-mem. Edit `.context/system/` files instead._',
+    '_Run `agent-mem sync --claude` to regenerate._',
+    '',
+  ];
+
+  for (const s of systemContent) {
+    sections.push(s.content);
+    sections.push('');
+  }
+
+  if (memorySummary) {
+    sections.push(memorySummary);
+  }
+
+  sections.push(buildTriggerInstructions());
+
+  return sections.join('\n');
+}
+
+function buildGeminiMd(systemContent, memorySummary, config) {
+  const sections = [
+    '# Project Context',
+    '',
+    '_Auto-generated by agent-mem. Edit `.context/system/` files instead._',
+    '_Run `agent-mem sync --gemini` to regenerate._',
+    '',
+  ];
+
+  for (const s of systemContent) {
+    sections.push(s.content);
+    sections.push('');
+  }
+
+  if (memorySummary) {
+    sections.push(memorySummary);
+  }
+
+  sections.push(buildTriggerInstructions());
+
+  return sections.join('\n');
+}
+
+function buildAgentsMd(systemContent, memorySummary, config) {
+  const sections = [
+    '# AGENTS.md',
+    '',
+    '_Auto-generated by agent-mem. Edit `.context/system/` files instead._',
+    '_Run `agent-mem sync --codex` to regenerate._',
+    '',
+  ];
+
+  for (const s of systemContent) {
+    sections.push(s.content);
+    sections.push('');
+  }
+
+  if (memorySummary) {
+    sections.push(memorySummary);
+  }
+
+  sections.push(buildTriggerInstructions());
+
+  return sections.join('\n');
+}
+
+/**
+ * Sync to Cursor: each system/ file becomes a .cursor/rules/ file.
+ * Cursor reads .cursor/rules/*.md with frontmatter.
+ */
+function syncCursorRules(root, ctxDir) {
+  const rulesDir = join(root, '.cursor', 'rules');
+  mkdirSync(rulesDir, { recursive: true });
+
+  const tree = buildTree(ctxDir);
+  const files = tree.filter((e) => !e.isDir && e.path.startsWith('system/'));
+
+  for (const f of files) {
+    const raw = readContextFile(ctxDir, f.path);
+    if (!raw) continue;
+
+    // Cursor rules use frontmatter with description and globs
+    const content = raw.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+    const ruleName = f.name.replace('.md', '');
+
+    const cursorRule = [
+      '---',
+      `description: "Project ${ruleName} (from agent-mem)"`,
+      'globs: **/*',
+      'alwaysApply: true',
+      '---',
+      '',
+      `_Auto-generated by agent-mem from .context/${f.path}_`,
+      '',
+      content,
+      '',
+    ].join('\n');
+
+    writeFileSync(join(rulesDir, `amem-${f.name}`), cursorRule);
+  }
+
+  // Write trigger instructions as a separate rule file
+  const triggerRule = [
+    '---',
+    'description: "agent-mem trigger instructions"',
+    'globs: **/*',
+    'alwaysApply: true',
+    '---',
+    '',
+    '_Auto-generated by agent-mem._',
+    '',
+    buildTriggerInstructions(),
+  ].join('\n');
+
+  writeFileSync(join(rulesDir, 'amem-triggers.md'), triggerRule);
+
+  console.log(`  📁 Cursor: ${files.length + 1} rules → .cursor/rules/amem-*.md`);
+}
+
+/**
+ * Sync to Windsurf: .windsurfrules (single file) + .windsurf/rules/*.md
+ */
+function syncWindsurf(root, ctxDir, systemContent, memorySummary) {
+  // Single file version
+  const sections = [
+    '# Project Rules',
+    '',
+    '_Auto-generated by agent-mem. Edit `.context/system/` files instead._',
+    '',
+  ];
+
+  for (const s of systemContent) {
+    sections.push(s.content);
+    sections.push('');
+  }
+
+  if (memorySummary) sections.push(memorySummary);
+
+  sections.push(buildTriggerInstructions());
+
+  writeFileSync(join(root, '.windsurfrules'), sections.join('\n'));
+  console.log(`  📄 Windsurf: .windsurfrules updated`);
+
+  // Also write individual rule files if .windsurf/rules/ exists or --windsurf explicit
+  const rulesDir = join(root, '.windsurf', 'rules');
+  mkdirSync(rulesDir, { recursive: true });
+
+  const tree = buildTree(ctxDir);
+  const files = tree.filter((e) => !e.isDir && e.path.startsWith('system/'));
+
+  for (const f of files) {
+    const raw = readContextFile(ctxDir, f.path);
+    if (!raw) continue;
+    const content = raw.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+
+    writeFileSync(
+      join(rulesDir, `amem-${f.name}`),
+      [`_Auto-generated by agent-mem from .context/${f.path}_`, '', content, ''].join('\n'),
+    );
+  }
+
+  console.log(`  📁 Windsurf: ${files.length} rules → .windsurf/rules/amem-*.md`);
+}
+
+/**
+ * Write a single file to project root.
+ */
+function syncSingleFile(root, filename, content) {
+  writeFileSync(join(root, filename), content);
+  console.log(`  📄 ${filename} updated (${content.length} chars)`);
+}

package/src/commands/track.js

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { contextDir as getContextDir } from '../core/context-root.js';
+
+/**
+ * Toggle whether .context/ is tracked in the project's git repo.
+ *
+ * agent-mem track          — show current status
+ * agent-mem track --enable — add .context/ to project git
+ * agent-mem track --disable — add .context/ to .gitignore
+ */
+export default async function track({ args, flags }) {
+  const root = flags._contextRoot;
+  const gitignorePath = join(root, '.gitignore');
+
+  const hasGitignore = existsSync(gitignorePath);
+  const gitignoreContent = hasGitignore ? readFileSync(gitignorePath, 'utf-8') : '';
+  const isIgnored = gitignoreContent
+    .split('\n')
+    .some((l) => l.trim() === '.context/' || l.trim() === '.context');
+
+  if (flags.enable) {
+    if (!isIgnored) {
+      console.log('✅ .context/ is already tracked (not in .gitignore).');
+      return;
+    }
+
+    // Remove .context/ from .gitignore
+    const lines = gitignoreContent
+      .split('\n')
+      .filter((l) => l.trim() !== '.context/' && l.trim() !== '.context');
+    writeFileSync(gitignorePath, lines.join('\n'));
+    console.log('✅ TRACKED: .context/ removed from .gitignore');
+    console.log('Context will be committed with your project code.');
+    console.log("Run: git add .context/ && git commit -m 'track agent context'");
+    return;
+  }
+
+  if (flags.disable) {
+    if (isIgnored) {
+      console.log('✅ .context/ is already ignored.');
+      return;
+    }
+
+    // Add .context/ to .gitignore
+    const newContent = gitignoreContent.trimEnd() + '\n\n# agent-mem (local only)\n.context/\n';
+    writeFileSync(gitignorePath, newContent);
+    console.log('✅ UNTRACKED: .context/ added to .gitignore');
+    console.log("Context stays local — use 'agent-mem push' to sync across machines.");
+    return;
+  }
+
+  // Status
+  console.log(`📊 TRACKING STATUS:`);
+  console.log(
+    `  .context/ is ${isIgnored ? 'IGNORED (local only)' : 'TRACKED (committed with project)'}`,
+  );
+  console.log('');
+  console.log('  agent-mem track --enable   — commit context with project');
+  console.log('  agent-mem track --disable  — keep context local only');
+}

package/src/commands/unpin.js

@@ -0,0 +1,28 @@
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { moveContextFile } from '../core/fs.js';
+import { existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+export default async function unpin({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+
+  if (!args.length) {
+    console.error('❌ Usage: agent-mem unpin <path>');
+    console.error('Example: agent-mem unpin system/old-conventions.md');
+    process.exit(1);
+  }
+
+  const relPath = args[0].startsWith('system/') ? args[0] : `system/${args[0]}`;
+  const name = basename(relPath);
+  const dest = `memory/${name}`;
+
+  if (!existsSync(join(ctxDir, relPath))) {
+    console.error(`❌ File not found: .context/${relPath}`);
+    process.exit(1);
+  }
+
+  moveContextFile(ctxDir, relPath, dest);
+  console.log(`📌 UNPINNED: ${relPath} → ${dest}`);
+  console.log(`File moved to memory/. It will show in tree but not be auto-loaded.`);
+}

package/src/commands/write.js

@@ -0,0 +1,58 @@
+import { contextDir as getContextDir } from '../core/context-root.js';
+import { writeContextFile, readContextFile } from '../core/fs.js';
+
+export default async function write({ args, flags }) {
+  const root = flags._contextRoot;
+  const ctxDir = getContextDir(root);
+
+  if (!args.length) {
+    console.error('❌ Usage: agent-mem write <path> --content <text>');
+    console.error("  Or pipe: echo 'content' | agent-mem write <path>");
+    process.exit(1);
+  }
+
+  const relPath = args[0];
+  let content = flags.content;
+
+  // If --content not provided, read from stdin
+  if (!content) {
+    // Remaining args as content
+    if (args.length > 1) {
+      content = args.slice(1).join(' ');
+    } else {
+      // Try stdin
+      content = await readStdin();
+    }
+  }
+
+  if (!content) {
+    console.error('❌ No content provided. Use --content or pipe stdin.');
+    process.exit(1);
+  }
+
+  const existed = readContextFile(ctxDir, relPath) !== null;
+  writeContextFile(ctxDir, relPath, content);
+
+  console.log(
+    `✅ ${existed ? 'UPDATED' : 'CREATED'}: .context/${relPath} (${content.length} chars)`,
+  );
+
+  // Auto-commit if enabled
+  const { maybeAutoCommit } = await import('../core/auto-commit.js');
+  maybeAutoCommit(ctxDir, `write ${relPath}`);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve(null);
+      return;
+    }
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => (data += chunk));
+    process.stdin.on('end', () => resolve(data || null));
+    // Timeout after 100ms if no data
+    setTimeout(() => resolve(data || null), 100);
+  });
+}

package/src/core/auto-commit.js

@@ -0,0 +1,22 @@
+import { readConfig } from './config.js';
+import { commitContext, commitCount } from './git.js';
+
+/**
+ * Check if auto-commit should fire, and commit if so.
+ * Tracks mutations via commit count modulo interval.
+ */
+export function maybeAutoCommit(contextDir, changeDescription) {
+  const config = readConfig(contextDir);
+  if (!config.auto_commit) return;
+
+  const interval = config.auto_commit_interval || 10;
+  const count = commitCount(contextDir);
+
+  // Simple heuristic: commit if we have uncommitted changes
+  // and count of commits since last is divisible by interval
+  // For now: just auto-commit every mutation when enabled
+  const hash = commitContext(contextDir, `auto: ${changeDescription}`);
+  if (hash) {
+    console.log(`  ⚡ Auto-committed: ${hash}`);
+  }
+}

package/src/core/config.js

@@ -0,0 +1,93 @@
+import { readContextFile, writeContextFile } from './fs.js';
+
+const DEFAULT_CONFIG = {
+  auto_commit: false,
+  auto_commit_interval: 10,
+  reflection: {
+    trigger: 'manual',
+    frequency: 5,
+    model: null,
+    defrag_threshold: 50,
+    defrag_size_kb: 10,
+    stale_days: 30,
+  },
+  compact: {
+    retain_days: 7,
+  },
+  system_files_max: 10,
+  memory_files_max: 25,
+  branch: 'main',
+};
+
+/**
+ * Read config from .context/config.yaml (simple YAML-like parser).
+ */
+export function readConfig(contextDir) {
+  const raw = readContextFile(contextDir, 'config.yaml');
+  if (!raw) return { ...DEFAULT_CONFIG };
+
+  // Simple YAML parser for flat + one-level nested
+  const config = { ...DEFAULT_CONFIG };
+  let currentSection = null;
+
+  for (const line of raw.split('\n')) {
+    if (line.startsWith('#') || !line.trim()) continue;
+
+    const indent = line.length - line.trimStart().length;
+    const match = line.trim().match(/^(\w[\w_]*)\s*:\s*(.*)$/);
+    if (!match) continue;
+
+    const [, key, rawVal] = match;
+    const val = parseVal(rawVal);
+
+    if (indent === 0) {
+      if (rawVal === '') {
+        // Section header
+        currentSection = key;
+        if (typeof config[key] !== 'object') config[key] = {};
+      } else {
+        config[key] = val;
+        currentSection = null;
+      }
+    } else if (currentSection && config[currentSection]) {
+      config[currentSection][key] = val;
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Write config to .context/config.yaml.
+ */
+export function writeConfig(contextDir, config) {
+  const lines = ['# agent-mem configuration'];
+
+  for (const [key, val] of Object.entries(config)) {
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+      lines.push(`${key}:`);
+      for (const [k, v] of Object.entries(val)) {
+        lines.push(`  ${k}: ${serializeVal(v)}`);
+      }
+    } else {
+      lines.push(`${key}: ${serializeVal(val)}`);
+    }
+  }
+
+  writeContextFile(contextDir, 'config.yaml', lines.join('\n') + '\n');
+}
+
+function parseVal(raw) {
+  const s = raw.trim().replace(/^['"]|['"]$/g, '');
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  if (s === 'null' || s === '') return null;
+  if (/^\d+$/.test(s)) return parseInt(s, 10);
+  return s;
+}
+
+function serializeVal(val) {
+  if (val === null || val === undefined) return 'null';
+  if (typeof val === 'boolean') return val ? 'true' : 'false';
+  return String(val);
+}

package/src/core/context-root.js

@@ -0,0 +1,28 @@
+import { existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+
+/**
+ * Walk up from `cwd` looking for a .context/ directory.
+ * Returns the project root (parent of .context/) or null.
+ */
+export function findContextRoot(cwd) {
+  let dir = resolve(cwd);
+  const root = dirname(dir) === dir ? dir : '/'; // filesystem root
+
+  while (true) {
+    if (existsSync(join(dir, '.context'))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break; // reached filesystem root
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Get the .context/ directory path from project root.
+ */
+export function contextDir(projectRoot) {
+  return join(projectRoot, '.context');
+}