@agentmemory/agentmemory 0.7.2 → 0.7.3

package/src/functions/snapshot.ts

@@ -1,219 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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;
-  });
-}