agentel 0.2.0

package/src/mcp.js

@@ -0,0 +1,148 @@
+"use strict";
+
+const { searchPastSessions } = require("./search");
+const { version } = require("./version");
+
+async function runMcpServer(input = process.stdin, output = process.stdout, env = process.env) {
+  const transport = new McpStdioTransport(input, output);
+  transport.onMessage(async (message) => {
+    if (!message || !message.method) return;
+    try {
+      const result = await handleRequest(message, env);
+      if ("id" in message && result !== undefined) transport.send({ jsonrpc: "2.0", id: message.id, result });
+    } catch (error) {
+      if ("id" in message) {
+        transport.send({
+          jsonrpc: "2.0",
+          id: message.id,
+          error: { code: -32000, message: error.message || String(error) }
+        });
+      }
+    }
+  });
+  await transport.start();
+}
+
+async function handleRequest(message, env = process.env) {
+  if (message.method === "initialize") {
+    return {
+      protocolVersion: message.params?.protocolVersion || "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: { name: "agentlog-recall", version }
+    };
+  }
+  if (message.method === "tools/list") {
+    return {
+      tools: [
+        {
+          name: "search_past_sessions",
+          description: "Search redacted, repo-keyed conversation markdown archives for relevant excerpts.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+              repo: { type: "string" },
+              limit: { type: "integer", default: 10, minimum: 1, maximum: 50 },
+              include_web_chats: { type: "boolean", default: false }
+            },
+            required: ["query"]
+          }
+        }
+      ]
+    };
+  }
+  if (message.method === "tools/call") {
+    const name = message.params?.name;
+    if (name !== "search_past_sessions") throw new Error(`unknown tool: ${name}`);
+    const args = message.params?.arguments || {};
+    const results = searchPastSessions(
+      args.query || "",
+      {
+        repo: args.repo,
+        limit: args.limit || 10,
+        includeWebChats: args.include_web_chats === true
+      },
+      env
+    );
+    return {
+      content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+      structuredContent: { results }
+    };
+  }
+  if (message.method === "ping") return {};
+  if (message.method.startsWith("notifications/")) return undefined;
+  throw new Error(`unsupported MCP method: ${message.method}`);
+}
+
+class McpStdioTransport {
+  constructor(input, output) {
+    this.input = input;
+    this.output = output;
+    this.buffer = "";
+    this.handlers = [];
+  }
+
+  onMessage(handler) {
+    this.handlers.push(handler);
+  }
+
+  async start() {
+    this.input.setEncoding("utf8");
+    this.input.on("data", (chunk) => {
+      this.buffer += chunk;
+      this.drain();
+    });
+    return new Promise((resolve) => {
+      this.input.on("end", resolve);
+    });
+  }
+
+  drain() {
+    for (;;) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (this.buffer.startsWith("Content-Length:") && headerEnd >= 0) {
+        const header = this.buffer.slice(0, headerEnd);
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match) {
+          this.buffer = "";
+          return;
+        }
+        const length = Number(match[1]);
+        const bodyStart = headerEnd + 4;
+        if (this.buffer.length < bodyStart + length) return;
+        const body = this.buffer.slice(bodyStart, bodyStart + length);
+        this.buffer = this.buffer.slice(bodyStart + length);
+        this.emit(body);
+        continue;
+      }
+
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) return;
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line) this.emit(line);
+    }
+  }
+
+  emit(body) {
+    let message;
+    try {
+      message = JSON.parse(body);
+    } catch (error) {
+      console.error(`agentlog-recall: invalid JSON-RPC message: ${error.message}`);
+      return;
+    }
+    for (const handler of this.handlers) handler(message);
+  }
+
+  send(message) {
+    const body = JSON.stringify(message);
+    this.output.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+  }
+}
+
+module.exports = {
+  McpStdioTransport,
+  handleRequest,
+  runMcpServer
+};

