@agentmemory/agentmemory 0.7.0

package/src/functions/snapshot.ts

@@ -0,0 +1,219 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { SnapshotMeta, Session, Memory, GraphNode } from "../types.js";
+import { KV, generateId } from "../state/schema.js";
+import type { StateKV } from "../state/kv.js";
+import { recordAudit } from "./audit.js";
+import { VERSION } from "../version.js";
+
+const COMMIT_HASH_RE = /^[0-9a-f]{7,40}$/i;
+
+const execFileAsync = promisify(execFile);
+
+async function gitExec(dir: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("git", args, { cwd: dir });
+  return stdout.trim();
+}
+
+async function ensureGitRepo(dir: string): Promise<void> {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  if (!existsSync(join(dir, ".git"))) {
+    await gitExec(dir, ["init"]);
+    await gitExec(dir, ["config", "user.email", "agentmemory@local"]);
+    await gitExec(dir, ["config", "user.name", "agentmemory"]);
+  }
+}
+
+export function registerSnapshotFunction(
+  sdk: ISdk,
+  kv: StateKV,
+  snapshotDir: string,
+): void {
+  sdk.registerFunction(
+    { id: "mem::snapshot-create" },
+    async (data?: { message?: string }) => {
+      const ctx = getContext();
+
+      try {
+        await ensureGitRepo(snapshotDir);
+
+        const sessions = await kv.list<Session>(KV.sessions);
+        const memories = await kv.list<Memory>(KV.memories);
+        const graphNodes = await kv.list<GraphNode>(KV.graphNodes);
+
+        const observations: Record<string, unknown[]> = {};
+        for (const session of sessions) {
+          const obs = await kv
+            .list(KV.observations(session.id))
+            .catch(() => []);
+          if (obs.length > 0) {
+            observations[session.id] = obs;
+          }
+        }
+
+        const state = {
+          version: VERSION,
+          timestamp: new Date().toISOString(),
+          sessions,
+          memories,
+          graphNodes,
+          observations,
+        };
+
+        writeFileSync(
+          join(snapshotDir, "state.json"),
+          JSON.stringify(state, null, 2),
+          "utf-8",
+        );
+
+        await gitExec(snapshotDir, ["add", "."]);
+
+        const message = data?.message || `Snapshot ${new Date().toISOString()}`;
+        try {
+          await gitExec(snapshotDir, ["commit", "-m", message]);
+        } catch (commitErr) {
+          const errMsg =
+            commitErr instanceof Error ? commitErr.message : String(commitErr);
+          if (errMsg.includes("nothing to commit")) {
+            return { success: true, message: "No changes to snapshot" };
+          }
+          throw commitErr;
+        }
+
+        const commitHash = await gitExec(snapshotDir, ["rev-parse", "HEAD"]);
+
+        const meta: SnapshotMeta = {
+          id: generateId("snap"),
+          commitHash,
+          createdAt: new Date().toISOString(),
+          message,
+          stats: {
+            sessions: sessions.length,
+            observations: Object.values(observations).reduce(
+              (sum, arr) => sum + arr.length,
+              0,
+            ),
+            memories: memories.length,
+            graphNodes: graphNodes.length,
+          },
+        };
+
+        await recordAudit(kv, "export", "mem::snapshot-create", [meta.id], {
+          commitHash,
+          stats: meta.stats,
+        });
+
+        ctx.logger.info("Snapshot created", { commitHash });
+        return { success: true, snapshot: meta };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.logger.error("Snapshot failed", { error: msg });
+        return { success: false, error: msg };
+      }
+    },
+  );
+
+  sdk.registerFunction({ id: "mem::snapshot-list" }, async () => {
+    try {
+      if (!existsSync(join(snapshotDir, ".git"))) {
+        return { snapshots: [] };
+      }
+      const log = await gitExec(snapshotDir, [
+        "log",
+        "--format=%H|%aI|%s",
+        "-20",
+      ]);
+      const snapshots = log
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+          const parts = line.split("|");
+          const [hash, date] = parts;
+          const msg = parts.slice(2).join("|");
+          return { commitHash: hash, createdAt: date, message: msg };
+        });
+      return { snapshots };
+    } catch {
+      return { snapshots: [] };
+    }
+  });
+
+  sdk.registerFunction(
+    { id: "mem::snapshot-restore" },
+    async (data: { commitHash: string }) => {
+      const ctx = getContext();
+      if (!data.commitHash) {
+        return { success: false, error: "commitHash is required" };
+      }
+      if (!COMMIT_HASH_RE.test(data.commitHash)) {
+        return { success: false, error: "Invalid commitHash format" };
+      }
+
+      try {
+        await gitExec(snapshotDir, [
+          "checkout",
+          data.commitHash,
+          "--",
+          "state.json",
+        ]);
+        const content = readFileSync(join(snapshotDir, "state.json"), "utf-8");
+        const state = JSON.parse(content) as {
+          sessions?: Array<{ id: string } & Record<string, unknown>>;
+          memories?: Array<{ id: string } & Record<string, unknown>>;
+          graphNodes?: Array<{ id: string } & Record<string, unknown>>;
+          observations?: Record<
+            string,
+            Array<{ id: string } & Record<string, unknown>>
+          >;
+        };
+
+        if (state.sessions) {
+          for (const session of state.sessions) {
+            await kv.set(KV.sessions, session.id, session);
+          }
+        }
+        if (state.memories) {
+          for (const memory of state.memories) {
+            await kv.set(KV.memories, memory.id, memory);
+          }
+        }
+        if (state.graphNodes) {
+          for (const node of state.graphNodes) {
+            await kv.set(KV.graphNodes, node.id, node);
+          }
+        }
+        if (state.observations) {
+          for (const [sessionId, obs] of Object.entries(state.observations)) {
+            for (const o of obs) {
+              await kv.set(KV.observations(sessionId), o.id, o);
+            }
+          }
+        }
+
+        await gitExec(snapshotDir, ["checkout", "HEAD", "--", "state.json"]);
+
+        await recordAudit(kv, "import", "mem::snapshot-restore", [], {
+          commitHash: data.commitHash,
+          sessions: state.sessions?.length || 0,
+          memories: state.memories?.length || 0,
+          graphNodes: state.graphNodes?.length || 0,
+        });
+
+        ctx.logger.info("Snapshot restored", {
+          commitHash: data.commitHash,
+        });
+        return { success: true, commitHash: data.commitHash };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.logger.error("Snapshot restore failed", { error: msg });
+        return { success: false, error: msg };
+      }
+    },
+  );
+}

