pi-automem-core 0.2.0

package/src/config.ts

@@ -0,0 +1,251 @@
+/**
+ * config.ts - Config loading, defaults, validation, and env-var resolution.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type MemoryType =
+  | "Decision"
+  | "Pattern"
+  | "Preference"
+  | "Style"
+  | "Habit"
+  | "Insight"
+  | "Context";
+
+export type RelationshipType =
+  | "RELATES_TO"
+  | "LEADS_TO"
+  | "OCCURRED_BEFORE"
+  | "PREFERS_OVER"
+  | "EXEMPLIFIES"
+  | "CONTRADICTS"
+  | "REINFORCES"
+  | "INVALIDATED_BY"
+  | "EVOLVED_INTO"
+  | "DERIVED_FROM"
+  | "PART_OF";
+
+export interface ProjectRecallOverride {
+  limit?: number;
+  maxBytes?: number;
+  contextTypes?: MemoryType[];
+  expandRelations?: boolean;
+  expandEntities?: boolean;
+}
+
+export interface AutoMemConfig {
+  mcpServerName: string;
+  startupRecall: {
+    enabled: boolean;
+    queries: string[];
+    tags: string[];
+    tagMode: "any" | "all";
+    limit: number;
+    maxBytes: number;
+    showStatus: boolean;
+  };
+  turnRecall: {
+    enabled: boolean;
+    limit: number;
+    maxBytes: number;
+    contextTypes: MemoryType[];
+    expandRelations: boolean;
+    expandEntities: boolean;
+  };
+  projectDetection: {
+    enabled: boolean;
+    tagPrefix: string;
+    folderTags: Record<string, string[]>;
+    gitRepoToTag: Record<string, string>;
+  };
+  projectOverrides?: Record<string, ProjectRecallOverride>;
+  writePolicy: {
+    mode: "off" | "propose" | "safe-auto" | "confirm-all";
+    autoWriteCategories: string[];
+    confirmCategories: string[];
+    blockedCategories: string[];
+    defaultSource: string;
+    machineTag: boolean;
+    alwaysTag: string[];
+    minImportanceToWrite: number;
+    dedupeBeforeWrite: boolean;
+    dedupeLimit: number;
+  };
+  behavior: {
+    injectSystemPrompt: boolean;
+    displayRecall: "full" | "summary" | "hidden";
+    maxContentLength: number;
+    preferredContentLength: number;
+  };
+  viewer: {
+    enabled: boolean;
+    mode: "standalone" | "embedded";
+    port: number;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_CONFIG: AutoMemConfig = {
+  mcpServerName: "automem",
+  startupRecall: {
+    enabled: true,
+    queries: ["user preferences working style environment"],
+    tags: [],
+    tagMode: "any",
+    limit: 8,
+    maxBytes: 6000,
+    showStatus: true,
+  },
+  turnRecall: {
+    enabled: true,
+    limit: 6,
+    maxBytes: 4000,
+    contextTypes: ["Preference", "Decision", "Pattern", "Insight", "Context"],
+    expandRelations: true,
+    expandEntities: true,
+  },
+  projectDetection: {
+    enabled: true,
+    tagPrefix: "project:",
+    folderTags: {},
+    gitRepoToTag: {},
+  },
+  writePolicy: {
+    mode: "safe-auto",
+    autoWriteCategories: ["technical-decision", "agent-pattern", "bug-fix", "tooling-lesson"],
+    confirmCategories: ["personal", "financial", "private", "identity"],
+    blockedCategories: ["secret", "credential", "api-key", "raw-transcript"],
+    defaultSource: "pi-session",
+    machineTag: true,
+    alwaysTag: ["source:pi"],
+    minImportanceToWrite: 0.7,
+    dedupeBeforeWrite: true,
+    dedupeLimit: 3,
+  },
+  behavior: {
+    injectSystemPrompt: true,
+    displayRecall: "summary",
+    maxContentLength: 2000,
+    preferredContentLength: 500,
+  },
+  viewer: {
+    enabled: false,
+    mode: "standalone",
+    port: 3000,
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Config path resolution
+// ---------------------------------------------------------------------------
+
+export function resolveConfigPath(): string {
+  const envPath = process.env.AUTOMEM_CONFIG_PATH;
+  if (envPath) return resolve(envPath);
+  return resolve(homedir(), ".pi", "agent", "automem.json");
+}
+
+// ---------------------------------------------------------------------------
+// Env-var interpolation
+// ---------------------------------------------------------------------------
+
+export function resolveEnvVars(value: string): string {
+  return value.replace(/\$\{([^}]+)\}/g, function(_match: string, name: string) {
+    const v = process.env[name];
+    if (v === undefined) {
+      console.warn('[automem] env var "' + name + '" referenced in config but not set');
+      return "";
+    }
+    return v;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Deep merge
+// ---------------------------------------------------------------------------
+
+function deepMerge(base: any, override: any): any {
+  const result = Object.assign({}, base);
+  const keys = Object.keys(override);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const bVal = (base as any)[key];
+    const oVal = override[key];
+    if (
+      oVal !== undefined &&
+      typeof oVal === "object" &&
+      oVal !== null &&
+      !Array.isArray(oVal) &&
+      typeof bVal === "object" &&
+      bVal !== null &&
+      !Array.isArray(bVal)
+    ) {
+      (result as any)[key] = deepMerge(bVal, oVal);
+    } else if (oVal !== undefined) {
+      (result as any)[key] = oVal;
+    }
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Load + validate
+// ---------------------------------------------------------------------------
+
+export function loadConfig(): AutoMemConfig {
+  const configPath = resolveConfigPath();
+
+  if (!existsSync(configPath)) {
+    console.log("[automem] no config at " + configPath + ", using defaults");
+    return DEFAULT_CONFIG;
+  }
+
+  let raw: any;
+  try {
+    const text = readFileSync(configPath, "utf8");
+    raw = JSON.parse(text);
+  } catch (err) {
+    console.error("[automem] failed to read/parse config: " + err);
+    return DEFAULT_CONFIG;
+  }
+
+  if (typeof raw !== "object" || raw === null) {
+    console.error("[automem] config root must be an object, using defaults");
+    return DEFAULT_CONFIG;
+  }
+
+  const config = deepMerge(DEFAULT_CONFIG, raw) as AutoMemConfig;
+
+  if (config.startupRecall.limit < 1 || config.startupRecall.limit > 20) {
+    console.warn("[automem] startupRecall.limit out of range (1-20), clamping to 8");
+    config.startupRecall.limit = 8;
+  }
+  if (config.turnRecall.limit < 1 || config.turnRecall.limit > 20) {
+    console.warn("[automem] turnRecall.limit out of range (1-20), clamping to 6");
+    config.turnRecall.limit = 6;
+  }
+
+  const validDisplayModes = ["full", "summary", "hidden"];
+  if (!validDisplayModes.includes(config.behavior.displayRecall)) {
+    console.warn("[automem] unknown behavior.displayRecall \"" + config.behavior.displayRecall + "\", valid values: full, summary, hidden. Defaulting to \"summary\"");
+    config.behavior.displayRecall = "summary";
+  }
+
+  const validWriteModes = ["off", "propose", "safe-auto", "confirm-all"];
+  if (!validWriteModes.includes(config.writePolicy.mode)) {
+    console.warn("[automem] unknown writePolicy.mode \"" + config.writePolicy.mode + "\", valid values: off, propose, safe-auto, confirm-all. Defaulting to \"propose\"");
+    config.writePolicy.mode = "propose";
+  }
+
+  return config;
+}

package/src/context-injector.ts

@@ -0,0 +1,42 @@
+/**
+ * context-injector.ts - Build the context message injected into the session
+ * from recall results.
+ */
+
+import type { RecallResult } from "./recall";
+import type { ProjectDetection } from "./project-detect";
+
+export interface Injection {
+  message: string;
+  projectTag: string | null;
+}
+
+export function buildContextMessage(
+  startupResult: RecallResult,
+  turnResult: RecallResult,
+  project: ProjectDetection,
+): Injection | null {
+  const sections: string[] = [];
+
+  if (startupResult.text) {
+    sections.push(
+      "## AutoMem Startup Recall (" + startupResult.count + " memories)\n" + startupResult.text
+    );
+  }
+
+  if (turnResult.text) {
+    const projectLabel = project.projectLabel ? " [" + project.projectLabel + "]" : "";
+    sections.push(
+      "## AutoMem Turn Recall" + projectLabel + " (" + turnResult.count + " memories)\n" + turnResult.text
+    );
+  }
+
+  if (sections.length === 0) {
+    return null;
+  }
+
+  return {
+    message: sections.join("\n\n"),
+    projectTag: project.projectTag,
+  };
+}