package/src/parser-versions.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const SOURCE_TYPE_ALIASES = {
+  "cursor-sqlite-history": "cursor-workspace-sqlite",
+  "antigravity-brain": "antigravity-history"
+};
+
+const PARSER_VERSIONS = {
+  "codex-cli-history": "1.0.0",
+  "codex-desktop-history": "1.0.0",
+  "cli-history": "1.0.0",
+  "claude-sdk-history": "1.0.0",
+  "claude-code-desktop-metadata": "1.0.0",
+  "claude-workspace-desktop": "1.0.0",
+  "cursor-workspace-sqlite": "1.0.0",
+  "cursor-global-sqlite": "1.0.0",
+  "cursor-raw-sqlite-salvage": "1.0.0",
+  "cursor-agent-transcripts": "1.0.0",
+  "devin-cli-history": "1.0.0",
+  "gemini-cli-history": "1.0.0",
+  "cline-task-history": "1.0.0",
+  "opencode-history": "1.0.0",
+  "aider-chat-history": "1.0.0",
+  "antigravity-history": "1.0.0",
+  "web-chat-export": "1.0.0",
+  "chatgpt-export": "1.0.0",
+  "claude-web-export": "1.0.0",
+  "claude-web-memory": "1.0.0",
+  import: "1.0.0"
+};
+
+function canonicalSourceType(sourceType) {
+  const key = String(sourceType || "import").trim() || "import";
+  return SOURCE_TYPE_ALIASES[key] || key;
+}
+
+function parserVersionForSource(sourceType) {
+  const key = canonicalSourceType(sourceType);
+  return PARSER_VERSIONS[key] || null;
+}
+
+function fingerprintPrefix(sourceType) {
+  const key = canonicalSourceType(sourceType);
+  const version = parserVersionForSource(key);
+  if (!version) throw new Error(`unknown parser source type: ${sourceType || "(empty)"}`);
+  return `${key}-v${version}`;
+}
+
+function assertKnownSourceType(sourceType) {
+  const key = canonicalSourceType(sourceType);
+  if (!parserVersionForSource(key)) throw new Error(`unknown parser source type: ${sourceType || "(empty)"}`);
+  return key;
+}
+
+module.exports = {
+  PARSER_VERSIONS,
+  SOURCE_TYPE_ALIASES,
+  assertKnownSourceType,
+  canonicalSourceType,
+  fingerprintPrefix,
+  parserVersionForSource
+};