package/src/functions/summarize.ts

@@ -0,0 +1,155 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type {
+  CompressedObservation,
+  SessionSummary,
+  MemoryProvider,
+  Session,
+} from "../types.js";
+import { KV } from "../state/schema.js";
+import { StateKV } from "../state/kv.js";
+import { SUMMARY_SYSTEM, buildSummaryPrompt } from "../prompts/summary.js";
+import { getXmlTag, getXmlChildren } from "../prompts/xml.js";
+import { SummaryOutputSchema } from "../eval/schemas.js";
+import { validateOutput } from "../eval/validator.js";
+import { scoreSummary } from "../eval/quality.js";
+import type { MetricsStore } from "../eval/metrics-store.js";
+
+function parseSummaryXml(
+  xml: string,
+  sessionId: string,
+  project: string,
+  obsCount: number,
+): SessionSummary | null {
+  const title = getXmlTag(xml, "title");
+  if (!title) return null;
+
+  return {
+    sessionId,
+    project,
+    createdAt: new Date().toISOString(),
+    title,
+    narrative: getXmlTag(xml, "narrative"),
+    keyDecisions: getXmlChildren(xml, "decisions", "decision"),
+    filesModified: getXmlChildren(xml, "files", "file"),
+    concepts: getXmlChildren(xml, "concepts", "concept"),
+    observationCount: obsCount,
+  };
+}
+
+export function registerSummarizeFunction(
+  sdk: ISdk,
+  kv: StateKV,
+  provider: MemoryProvider,
+  metricsStore?: MetricsStore,
+): void {
+  sdk.registerFunction(
+    { id: "mem::summarize", description: "Generate end-of-session summary" },
+    async (data: { sessionId: string }) => {
+      const ctx = getContext();
+      const startMs = Date.now();
+
+      const session = await kv.get<Session>(KV.sessions, data.sessionId);
+      if (!session) {
+        ctx.logger.warn("Session not found for summarize", {
+          sessionId: data.sessionId,
+        });
+        return { success: false, error: "session_not_found" };
+      }
+
+      const observations = await kv.list<CompressedObservation>(
+        KV.observations(data.sessionId),
+      );
+      const compressed = observations.filter((o) => o.title);
+
+      if (compressed.length === 0) {
+        ctx.logger.info("No observations to summarize", {
+          sessionId: data.sessionId,
+        });
+        return { success: false, error: "no_observations" };
+      }
+
+      try {
+        const prompt = buildSummaryPrompt(compressed);
+        const response = await provider.summarize(SUMMARY_SYSTEM, prompt);
+        const summary = parseSummaryXml(
+          response,
+          data.sessionId,
+          session.project,
+          compressed.length,
+        );
+
+        if (!summary) {
+          const latencyMs = Date.now() - startMs;
+          if (metricsStore) {
+            await metricsStore.record("mem::summarize", latencyMs, false);
+          }
+          ctx.logger.warn("Failed to parse summary XML", {
+            sessionId: data.sessionId,
+          });
+          return { success: false, error: "parse_failed" };
+        }
+
+        const summaryForValidation = {
+          title: summary.title,
+          narrative: summary.narrative,
+          keyDecisions: summary.keyDecisions,
+          filesModified: summary.filesModified,
+          concepts: summary.concepts,
+        };
+        const validation = validateOutput(
+          SummaryOutputSchema,
+          summaryForValidation,
+          "mem::summarize",
+        );
+
+        if (!validation.valid) {
+          const latencyMs = Date.now() - startMs;
+          if (metricsStore) {
+            await metricsStore.record("mem::summarize", latencyMs, false);
+          }
+          ctx.logger.warn("Summary validation failed", {
+            sessionId: data.sessionId,
+            errors: validation.result.errors,
+          });
+          return { success: false, error: "validation_failed" };
+        }
+
+        const qualityScore = scoreSummary(summaryForValidation);
+
+        await kv.set(KV.summaries, data.sessionId, summary);
+
+        const latencyMs = Date.now() - startMs;
+        if (metricsStore) {
+          await metricsStore.record(
+            "mem::summarize",
+            latencyMs,
+            true,
+            qualityScore,
+          );
+        }
+
+        ctx.logger.info("Session summarized", {
+          sessionId: data.sessionId,
+          title: summary.title,
+          decisions: summary.keyDecisions.length,
+          qualityScore,
+          valid: validation.valid,
+        });
+
+        return { success: true, summary, qualityScore };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const latencyMs = Date.now() - startMs;
+        if (metricsStore) {
+          await metricsStore.record("mem::summarize", latencyMs, false);
+        }
+        ctx.logger.error("Summarize failed", {
+          sessionId: data.sessionId,
+          error: msg,
+        });
+        return { success: false, error: msg };
+      }
+    },
+  );
+}

