pi-automem-core 0.2.0

package/src/mcp-client.ts

@@ -0,0 +1,361 @@
+/**
+ * mcp-client.ts - JSON-RPC client for AutoMem MCP sidecar.
+ *
+ * Reads connection info from pi's mcp.json (url + auth header).
+ * All calls go through the MCP tools/call endpoint.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { resolveEnvVars } from "./config";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface McpCallResult {
+  content: Array<{ type: string; text?: string }>;
+  isError?: boolean;
+}
+
+export interface McpHealth {
+  healthy: boolean;
+  memoryCount?: number;
+  error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// MCP config reader
+// ---------------------------------------------------------------------------
+
+function loadMcpServerConfig(serverName: string): { url: string; auth: string } {
+  const mcpJsonPath = resolve(homedir(), ".pi", "agent", "mcp.json");
+
+  if (!existsSync(mcpJsonPath)) {
+    throw new Error("mcp.json not found at " + mcpJsonPath);
+  }
+
+  const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8")) as {
+    mcpServers?: Record<string, { url: string; headers?: Record<string, string> }>;
+  };
+
+  const server = mcpJson.mcpServers ? mcpJson.mcpServers[serverName] : undefined;
+  if (!server) {
+    const available = mcpJson.mcpServers ? Object.keys(mcpJson.mcpServers).join(", ") : "(none)";
+    throw new Error('MCP server "' + serverName + '" not found. Available: ' + available);
+  }
+
+  return {
+    url: server.url,
+    auth: resolveEnvVars(server.headers?.Authorization || ""),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Response parsing — handles both JSON and text/event-stream (SSE)
+// ---------------------------------------------------------------------------
+
+async function parseJsonRpcResponse(resp: Response): Promise<any> {
+  const ct = resp.headers.get("content-type") || "";
+  if (ct.includes("text/event-stream")) {
+    const text = await resp.text();
+    // SSE lines are "data: <json>\n"; find the last non-empty data line
+    const dataLine = text
+      .split("\n")
+      .map(function(l: string) { return l.trim(); })
+      .filter(function(l: string) { return l.startsWith("data:") && l.length > 5; })
+      .pop();
+    if (!dataLine) throw new Error("SSE response contained no data lines");
+    return JSON.parse(dataLine.slice(5).trim());
+  }
+  return resp.json();
+}
+
+// ---------------------------------------------------------------------------
+// JSON-RPC client
+// ---------------------------------------------------------------------------
+
+let callId = 0;
+let configuredServerName = process.env.AUTOMEM_MCP_SERVER || "automem";
+
+export function setAutoMemMcpServerName(serverName: string | undefined): void {
+  if (serverName && serverName.trim()) {
+    const newName = serverName.trim();
+    if (newName !== configuredServerName) {
+      discoveredTools = null;
+      configuredServerName = newName;
+    }
+  }
+}
+
+function getAutoMemMcpServerName(): string {
+  return process.env.AUTOMEM_MCP_SERVER || configuredServerName || "automem";
+}
+
+async function mcpCall(tool: string, args: Record<string, unknown>): Promise<McpCallResult> {
+  const serverName = getAutoMemMcpServerName();
+  const cfg = loadMcpServerConfig(serverName);
+
+  const body = {
+    jsonrpc: "2.0",
+    id: ++callId,
+    method: "tools/call",
+    params: { name: tool, arguments: args },
+  };
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 30000);
+
+  try {
+    const resp = await fetch(cfg.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(cfg.auth ? { Authorization: cfg.auth } : {}),
+        Accept: "application/json, text/event-stream",
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    if (!resp.ok) {
+      const text = await resp.text().catch(function() { return ""; });
+      throw new Error("MCP HTTP " + resp.status + ": " + text.slice(0, 200));
+    }
+
+    const payload = (await parseJsonRpcResponse(resp)) as {
+      result?: McpCallResult;
+      error?: { code: number; message: string };
+    };
+
+    if (payload.error) {
+      throw new Error("MCP error: " + payload.error.message);
+    }
+
+    return payload.result || { content: [] };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool discovery cache
+// ---------------------------------------------------------------------------
+
+let discoveredTools: Map<string, string> | null = null;
+
+/**
+ * Discover available tools from the MCP server via tools/list.
+ * Returns a Map of normalized tool name → actual tool name.
+ * Cached after first call.
+ */
+export async function discoverTools(): Promise<Map<string, string>> {
+  if (discoveredTools) return discoveredTools;
+
+  const serverName = getAutoMemMcpServerName();
+  const cfg = loadMcpServerConfig(serverName);
+
+  const body = {
+    jsonrpc: "2.0",
+    id: ++callId,
+    method: "tools/list",
+    params: {},
+  };
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15000);
+
+  try {
+    const resp = await fetch(cfg.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(cfg.auth ? { Authorization: cfg.auth } : {}),
+        Accept: "application/json, text/event-stream",
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    if (!resp.ok) {
+      throw new Error("MCP tools/list HTTP " + resp.status);
+    }
+
+    const payload = (await parseJsonRpcResponse(resp)) as {
+      result?: { tools?: Array<{ name: string }> };
+      error?: { code: number; message: string };
+    };
+
+    if (payload.error) {
+      throw new Error("MCP tools/list error: " + payload.error.message);
+    }
+
+    const tools = payload.result?.tools || [];
+    const map = new Map<string, string>();
+    for (const t of tools) {
+      map.set(t.name.toLowerCase(), t.name);
+      // Also index without automem_ prefix for fuzzy matching
+      if (t.name.toLowerCase().startsWith("automem_")) {
+        map.set(t.name.toLowerCase().replace("automem_", ""), t.name);
+      }
+      // Also index with automem_ prefix for reverse lookups
+      map.set("automem_" + t.name.toLowerCase(), t.name);
+    }
+
+    discoveredTools = map;
+    console.log("[automem] discovered tools: " + Array.from(new Set(map.values())).join(", "));
+    return map;
+  } catch (err) {
+    console.warn("[automem] tools/list failed, using default tool names: " + err);
+    // Fallback: use actual server tool names (no automem_ prefix)
+    discoveredTools = new Map<string, string>([
+      ["recall_memory", "recall_memory"],
+      ["automem_recall_memory", "recall_memory"],
+      ["check_database_health", "check_database_health"],
+      ["automem_check_database_health", "check_database_health"],
+      ["store_memory", "store_memory"],
+      ["automem_store_memory", "store_memory"],
+      ["associate_memories", "associate_memories"],
+      ["automem_associate_memories", "associate_memories"],
+      ["update_memory", "update_memory"],
+      ["automem_update_memory", "update_memory"],
+      ["delete_memory", "delete_memory"],
+      ["automem_delete_memory", "delete_memory"],
+    ]);
+    return discoveredTools;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Resolve a logical tool name to the actual server tool name.
+ * e.g. "recall_memory" → the actual server tool name discovered from tools/list.
+ */
+export function resolveToolName(logicalName: string): string {
+  if (!discoveredTools) return logicalName;
+  const key = logicalName.toLowerCase();
+  return discoveredTools.get(key) || logicalName;
+}
+
+// ---------------------------------------------------------------------------
+// AutoMem-specific wrappers
+// ---------------------------------------------------------------------------
+
+export async function automemRecall(
+  query: string,
+  options?: {
+    limit?: number;
+    tags?: string[];
+    tagMode?: "any" | "all";
+    contextTypes?: string[];
+    expandRelations?: boolean;
+    expandEntities?: boolean;
+  },
+): Promise<McpCallResult> {
+  const args: Record<string, unknown> = {
+    query,
+    limit: options && options.limit ? options.limit : 8,
+    tags: options && options.tags ? options.tags : [],
+    tag_mode: options && options.tagMode ? options.tagMode : "any",
+    expand_relations: options ? !!options.expandRelations : false,
+    expand_entities: options ? !!options.expandEntities : false,
+  };
+
+  if (options && options.contextTypes && options.contextTypes.length > 0) {
+    args.context_types = options.contextTypes;
+  }
+
+  return mcpCall(resolveToolName("recall_memory"), args);
+}
+
+export async function automemHealth(): Promise<McpHealth> {
+  try {
+    const result = await mcpCall(resolveToolName("check_database_health"), {});
+    const text = result.content && result.content[0] ? result.content[0].text : undefined;
+    if (text) {
+      try {
+        const parsed = JSON.parse(text);
+        const count = parsed.memory_count !== undefined
+          ? parsed.memory_count
+          : (parsed.count !== undefined ? parsed.count : parsed.memories);
+        return {
+          healthy: true,
+          memoryCount: typeof count === "number" ? count : undefined,
+        };
+      } catch (_e) {
+        return { healthy: true };
+      }
+    }
+    return { healthy: true };
+  } catch (err) {
+    return { healthy: false, error: String(err) };
+  }
+}
+
+export async function automemStore(
+  content: string,
+  type: string,
+  tags: string[],
+  options?: {
+    source?: string;
+    confidence?: number;
+    importance?: number;
+    metadata?: Record<string, unknown>;
+  },
+): Promise<McpCallResult> {
+  const meta: Record<string, unknown> = {};
+  if (options && options.source) meta.source = options.source;
+  if (options && options.metadata) Object.assign(meta, options.metadata);
+
+  return mcpCall(resolveToolName("store_memory"), {
+    content,
+    type,
+    tags,
+    confidence: options && options.confidence ? options.confidence : 0.8,
+    importance: options && options.importance ? options.importance : 0.5,
+    metadata: Object.keys(meta).length > 0 ? meta : undefined,
+  });
+}
+
+export async function automemAssociate(
+  memory1Id: string,
+  memory2Id: string,
+  relationship: string,
+  strength: number = 0.5,
+): Promise<McpCallResult> {
+  return mcpCall(resolveToolName("associate_memories"), {
+    memory1_id: memory1Id,
+    memory2_id: memory2Id,
+    type: relationship,
+    strength,
+  });
+}
+
+export async function automemUpdate(
+  memoryId: string,
+  updates: {
+    content?: string;
+    type?: string;
+    tags?: string[];
+    importance?: number;
+    confidence?: number;
+    metadata?: Record<string, unknown>;
+  },
+): Promise<McpCallResult> {
+  const args: Record<string, unknown> = { memory_id: memoryId };
+  if (updates.content !== undefined) args.content = updates.content;
+  if (updates.type !== undefined) args.type = updates.type;
+  if (updates.tags !== undefined) args.tags = updates.tags;
+  if (updates.importance !== undefined) args.importance = updates.importance;
+  if (updates.confidence !== undefined) args.confidence = updates.confidence;
+  if (updates.metadata !== undefined) args.metadata = updates.metadata;
+  return mcpCall(resolveToolName("update_memory"), args);
+}
+
+export async function automemDelete(memoryId: string): Promise<McpCallResult> {
+  return mcpCall(resolveToolName("delete_memory"), {
+    memory_id: memoryId,
+  });
+}

package/src/project-detect.ts

@@ -0,0 +1,94 @@
+/**
+ * project-detect.ts - Infer the current project from cwd, git remote, and prompt text.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { AutoMemConfig } from "./config";
+
+export interface ProjectDetection {
+  projectTag: string | null;
+  projectLabel: string | null;
+}
+
+function detectFromGit(cwd: string, gitRepoToTag: Record<string, string>): ProjectDetection {
+  // Walk up the directory tree to handle running from a subdirectory of a repo
+  let dir = cwd;
+  while (true) {
+    const gitConfigPath = resolve(dir, ".git", "config");
+    if (existsSync(gitConfigPath)) {
+      try {
+        const gitConfig = readFileSync(gitConfigPath, "utf8");
+        const urlMatch = gitConfig.match(/\[remote "[^"]+"\][\s\S]*?url\s*=\s*(.+)/);
+        if (urlMatch) {
+          const remoteUrl = urlMatch[1].trim().toLowerCase();
+          const keys = Object.keys(gitRepoToTag);
+          for (let i = 0; i < keys.length; i++) {
+            const substring = keys[i].toLowerCase();
+            if (remoteUrl.indexOf(substring) !== -1) {
+              const tag = gitRepoToTag[keys[i]];
+              return { projectTag: tag, projectLabel: tag.replace(/^[^:]+:/, "") };
+            }
+          }
+        }
+      } catch (_e) {
+        // ignore unreadable config
+      }
+      // Found .git but no matching remote — stop traversing
+      break;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) break; // reached filesystem root
+    dir = parent;
+  }
+
+  return { projectTag: null, projectLabel: null };
+}
+
+function detectFromFolder(cwd: string, folderTags: Record<string, string[]>): ProjectDetection {
+  const normalizedFolderTags: Record<string, string[]> = {};
+  const keys = Object.keys(folderTags);
+  for (let i = 0; i < keys.length; i++) {
+    normalizedFolderTags[keys[i].toLowerCase()] = folderTags[keys[i]];
+  }
+
+  const parts = cwd.split(/[\\/]/);
+  for (let i = 0; i < parts.length; i++) {
+    const lower = parts[i].toLowerCase();
+    if (normalizedFolderTags[lower] && normalizedFolderTags[lower].length > 0) {
+      const tag = normalizedFolderTags[lower][0];
+      return { projectTag: tag, projectLabel: lower };
+    }
+  }
+  return { projectTag: null, projectLabel: null };
+}
+
+function detectFromPrompt(prompt: string, gitRepoToTag: Record<string, string>): ProjectDetection {
+  const lower = prompt.toLowerCase();
+  const keys = Object.keys(gitRepoToTag);
+  for (let i = 0; i < keys.length; i++) {
+    if (lower.indexOf(keys[i].toLowerCase()) !== -1) {
+      const tag = gitRepoToTag[keys[i]];
+      return { projectTag: tag, projectLabel: tag.replace(/^[^:]+:/, "") };
+    }
+  }
+  return { projectTag: null, projectLabel: null };
+}
+
+export function detectProject(
+  cwd: string,
+  prompt: string,
+  config: AutoMemConfig,
+): ProjectDetection {
+  if (!config.projectDetection.enabled) {
+    return { projectTag: null, projectLabel: null };
+  }
+
+  const gitResult = detectFromGit(cwd, config.projectDetection.gitRepoToTag);
+  if (gitResult.projectTag) return gitResult;
+
+  const folderResult = detectFromFolder(cwd, config.projectDetection.folderTags);
+  if (folderResult.projectTag) return folderResult;
+
+  return detectFromPrompt(prompt, config.projectDetection.gitRepoToTag);
+}

package/src/recall.ts

@@ -0,0 +1,254 @@
+/**
+ * recall.ts - Startup and turn-level recall logic.
+ *
+ * Queries AutoMem, formats results, and enforces byte budgets.
+ */
+
+import { automemRecall } from "./mcp-client";
+import type { AutoMemConfig } from "./config";
+import type { ProjectDetection } from "./project-detect";
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+export interface FormattedMemory {
+  id: string;
+  type: string;
+  content: string;
+  tags: string[];
+  score?: number;
+}
+
+export function parseSearchResults(text: string): FormattedMemory[] {
+  if (!text || !text.trim()) return [];
+
+  // Try JSON array first
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+      return parsed.map(function(item: any) {
+        return {
+          id: item.id || item.memory_id || "",
+          type: item.type || item.memory_type || "Context",
+          content: item.content || item.text || "",
+          tags: Array.isArray(item.tags) ? item.tags : [],
+          score: item.score !== undefined ? item.score : (item.similarity !== undefined ? item.similarity : undefined),
+        };
+      });
+    }
+  } catch (_e) {
+    // Not JSON array
+  }
+
+  // AutoMem MCP returns human-readable text like:
+  // Found 2 memories:
+  //
+  // 1. Memory content [tag1, tag2] score=0.812
+  // ID: uuid
+  if (/^Found\s+\d+\s+memories:/i.test(text.trim())) {
+    const memories: FormattedMemory[] = [];
+    const lines = text.split("\n");
+    let current: string[] = [];
+
+    function flushCurrent() {
+      if (current.length === 0) return;
+      const raw = current.join("\n").trim();
+      if (!raw) return;
+
+      const idMatch = raw.match(/(?:^|\n)ID:\s*([^\s]+)/i);
+      const scoreMatch = raw.match(/\bscore=([0-9.]+)/i);
+      const firstLine = raw.split("\n")[0] || raw;
+      const content = firstLine
+        .replace(/^\d+\.\s*/, "")
+        .replace(/\s+score=[0-9.]+\s*$/i, "")
+        .trim();
+      const tagMatch = content.match(/\[([^\]]+)\]\s*$/);
+      const tags = tagMatch
+        ? tagMatch[1].split(",").map(function(t: string) { return t.trim(); }).filter(Boolean)
+        : [];
+      const cleanContent = tagMatch ? content.slice(0, tagMatch.index).trim() : content;
+
+      // AutoMem's human-readable format doesn't reliably include type info.
+      // Some versions prefix content with [TypeName]; detect it if present.
+      const KNOWN_TYPES = new Set(["Decision", "Pattern", "Preference", "Style", "Habit", "Insight", "Context"]);
+      const typePrefix = cleanContent.match(/^\[([A-Za-z]+)\]\s*/);
+      const detectedType = (typePrefix && KNOWN_TYPES.has(typePrefix[1])) ? typePrefix[1] : "Context";
+      const finalContent = (typePrefix && KNOWN_TYPES.has(typePrefix[1]))
+        ? cleanContent.slice(typePrefix[0].length)
+        : cleanContent;
+
+      memories.push({
+        id: idMatch ? idMatch[1] : "",
+        type: detectedType,
+        content: finalContent,
+        tags,
+        score: scoreMatch ? Number(scoreMatch[1]) : undefined,
+      });
+    }
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\d+\.\s+/.test(line.trim())) {
+        flushCurrent();
+        current = [line.trim()];
+      } else if (current.length > 0) {
+        current.push(line.trim());
+      }
+    }
+    flushCurrent();
+
+    return memories;
+  }
+
+  // Try newline-delimited JSON; fall back to one memory per nonempty line.
+  const lines = text.split("\n").filter(function(l: string) { return l.trim().length > 0; });
+  const memories: FormattedMemory[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    try {
+      const item = JSON.parse(lines[i]);
+      memories.push({
+        id: item.id || item.memory_id || "",
+        type: item.type || item.memory_type || "Context",
+        content: item.content || item.text || "",
+        tags: Array.isArray(item.tags) ? item.tags : [],
+        score: item.score !== undefined ? item.score : (item.similarity !== undefined ? item.similarity : undefined),
+      });
+    } catch (_e) {
+      if (lines[i].trim()) {
+        memories.push({
+          id: "",
+          type: "Context",
+          content: lines[i].trim(),
+          tags: [],
+        });
+      }
+    }
+  }
+
+  return memories;
+}
+
+function formatMemoriesForContext(memories: FormattedMemory[], maxBytes: number): string {
+  const lines: string[] = [];
+  let bytes = 0;
+
+  for (let i = 0; i < memories.length; i++) {
+    const mem = memories[i];
+    const tagStr = mem.tags.length > 0 ? " (" + mem.tags.join(", ") + ")" : "";
+    const entry = "[" + mem.type + "] " + mem.content + tagStr;
+    const entryBytes = Buffer.byteLength(entry, "utf8") + 1;
+
+    if (bytes + entryBytes > maxBytes && lines.length > 0) {
+      break;
+    }
+
+    lines.push(entry);
+    bytes += entryBytes;
+  }
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Startup recall
+// ---------------------------------------------------------------------------
+
+export interface RecallResult {
+  text: string;
+  count: number;
+  truncated: boolean;
+}
+
+export async function startupRecall(config: AutoMemConfig): Promise<RecallResult> {
+  if (!config.startupRecall.enabled) {
+    return { text: "", count: 0, truncated: false };
+  }
+
+  const allMemories: FormattedMemory[] = [];
+  const seenIds = new Set<string>();
+
+  for (let q = 0; q < config.startupRecall.queries.length; q++) {
+    const query = config.startupRecall.queries[q];
+    try {
+      const result = await automemRecall(query, {
+        limit: config.startupRecall.limit,
+        tags: config.startupRecall.tags,
+        tagMode: config.startupRecall.tagMode,
+      });
+
+      const text = result.content && result.content[0] ? result.content[0].text || "" : "";
+      const memories = parseSearchResults(text);
+      for (let i = 0; i < memories.length; i++) {
+        const mem = memories[i];
+        if (mem.id && !seenIds.has(mem.id)) {
+          seenIds.add(mem.id);
+          allMemories.push(mem);
+        } else if (!mem.id) {
+          const key = mem.content.slice(0, 80);
+          if (!seenIds.has(key)) {
+            seenIds.add(key);
+            allMemories.push(mem);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn('[automem] startup recall query failed: "' + query + '" - ' + err);
+    }
+  }
+
+  const maxBytes = config.startupRecall.maxBytes;
+  const text = formatMemoriesForContext(allMemories, maxBytes);
+  const truncated = Buffer.byteLength(text, "utf8") >= maxBytes && allMemories.length > 0;
+
+  return { text, count: allMemories.length, truncated };
+}
+
+// ---------------------------------------------------------------------------
+// Turn-level recall
+// ---------------------------------------------------------------------------
+
+export async function turnRecall(
+  prompt: string,
+  project: ProjectDetection,
+  config: AutoMemConfig,
+): Promise<RecallResult> {
+  if (!config.turnRecall.enabled) {
+    return { text: "", count: 0, truncated: false };
+  }
+
+  const query = project.projectLabel
+    ? prompt + " " + project.projectLabel
+    : prompt;
+
+  const tags: string[] = [];
+  if (project.projectTag) {
+    tags.push(project.projectTag);
+  }
+
+  const recallConfig = (project.projectTag && config.projectOverrides && config.projectOverrides[project.projectTag])
+    ? { ...config.turnRecall, ...config.projectOverrides[project.projectTag] }
+    : config.turnRecall;
+
+  try {
+    const result = await automemRecall(query, {
+      limit: recallConfig.limit,
+      tags: tags.length > 0 ? tags : undefined,
+      tagMode: "any",
+      contextTypes: recallConfig.contextTypes as unknown as string[],
+      expandRelations: recallConfig.expandRelations,
+      expandEntities: recallConfig.expandEntities,
+    });
+
+    const text = result.content && result.content[0] ? result.content[0].text || "" : "";
+    const memories = parseSearchResults(text);
+    const formatted = formatMemoriesForContext(memories, recallConfig.maxBytes);
+    const truncated = Buffer.byteLength(formatted, "utf8") >= recallConfig.maxBytes && memories.length > 0;
+
+    return { text: formatted, count: memories.length, truncated };
+  } catch (err) {
+    console.warn("[automem] turn recall failed: " + err);
+    return { text: "", count: 0, truncated: false };
+  }
+}