package/src/paths.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+function homeDir(env = process.env) {
+  return env.AGENTLOG_HOME || path.join(os.homedir(), ".agentlog");
+}
+
+function paths(env = process.env) {
+  const home = homeDir(env);
+  return {
+    home,
+    config: path.join(home, "config.json"),
+    redaction: path.join(home, "redaction.yaml"),
+    data: path.join(home, "data"),
+    state: path.join(home, "state"),
+    spool: path.join(home, "spool"),
+    cache: path.join(home, "cache"),
+    logs: path.join(home, "logs"),
+    pid: path.join(home, "state", "supervisor.pid"),
+    imports: path.join(home, "state", "imports.json"),
+    webAccounts: path.join(home, "state", "web-accounts.json"),
+    index: path.join(home, "data", "agentlog", "indexes", "bm25", "index.json"),
+    revealCache: path.join(home, "cache", "unredacted")
+  };
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+
+function ensureBaseDirs(p = paths()) {
+  for (const dir of [p.home, p.data, p.state, p.spool, p.cache, p.logs, p.revealCache]) {
+    ensureDir(dir);
+  }
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+
+function writeJson(file, value) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+
+module.exports = {
+  ensureBaseDirs,
+  ensureDir,
+  homeDir,
+  paths,
+  readJson,
+  writeJson
+};

package/src/redaction.js

@@ -0,0 +1,228 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { paths } = require("./paths");
+
+const BUILT_INS = [
+  { name: "aws_key", regex: /\bAKIA[0-9A-Z]{16}\b/g },
+  { name: "anthropic_key", regex: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+  { name: "openai_key", regex: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
+  { name: "github_token", regex: /\bgh[pousr]_[A-Za-z0-9_]{30,}\b/g },
+  { name: "slack_token", regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
+  { name: "jwt", regex: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g },
+  {
+    name: "private_key",
+    regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g
+  }
+];
+
+const REDACTION_MARKER_RE = /\[REDACTED:([^\]\n]+)\]/g;
+
+function loadRedactionConfig(env = process.env) {
+  const file = paths(env).redaction;
+  try {
+    return parseRedactionYaml(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return { patterns: [], envVars: [], allowlistRepos: [] };
+    throw error;
+  }
+}
+
+function parseRedactionYaml(text) {
+  const patterns = [];
+  const envVars = [];
+  const allowlistRepos = [];
+  const lines = text.split(/\r?\n/);
+  let section = "";
+  let currentPattern = null;
+
+  for (const raw of lines) {
+    const line = raw.replace(/\s+#.*$/, "");
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    const top = trimmed.match(/^([a-zA-Z_]+)\s*:\s*(.*)$/);
+    if (top && !line.startsWith(" ")) {
+      section = top[1];
+      const inline = top[2].trim();
+      if (section === "env_vars" && inline.startsWith("[")) {
+        envVars.push(...parseInlineList(inline));
+      } else if (section === "allowlist_repos" && inline.startsWith("[")) {
+        allowlistRepos.push(...parseInlineList(inline));
+      }
+      continue;
+    }
+
+    if (section === "patterns") {
+      const name = trimmed.match(/^-\s*name\s*:\s*["']?([^"']+)["']?$/);
+      if (name) {
+        currentPattern = { name: name[1].trim(), regex: "" };
+        patterns.push(currentPattern);
+        continue;
+      }
+      const regex = trimmed.match(/^regex\s*:\s*(.*)$/);
+      if (regex && currentPattern) {
+        currentPattern.regex = stripYamlString(regex[1].trim());
+      }
+    } else if (section === "env_vars") {
+      const item = trimmed.match(/^-\s*(.+)$/);
+      if (item) envVars.push(stripYamlString(item[1].trim()));
+    } else if (section === "allowlist_repos") {
+      const item = trimmed.match(/^-\s*(.+)$/);
+      if (item) allowlistRepos.push(stripYamlString(item[1].trim()).toLowerCase());
+    }
+  }
+
+  return {
+    patterns: patterns.filter((pattern) => pattern.name && pattern.regex),
+    envVars: [...new Set(envVars.filter(Boolean))],
+    allowlistRepos: [...new Set(allowlistRepos.filter(Boolean))]
+  };
+}
+
+function parseInlineList(value) {
+  return value
+    .replace(/^\[/, "")
+    .replace(/\]$/, "")
+    .split(",")
+    .map((item) => stripYamlString(item.trim()))
+    .filter(Boolean);
+}
+
+function stripYamlString(value) {
+  return value.replace(/^['"]/, "").replace(/['"]$/, "");
+}
+
+function loadEnvValues(cwd, names = [], env = process.env) {
+  const values = [];
+  for (const name of names) {
+    if (env[name]) values.push({ name, value: env[name] });
+  }
+  for (const file of envFilesFor(cwd)) {
+    try {
+      const text = fs.readFileSync(file, "utf8");
+      for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#")) continue;
+        const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+        if (!match || !names.includes(match[1])) continue;
+        const value = stripYamlString(match[2].trim());
+        if (value) values.push({ name: match[1], value });
+      }
+    } catch {
+      // Ignore unreadable .env files; import should continue.
+    }
+  }
+  return values.filter((item) => item.value && item.value.length >= 4);
+}
+
+function envFilesFor(cwd) {
+  const files = [];
+  let dir = path.resolve(cwd || process.cwd());
+  for (;;) {
+    files.push(path.join(dir, ".env"));
+    const parent = path.dirname(dir);
+    if (parent === dir) return files;
+    if (fs.existsSync(path.join(dir, ".git"))) return files;
+    dir = parent;
+  }
+}
+
+function redactText(input, options = {}) {
+  let text = String(input ?? "");
+  const summary = {};
+  const repo = options.repoCanonical || "";
+  const cfg = options.config || loadRedactionConfig(options.env);
+
+  if (repo && cfg.allowlistRepos.includes(repo.toLowerCase())) {
+    return { text, summary };
+  }
+
+  for (const pattern of BUILT_INS) {
+    text = replaceMatches(text, pattern.regex, `[REDACTED:${pattern.name}]`, summary, pattern.name);
+  }
+
+  const envValues = options.envValues || loadEnvValues(options.cwd, cfg.envVars, options.env);
+  for (const item of envValues) {
+    const escaped = escapeRegExp(item.value);
+    if (!escaped) continue;
+    text = replaceMatches(text, new RegExp(escaped, "g"), `[REDACTED:env:${item.name}]`, summary, `env:${item.name}`);
+  }
+
+  text = text.replace(
+    /(\b[A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PWD)[A-Z0-9_]*\s*=\s*)(["']?)([A-Za-z0-9+/=_-]{32,})(\2)/gi,
+    (_, prefix, quote, value, suffix) => {
+      if (!looksHighEntropy(value)) return `${prefix}${quote}${value}${suffix}`;
+      increment(summary, "high_entropy_env");
+      return `${prefix}${quote}[REDACTED:high_entropy_env]${suffix}`;
+    }
+  );
+
+  for (const pattern of cfg.patterns) {
+    try {
+      text = replaceMatches(text, new RegExp(pattern.regex, "g"), `[REDACTED:${pattern.name}]`, summary, pattern.name);
+    } catch {
+      increment(summary, "invalid_user_pattern");
+    }
+  }
+
+  return { text, summary };
+}
+
+function styleRedactionMarkersForMarkdown(input) {
+  return String(input ?? "").replace(REDACTION_MARKER_RE, (_, rawKind) => {
+    const kind = safeRedactionKind(rawKind);
+    return `<mark class="agentlog-redaction" title="agentlog redacted ${escapeHtml(kind)}">[REDACTED:${escapeHtml(kind)}]</mark>`;
+  });
+}
+
+function safeRedactionKind(value) {
+  return String(value || "unknown").replace(/[^\w:.-]/g, "_").slice(0, 120) || "unknown";
+}
+
+function escapeHtml(value) {
+  return String(value ?? "").replace(/[&<>"']/g, (ch) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    "\"": "&quot;",
+    "'": "&#39;"
+  })[ch]);
+}
+
+function replaceMatches(text, regex, replacement, summary, name) {
+  return text.replace(regex, () => {
+    increment(summary, name);
+    return replacement;
+  });
+}
+
+function looksHighEntropy(value) {
+  const unique = new Set(value.split(""));
+  return unique.size >= 12 && /[A-Z]/i.test(value) && /\d/.test(value);
+}
+
+function increment(summary, key, amount = 1) {
+  summary[key] = (summary[key] || 0) + amount;
+}
+
+function mergeSummaries(target, source) {
+  for (const [key, value] of Object.entries(source || {})) {
+    increment(target, key, value);
+  }
+  return target;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+module.exports = {
+  loadEnvValues,
+  loadRedactionConfig,
+  mergeSummaries,
+  parseRedactionYaml,
+  redactText,
+  styleRedactionMarkersForMarkdown
+};

package/src/repo.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+function canonicalizeRemote(remote) {
+  if (!remote || typeof remote !== "string") return "";
+  let value = remote.trim();
+  if (!value) return "";
+
+  const scpLike = value.match(/^(?:[^@/:]+@)?([^/:]+):(.+)$/);
+  if (scpLike && !value.includes("://")) {
+    return normalizeHostPath(scpLike[1], scpLike[2]);
+  }
+
+  try {
+    const parsed = new URL(value);
+    return normalizeHostPath(parsed.hostname, parsed.pathname);
+  } catch {
+    const withoutProtocol = value.replace(/^[a-z]+:\/\//i, "");
+    const firstSlash = withoutProtocol.indexOf("/");
+    if (firstSlash === -1) return stripGit(withoutProtocol).toLowerCase();
+    return normalizeHostPath(withoutProtocol.slice(0, firstSlash), withoutProtocol.slice(firstSlash + 1));
+  }
+}
+
+function normalizeHostPath(host, repoPath) {
+  const cleanedHost = host.replace(/^.*@/, "").toLowerCase();
+  const cleanedPath = stripGit(repoPath.replace(/^\/+/, "").replace(/\/+$/, ""))
+    .toLowerCase();
+  if (!cleanedHost || !cleanedPath) return "";
+  return `${cleanedHost}/${cleanedPath}`;
+}
+
+function stripGit(value) {
+  return value.replace(/\.git$/i, "");
+}
+
+function canonicalRepo(cwd = process.cwd()) {
+  const override = readRepoOverride(cwd);
+  if (override) return { key: override, source: ".agentlog.yaml" };
+
+  const remote = runGit(cwd, ["config", "--get", "remote.origin.url"]);
+  const remoteKey = canonicalizeRemote(remote);
+  if (remoteKey) return { key: remoteKey, source: "git-remote" };
+
+  const firstCommit = runGit(cwd, ["rev-list", "--max-parents=0", "HEAD"]);
+  if (firstCommit) return { key: `firstcommit:${firstCommit.trim()}`, source: "git-first-commit" };
+
+  const normalized = normalizePathForHash(cwd);
+  const hash = crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 32);
+  return { key: `path:${hash}`, source: "path-hash" };
+}
+
+function runGit(cwd, args) {
+  try {
+    return execFileSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function normalizePathForHash(cwd) {
+  const resolved = path.resolve(cwd);
+  const home = os.homedir();
+  if (resolved === home) return "~";
+  if (resolved.startsWith(`${home}${path.sep}`)) return `~/${resolved.slice(home.length + 1)}`;
+  return resolved;
+}
+
+function readRepoOverride(cwd) {
+  const file = findUp(cwd, ".agentlog.yaml");
+  if (!file) return "";
+  try {
+    const text = fs.readFileSync(file, "utf8");
+    const match = text.match(/^\s*canonical_repo\s*:\s*["']?([^"'\n#]+)["']?\s*(?:#.*)?$/m);
+    return match ? match[1].trim().toLowerCase() : "";
+  } catch {
+    return "";
+  }
+}
+
+function findUp(start, filename) {
+  let dir = path.resolve(start || process.cwd());
+  for (;;) {
+    const candidate = path.join(dir, filename);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return "";
+    if (fs.existsSync(path.join(dir, ".git"))) return "";
+    dir = parent;
+  }
+}
+
+module.exports = {
+  canonicalRepo,
+  canonicalizeRemote,
+  normalizePathForHash,
+  readRepoOverride
+};