package/src/index.ts

@@ -0,0 +1,158 @@
+/**
+ * index.ts - AutoMem Core Extension entry point.
+ *
+ * Phase 1: Recall-only core.
+ * - session_start: load config, health check, startup recall
+ * - before_agent_start: turn-level recall, inject context
+ * - /automem-status: health + memory count
+ * - /automem-recall: manual recall
+ * - status widget in footer
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "./config";
+import { automemHealth, discoverTools, setAutoMemMcpServerName } from "./mcp-client";
+import { startupRecall, turnRecall, type RecallResult } from "./recall";
+import { detectProject } from "./project-detect";
+import { buildContextMessage } from "./context-injector";
+import { registerStatusCommand } from "./commands/status";
+import { registerRecallCommand } from "./commands/recall";
+import { registerMemoryTools } from "./tools/memory-tools";
+import { registerRelationshipTools } from "./tools/relationship-tools";
+
+export default function (pi: ExtensionAPI) {
+  let config = loadConfig();
+  setAutoMemMcpServerName(config.mcpServerName);
+  let autoMemHealthy = false;
+  let autoMemCount: number | undefined;
+  let startupInjected = false;
+  let startupResult: RecallResult = { text: "", count: 0, truncated: false };
+
+  // Register commands and Phase 2 explicit write tools
+  registerStatusCommand(pi);
+  registerRecallCommand(pi);
+  registerMemoryTools(pi);
+  registerRelationshipTools(pi);
+
+  // session_start - Load config, check health, run startup recall
+  pi.on("session_start", async function(_event: any, ctx: any) {
+    config = loadConfig();
+    setAutoMemMcpServerName(config.mcpServerName);
+
+    try {
+      await discoverTools();
+      const health = await automemHealth();
+      autoMemHealthy = health.healthy;
+      autoMemCount = health.memoryCount;
+
+      if (health.healthy) {
+        const count = health.memoryCount != null ? " (" + health.memoryCount + ")" : "";
+        ctx.ui.notify("AutoMem: healthy" + count, "info");
+      } else {
+        ctx.ui.notify("AutoMem: unhealthy - " + (health.error || "unreachable"), "warning");
+      }
+    } catch (err) {
+      autoMemHealthy = false;
+      ctx.ui.notify("AutoMem health check failed: " + err, "warning");
+    }
+
+    if (config.startupRecall.enabled && autoMemHealthy) {
+      try {
+        startupResult = await startupRecall(config);
+        if (startupResult.count > 0 && config.startupRecall.showStatus) {
+          ctx.ui.notify("AutoMem: recalled " + startupResult.count + " memories at startup", "info");
+        }
+      } catch (err) {
+        ctx.ui.notify("AutoMem startup recall failed: " + err, "warning");
+      }
+    }
+
+    updateStatusWidget(ctx);
+  });
+
+  // before_agent_start - Turn-level recall + context injection
+  pi.on("before_agent_start", async function(event: any, ctx: any) {
+    if (!autoMemHealthy) return;
+
+    const prompt = event.prompt || "";
+    if (!prompt.trim()) return;
+
+    const project = detectProject(ctx.cwd, prompt, config);
+
+    let turnResult;
+    try {
+      turnResult = await turnRecall(prompt, project, config);
+    } catch (err) {
+      console.warn("[automem] turn recall failed: " + err);
+      return;
+    }
+
+    const startupForInjection = startupInjected
+      ? { text: "", count: 0, truncated: false }
+      : startupResult;
+
+    if (turnResult.count === 0 && !startupForInjection.text) return;
+
+    const injection = buildContextMessage(
+      startupForInjection,
+      { text: turnResult.text, count: turnResult.count, truncated: turnResult.truncated },
+      project,
+    );
+
+    if (!injection) return;
+
+    if (startupForInjection.text) startupInjected = true;
+
+    const displayRecall = config.behavior.displayRecall || "summary";
+    const displayFull = displayRecall === "full";
+
+    if (displayRecall === "summary") {
+      const parts: string[] = [];
+      if (startupForInjection.count > 0) parts.push("startup " + startupForInjection.count);
+      if (turnResult.count > 0) parts.push("turn " + turnResult.count);
+      const projectPart = project.projectLabel ? " [" + project.projectLabel + "]" : "";
+      ctx.ui.notify("AutoMem recalled" + projectPart + ": " + parts.join(", "), "info");
+    }
+
+    if (displayFull) {
+      return {
+        message: {
+          customType: "automem-recall",
+          content: injection.message,
+          display: true,
+        },
+      };
+    }
+
+    // Hidden/summary mode: inject into the per-turn system prompt instead of
+    // returning a session message. `display: false` hides from the TUI, but API
+    // transcripts can still expose message injections as large context blocks.
+    return {
+      systemPrompt: (event.systemPrompt || "") + "\n\n" + injection.message,
+    };
+  });
+
+  // session_shutdown - Cleanup
+  pi.on("session_shutdown", async function(_event: any, _ctx: any) {
+    autoMemHealthy = false;
+    autoMemCount = undefined;
+    startupInjected = false;
+    startupResult = { text: "", count: 0, truncated: false };
+  });
+
+  function updateStatusWidget(ctx: any) {
+    const theme = ctx.ui.theme;
+    if (autoMemHealthy) {
+      const count = autoMemCount != null ? " (" + autoMemCount + ")" : "";
+      ctx.ui.setStatus(
+        "automem",
+        theme.fg("success", "\u25CF") + theme.fg("dim", " AutoMem" + count),
+      );
+    } else {
+      ctx.ui.setStatus(
+        "automem",
+        theme.fg("error", "\u25CF") + theme.fg("dim", " AutoMem (offline)"),
+      );
+    }
+  }
+}