@lmaksym/agent-mem 0.1.0

package/src/core/fs.js

@@ -0,0 +1,137 @@
+import {
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  existsSync,
+  renameSync,
+} from 'node:fs';
+import { join, relative, basename, dirname } from 'node:path';
+
+/**
+ * Read a file from .context/, returns content or null.
+ */
+export function readContextFile(contextDir, relPath) {
+  const fullPath = join(contextDir, relPath);
+  if (!existsSync(fullPath)) return null;
+  return readFileSync(fullPath, 'utf-8');
+}
+
+/**
+ * Write a file to .context/, creating directories as needed.
+ */
+export function writeContextFile(contextDir, relPath, content) {
+  const fullPath = join(contextDir, relPath);
+  mkdirSync(dirname(fullPath), { recursive: true });
+  writeFileSync(fullPath, content, 'utf-8');
+}
+
+/**
+ * Move a file within .context/.
+ */
+export function moveContextFile(contextDir, fromRel, toRel) {
+  const fromFull = join(contextDir, fromRel);
+  const toFull = join(contextDir, toRel);
+  if (!existsSync(fromFull)) throw new Error(`File not found: ${fromRel}`);
+  mkdirSync(dirname(toFull), { recursive: true });
+  renameSync(fromFull, toFull);
+}
+
+/**
+ * Parse frontmatter from a markdown file.
+ * Returns { description, limit, readOnly, content }.
+ */
+export function parseFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { description: null, limit: null, readOnly: false, content: text };
+
+  const frontmatter = match[1];
+  const content = match[2];
+  const desc = frontmatter.match(/description:\s*['"]?(.*?)['"]?\s*$/m)?.[1] || null;
+  const limit = frontmatter.match(/limit:\s*(\d+)/)?.[1]
+    ? parseInt(frontmatter.match(/limit:\s*(\d+)/)[1])
+    : null;
+  const readOnly = /read_only:\s*true/i.test(frontmatter);
+
+  return { description: desc, limit, readOnly, content };
+}
+
+/**
+ * Build a tree representation of .context/ directory.
+ * Returns array of { path, name, isDir, description, size }.
+ */
+export function buildTree(contextDir, subDir = '', depth = 0, maxDepth = 4) {
+  const entries = [];
+  const fullDir = join(contextDir, subDir);
+
+  if (!existsSync(fullDir)) return entries;
+  if (depth > maxDepth) return entries;
+
+  const items = readdirSync(fullDir)
+    .filter((n) => !n.startsWith('.'))
+    .sort();
+
+  for (const name of items) {
+    const relPath = subDir ? `${subDir}/${name}` : name;
+    const fullPath = join(fullDir, name);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      entries.push({ path: relPath, name, isDir: true, depth });
+      entries.push(...buildTree(contextDir, relPath, depth + 1, maxDepth));
+    } else if (name.endsWith('.md') || name.endsWith('.yaml') || name.endsWith('.yml')) {
+      const content = readFileSync(fullPath, 'utf-8');
+      const { description } = parseFrontmatter(content);
+      entries.push({
+        path: relPath,
+        name,
+        isDir: false,
+        depth,
+        description: description || summarizeLine(content),
+        size: stat.size,
+      });
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Get the first meaningful line of content as a summary.
+ */
+function summarizeLine(text) {
+  const lines = text
+    .split('\n')
+    .filter((l) => l.trim() && !l.startsWith('---') && !l.startsWith('#'));
+  const first = lines[0]?.trim() || '';
+  return first.length > 80 ? first.slice(0, 77) + '...' : first;
+}
+
+/**
+ * List files in a directory (non-recursive).
+ */
+export function listFiles(contextDir, subDir) {
+  const fullDir = join(contextDir, subDir);
+  if (!existsSync(fullDir)) return [];
+  return readdirSync(fullDir).filter((n) => !n.startsWith('.'));
+}
+
+/**
+ * Count files recursively in a directory.
+ */
+export function countFiles(contextDir, subDir) {
+  const fullDir = join(contextDir, subDir);
+  if (!existsSync(fullDir)) return 0;
+  let count = 0;
+  const walk = (dir) => {
+    for (const name of readdirSync(dir)) {
+      if (name.startsWith('.')) continue;
+      const full = join(dir, name);
+      if (statSync(full).isDirectory()) walk(full);
+      else count++;
+    }
+  };
+  walk(fullDir);
+  return count;
+}

package/src/core/git.js

@@ -0,0 +1,182 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Run a git command in the given directory. Returns stdout as string.
+ */
+export function git(args, cwd) {
+  try {
+    return execSync(`git ${args}`, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch (err) {
+    throw new Error(`git ${args} failed: ${err.stderr?.trim() || err.message}`);
+  }
+}
+
+/**
+ * Check if directory is inside a git repo.
+ */
+export function isGitRepo(cwd) {
+  try {
+    git('rev-parse --is-inside-work-tree', cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Initialize git in .context/ if not already in a git repo.
+ */
+export function initGit(contextDir) {
+  if (!isGitRepo(contextDir)) {
+    git('init', contextDir);
+  }
+}
+
+/**
+ * Stage and commit all changes in .context/.
+ */
+export function commitContext(contextDir, message) {
+  git('add -A', contextDir);
+
+  // Check if there are staged changes
+  try {
+    git('diff --cached --quiet', contextDir);
+    return null; // nothing to commit
+  } catch {
+    // There are changes — commit them
+  }
+
+  git(`commit -m "${message.replace(/"/g, '\\"')}"`, contextDir);
+  return git('rev-parse --short HEAD', contextDir);
+}
+
+/**
+ * Get commit count in .context/ repo.
+ */
+export function commitCount(contextDir) {
+  try {
+    return parseInt(git('rev-list --count HEAD', contextDir), 10);
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get last commit info.
+ */
+export function lastCommit(contextDir) {
+  try {
+    const log = git('log -1 --format="%h|%s|%cr"', contextDir);
+    const [hash, message, timeAgo] = log.split('|');
+    return { hash, message, timeAgo };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if there are uncommitted changes.
+ */
+export function hasChanges(contextDir) {
+  try {
+    const status = git('status --porcelain', contextDir);
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get commit log since a ref. Returns array of { hash, message, date }.
+ * If sinceRef is null, returns all commits.
+ */
+export function gitLog(contextDir, sinceRef, maxCount = 50) {
+  try {
+    const range = sinceRef ? `${sinceRef}..HEAD` : 'HEAD';
+    const raw = git(`log ${range} --format="%h|%s|%ai" -n ${maxCount}`, contextDir);
+    if (!raw) return [];
+    return raw.split('\n').map((line) => {
+      const [hash, message, date] = line.split('|');
+      return { hash, message, date };
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get total commit count since a ref.
+ */
+export function commitCountSince(contextDir, sinceRef) {
+  try {
+    if (!sinceRef) return commitCount(contextDir);
+    const raw = git(`rev-list --count ${sinceRef}..HEAD`, contextDir);
+    return parseInt(raw, 10);
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get diff stats since a ref. Returns array of { file, added, removed }.
+ */
+export function gitDiffStat(contextDir, sinceRef) {
+  try {
+    const range = sinceRef ? `${sinceRef}..HEAD` : `$(git rev-list --max-parents=0 HEAD)..HEAD`;
+    const raw = git(`diff --numstat ${range}`, contextDir);
+    if (!raw) return [];
+    return raw
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const [added, removed, file] = line.split('\t');
+        return {
+          file,
+          added: added === '-' ? 0 : parseInt(added, 10),
+          removed: removed === '-' ? 0 : parseInt(removed, 10),
+        };
+      });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get full diff for specific path since a ref.
+ */
+export function gitDiffFiles(contextDir, sinceRef, path) {
+  try {
+    const range = sinceRef ? `${sinceRef}..HEAD` : `$(git rev-list --max-parents=0 HEAD)..HEAD`;
+    return git(`diff ${range} -- ${path}`, contextDir);
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Get file content at a specific ref.
+ */
+export function gitShowFile(contextDir, ref, path) {
+  try {
+    return git(`show ${ref}:${path}`, contextDir);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the first commit hash in the repo.
+ */
+export function firstCommit(contextDir) {
+  try {
+    return git('rev-list --max-parents=0 HEAD', contextDir).split('\n')[0];
+  } catch {
+    return null;
+  }
+}

package/src/core/importers.js

@@ -0,0 +1,210 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { writeContextFile } from './fs.js';
+
+/**
+ * Import Claude Code session history into .context/memory/.
+ *
+ * Claude Code stores sessions at:
+ *   ~/.claude/projects/<project-hash>/<session-id>.jsonl
+ *
+ * Project hash = cwd path with slashes replaced by dashes.
+ * Each line is a JSON object with { type, message, ... }.
+ * We extract assistant messages and tool results as context.
+ */
+export function importClaudeHistory(cwd, contextDir) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const claudeDir = join(home, '.claude', 'projects');
+
+  if (!existsSync(claudeDir)) {
+    console.log('  ℹ️  No Claude Code history found (~/.claude/projects/ not found)');
+    return 0;
+  }
+
+  // Find matching project directory
+  // Claude uses path with slashes → dashes: /home/user/myapp → -home-user-myapp-
+  const projectHash = cwd.replace(/\//g, '-');
+  const candidates = readdirSync(claudeDir).filter(
+    (d) => d.includes(basename(cwd)) || d === projectHash || d.endsWith(`-${basename(cwd)}-`),
+  );
+
+  if (!candidates.length) {
+    console.log(`  ℹ️  No Claude Code sessions found for this project`);
+    return 0;
+  }
+
+  let totalSessions = 0;
+  const summaries = [];
+
+  for (const candidate of candidates) {
+    const projectDir = join(claudeDir, candidate);
+    if (!statSync(projectDir).isDirectory()) continue;
+
+    const jsonlFiles = readdirSync(projectDir).filter((f) => f.endsWith('.jsonl'));
+
+    for (const file of jsonlFiles.slice(-5)) {
+      // Import last 5 sessions max
+      try {
+        const content = readFileSync(join(projectDir, file), 'utf-8');
+        const messages = content
+          .split('\n')
+          .filter((l) => l.trim())
+          .map((l) => {
+            try {
+              return JSON.parse(l);
+            } catch {
+              return null;
+            }
+          })
+          .filter(Boolean);
+
+        // Extract human messages and assistant summaries
+        const humanMsgs = messages
+          .filter((m) => m.type === 'human' && m.message?.content)
+          .map((m) =>
+            typeof m.message.content === 'string'
+              ? m.message.content
+              : JSON.stringify(m.message.content),
+          )
+          .slice(0, 10); // First 10 human messages as context
+
+        if (humanMsgs.length > 0) {
+          const sessionId = basename(file, '.jsonl').slice(0, 8);
+          summaries.push(
+            `### Session ${sessionId}\n${humanMsgs.map((m) => `- ${m.slice(0, 200)}`).join('\n')}`,
+          );
+          totalSessions++;
+        }
+      } catch {}
+    }
+  }
+
+  if (summaries.length) {
+    writeContextFile(
+      contextDir,
+      'memory/imported-claude-sessions.md',
+      [
+        '---',
+        'description: "Imported from Claude Code session history"',
+        '---',
+        '',
+        '# Claude Code Session History',
+        '',
+        `Imported ${totalSessions} sessions.`,
+        '',
+        ...summaries,
+        '',
+      ].join('\n'),
+    );
+    console.log(
+      `  📥 Imported ${totalSessions} Claude Code sessions → memory/imported-claude-sessions.md`,
+    );
+  }
+
+  return totalSessions;
+}
+
+/**
+ * Import Codex session history into .context/memory/.
+ *
+ * Codex stores sessions at:
+ *   ~/.codex/sessions/YYYY/MM/DD/<session-name>.jsonl
+ *
+ * Each line is a JSON object. We extract the conversation content.
+ */
+export function importCodexHistory(cwd, contextDir) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const codexDir = join(home, '.codex', 'sessions');
+
+  if (!existsSync(codexDir)) {
+    console.log('  ℹ️  No Codex history found (~/.codex/sessions/ not found)');
+    return 0;
+  }
+
+  // Walk the date-based directory structure, find recent sessions
+  const jsonlFiles = [];
+  const walkDates = (dir, depth = 0) => {
+    if (depth > 4 || !existsSync(dir)) return;
+    try {
+      for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+          walkDates(full, depth + 1);
+        } else if (entry.endsWith('.jsonl')) {
+          jsonlFiles.push({ path: full, name: entry, mtime: statSync(full).mtimeMs });
+        }
+      }
+    } catch {}
+  };
+
+  walkDates(codexDir);
+
+  if (!jsonlFiles.length) {
+    console.log('  ℹ️  No Codex sessions found');
+    return 0;
+  }
+
+  // Sort by most recent, take last 5
+  jsonlFiles.sort((a, b) => b.mtime - a.mtime);
+  const recent = jsonlFiles.slice(0, 5);
+
+  const summaries = [];
+
+  for (const file of recent) {
+    try {
+      const content = readFileSync(file.path, 'utf-8');
+      const lines = content
+        .split('\n')
+        .filter((l) => l.trim())
+        .map((l) => {
+          try {
+            return JSON.parse(l);
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean);
+
+      // Extract messages — Codex format varies, look for common patterns
+      const msgs = lines
+        .filter((m) => m.role === 'user' || m.type === 'message' || m.content)
+        .map((m) => {
+          const text = m.content || m.message?.content || m.text || '';
+          return typeof text === 'string' ? text : JSON.stringify(text);
+        })
+        .filter((t) => t.length > 0 && t.length < 500)
+        .slice(0, 10);
+
+      if (msgs.length) {
+        const sessionId = basename(file.name, '.jsonl').slice(0, 20);
+        summaries.push(
+          `### Session ${sessionId}\n${msgs.map((m) => `- ${m.slice(0, 200)}`).join('\n')}`,
+        );
+      }
+    } catch {}
+  }
+
+  if (summaries.length) {
+    writeContextFile(
+      contextDir,
+      'memory/imported-codex-sessions.md',
+      [
+        '---',
+        'description: "Imported from Codex session history"',
+        '---',
+        '',
+        '# Codex Session History',
+        '',
+        `Imported ${summaries.length} sessions.`,
+        '',
+        ...summaries,
+        '',
+      ].join('\n'),
+    );
+    console.log(
+      `  📥 Imported ${summaries.length} Codex sessions → memory/imported-codex-sessions.md`,
+    );
+  }
+
+  return summaries.length;
+}

package/src/core/lock.js

@@ -0,0 +1,62 @@
+import { writeFileSync, unlinkSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const LOCK_FILE = '.context.lock';
+const LOCK_TIMEOUT_MS = 30_000; // 30 seconds
+
+/**
+ * Acquire a lock on .context/ for safe concurrent access.
+ * Uses a simple lock file with PID and timestamp.
+ * Returns a release function.
+ */
+export function acquireLock(projectRoot) {
+  const lockPath = join(projectRoot, LOCK_FILE);
+
+  // Check for stale lock
+  if (existsSync(lockPath)) {
+    try {
+      const data = JSON.parse(readFileSync(lockPath, 'utf-8'));
+      const age = Date.now() - data.timestamp;
+
+      if (age > LOCK_TIMEOUT_MS) {
+        // Stale lock — remove it
+        unlinkSync(lockPath);
+      } else {
+        // Active lock — wait briefly then fail
+        const waitMs = Math.min(age, 2000);
+        const start = Date.now();
+        while (Date.now() - start < waitMs) {
+          // busy wait
+        }
+
+        if (existsSync(lockPath)) {
+          console.error(
+            `⚠️  Context locked by PID ${data.pid} (${Math.round(age / 1000)}s ago). Proceeding anyway.`,
+          );
+          // Don't block — just warn. Append-only files are safe for concurrent writes.
+        }
+      }
+    } catch {
+      // Corrupted lock file — remove
+      try {
+        unlinkSync(lockPath);
+      } catch {}
+    }
+  }
+
+  // Write lock
+  writeFileSync(
+    lockPath,
+    JSON.stringify({
+      pid: process.pid,
+      timestamp: Date.now(),
+    }),
+  );
+
+  // Return release function
+  return () => {
+    try {
+      unlinkSync(lockPath);
+    } catch {}
+  };
+}