package/src/functions/team.ts

@@ -0,0 +1,147 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type {
+  TeamConfig,
+  TeamSharedItem,
+  TeamProfile,
+  Memory,
+} from "../types.js";
+import { KV, generateId } from "../state/schema.js";
+import type { StateKV } from "../state/kv.js";
+import { recordAudit } from "./audit.js";
+
+const VALID_ITEM_TYPES = new Set(["memory", "pattern", "observation"]);
+
+export function registerTeamFunction(
+  sdk: ISdk,
+  kv: StateKV,
+  config: TeamConfig,
+): void {
+  sdk.registerFunction(
+    { id: "mem::team-share" },
+    async (data: {
+      itemId: string;
+      itemType: "memory" | "pattern" | "observation";
+      sessionId?: string;
+      project?: string;
+    }) => {
+      const ctx = getContext();
+      if (!data.itemId || !data.itemType) {
+        return { success: false, error: "itemId and itemType are required" };
+      }
+      if (!VALID_ITEM_TYPES.has(data.itemType)) {
+        return { success: false, error: `Invalid itemType: ${data.itemType}` };
+      }
+
+      let content: unknown;
+      if (data.itemType === "observation") {
+        if (!data.sessionId) {
+          return {
+            success: false,
+            error: "sessionId is required for observations",
+          };
+        }
+        content = await kv.get(KV.observations(data.sessionId), data.itemId);
+      } else {
+        content = await kv.get<Memory>(KV.memories, data.itemId);
+      }
+      if (!content) {
+        return { success: false, error: "Item not found" };
+      }
+
+      const shared: TeamSharedItem = {
+        id: generateId("ts"),
+        sharedBy: config.userId,
+        sharedAt: new Date().toISOString(),
+        type: data.itemType,
+        content,
+        project: data.project || "",
+        visibility: "shared",
+      };
+
+      await kv.set(KV.teamShared(config.teamId), shared.id, shared);
+
+      await recordAudit(kv, "share", "mem::team-share", [data.itemId], {
+        teamId: config.teamId,
+        userId: config.userId,
+        itemType: data.itemType,
+      });
+
+      ctx.logger.info("Team share", {
+        teamId: config.teamId,
+        itemId: data.itemId,
+      });
+      return { success: true, sharedItem: shared };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::team-feed" },
+    async (data?: { limit?: number }) => {
+      const limit = data?.limit || 20;
+      const items = await kv.list<TeamSharedItem>(KV.teamShared(config.teamId));
+
+      const filtered = items.filter((i) => i.visibility === "shared");
+      const sorted = filtered
+        .sort(
+          (a, b) =>
+            new Date(b.sharedAt).getTime() - new Date(a.sharedAt).getTime(),
+        )
+        .slice(0, limit);
+
+      return { items: sorted, total: filtered.length };
+    },
+  );
+
+  sdk.registerFunction({ id: "mem::team-profile" }, async () => {
+    const items = await kv.list<TeamSharedItem>(KV.teamShared(config.teamId));
+
+    const members = [...new Set(items.map((i) => i.sharedBy))];
+
+    const conceptCounts = new Map<string, number>();
+    const fileCounts = new Map<string, number>();
+    const patterns: string[] = [];
+
+    for (const item of items) {
+      if (item.type === "memory" || item.type === "pattern") {
+        const mem = item.content as Memory;
+        if (mem?.concepts) {
+          for (const c of mem.concepts) {
+            conceptCounts.set(c, (conceptCounts.get(c) || 0) + 1);
+          }
+        }
+        if (mem?.files) {
+          for (const f of mem.files) {
+            fileCounts.set(f, (fileCounts.get(f) || 0) + 1);
+          }
+        }
+        if (item.type === "pattern" && mem?.content) {
+          patterns.push(mem.content.slice(0, 100));
+        }
+      }
+    }
+
+    const topConcepts = [...conceptCounts.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10)
+      .map(([concept, frequency]) => ({ concept, frequency }));
+
+    const topFiles = [...fileCounts.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10)
+      .map(([file, frequency]) => ({ file, frequency }));
+
+    const profile: TeamProfile = {
+      teamId: config.teamId,
+      members,
+      topConcepts,
+      topFiles,
+      sharedPatterns: patterns.slice(0, 10),
+      totalSharedItems: items.length,
+      updatedAt: new Date().toISOString(),
+    };
+
+    await kv.set(KV.teamProfile(config.teamId), "profile", profile);
+    return profile;
+  });
+}