@agentmemory/agentmemory 0.7.0

package/src/functions/facets.ts

@@ -0,0 +1,248 @@
+import type { ISdk } from "iii-sdk";
+import type { StateKV } from "../state/kv.js";
+import { KV, generateId } from "../state/schema.js";
+import type { Facet } from "../types.js";
+
+export function registerFacetsFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    { id: "mem::facet-tag" },
+    async (data: {
+      targetId: string;
+      targetType: string;
+      dimension: string;
+      value: string;
+    }) => {
+      if (!data.targetId || typeof data.targetId !== "string") {
+        return { success: false, error: "targetId is required" };
+      }
+
+      const validTypes = ["action", "memory", "observation"];
+      if (!validTypes.includes(data.targetType)) {
+        return {
+          success: false,
+          error: `targetType must be one of: ${validTypes.join(", ")}`,
+        };
+      }
+
+      if (
+        !data.dimension ||
+        typeof data.dimension !== "string" ||
+        data.dimension.trim() === ""
+      ) {
+        return { success: false, error: "dimension is required" };
+      }
+
+      if (
+        !data.value ||
+        typeof data.value !== "string" ||
+        data.value.trim() === ""
+      ) {
+        return { success: false, error: "value is required" };
+      }
+
+      const dimension = data.dimension.trim();
+      const value = data.value.trim();
+
+      const existing = await kv.list<Facet>(KV.facets);
+      const duplicate = existing.find(
+        (f) =>
+          f.targetId === data.targetId &&
+          f.dimension === dimension &&
+          f.value === value,
+      );
+      if (duplicate) {
+        return { success: true, facet: duplicate, skipped: true };
+      }
+
+      const facet: Facet = {
+        id: generateId("fct"),
+        targetId: data.targetId,
+        targetType: data.targetType as Facet["targetType"],
+        dimension,
+        value,
+        createdAt: new Date().toISOString(),
+      };
+
+      await kv.set(KV.facets, facet.id, facet);
+      return { success: true, facet };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::facet-untag" },
+    async (data: {
+      targetId: string;
+      dimension: string;
+      value?: string;
+    }) => {
+      if (!data.targetId) {
+        return { success: false, error: "targetId is required" };
+      }
+      if (!data.dimension) {
+        return { success: false, error: "dimension is required" };
+      }
+
+      const all = await kv.list<Facet>(KV.facets);
+      const matches = all.filter((f) => {
+        if (f.targetId !== data.targetId || f.dimension !== data.dimension) {
+          return false;
+        }
+        if (data.value !== undefined) {
+          return f.value === data.value;
+        }
+        return true;
+      });
+
+      for (const f of matches) {
+        await kv.delete(KV.facets, f.id);
+      }
+
+      return { success: true, removed: matches.length };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::facet-query" },
+    async (data: {
+      matchAll?: string[];
+      matchAny?: string[];
+      targetType?: string;
+      limit?: number;
+    }) => {
+      if (
+        (!data.matchAll || data.matchAll.length === 0) &&
+        (!data.matchAny || data.matchAny.length === 0)
+      ) {
+        return {
+          success: false,
+          error: "at least one of matchAll or matchAny is required",
+        };
+      }
+
+      const all = await kv.list<Facet>(KV.facets);
+      const filtered = data.targetType
+        ? all.filter((f) => f.targetType === data.targetType)
+        : all;
+
+      const targetFacetMap = new Map<string, { targetType: string; facetKeys: Set<string> }>();
+      for (const f of filtered) {
+        const key = `${f.dimension}:${f.value}`;
+        let entry = targetFacetMap.get(f.targetId);
+        if (!entry) {
+          entry = { targetType: f.targetType, facetKeys: new Set() };
+          targetFacetMap.set(f.targetId, entry);
+        }
+        entry.facetKeys.add(key);
+      }
+
+      const results: Array<{ targetId: string; targetType: string; matchedFacets: string[] }> = [];
+
+      for (const [targetId, entry] of targetFacetMap) {
+        const matched: string[] = [];
+
+        if (data.matchAll && data.matchAll.length > 0) {
+          const allPresent = data.matchAll.every((k) => entry.facetKeys.has(k));
+          if (!allPresent) continue;
+          for (const k of data.matchAll) {
+            if (!matched.includes(k)) matched.push(k);
+          }
+        }
+
+        if (data.matchAny && data.matchAny.length > 0) {
+          const anyPresent = data.matchAny.filter((k) => entry.facetKeys.has(k));
+          if (anyPresent.length === 0) continue;
+          for (const k of anyPresent) {
+            if (!matched.includes(k)) matched.push(k);
+          }
+        }
+
+        results.push({
+          targetId,
+          targetType: entry.targetType,
+          matchedFacets: matched,
+        });
+      }
+
+      const limit = data.limit || 50;
+      return { success: true, results: results.slice(0, limit) };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::facet-get" },
+    async (data: { targetId: string }) => {
+      if (!data.targetId) {
+        return { success: false, error: "targetId is required" };
+      }
+
+      const all = await kv.list<Facet>(KV.facets);
+      const targetFacets = all.filter((f) => f.targetId === data.targetId);
+
+      const dimMap = new Map<string, string[]>();
+      for (const f of targetFacets) {
+        let values = dimMap.get(f.dimension);
+        if (!values) {
+          values = [];
+          dimMap.set(f.dimension, values);
+        }
+        values.push(f.value);
+      }
+
+      const dimensions = Array.from(dimMap.entries()).map(([dimension, values]) => ({
+        dimension,
+        values,
+      }));
+
+      return { success: true, dimensions };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::facet-stats" },
+    async (data: { targetType?: string }) => {
+      const all = await kv.list<Facet>(KV.facets);
+      const filtered = data.targetType
+        ? all.filter((f) => f.targetType === data.targetType)
+        : all;
+
+      const dimMap = new Map<string, Map<string, number>>();
+      for (const f of filtered) {
+        let valueMap = dimMap.get(f.dimension);
+        if (!valueMap) {
+          valueMap = new Map();
+          dimMap.set(f.dimension, valueMap);
+        }
+        valueMap.set(f.value, (valueMap.get(f.value) || 0) + 1);
+      }
+
+      const dimensions = Array.from(dimMap.entries()).map(([dimension, valueMap]) => ({
+        dimension,
+        values: Array.from(valueMap.entries()).map(([value, count]) => ({
+          value,
+          count,
+        })),
+      }));
+
+      return { success: true, dimensions, totalFacets: filtered.length };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::facet-dimensions" },
+    async () => {
+      const all = await kv.list<Facet>(KV.facets);
+
+      const counts = new Map<string, number>();
+      for (const f of all) {
+        counts.set(f.dimension, (counts.get(f.dimension) || 0) + 1);
+      }
+
+      const dimensions = Array.from(counts.entries()).map(([dimension, count]) => ({
+        dimension,
+        count,
+      }));
+
+      return { success: true, dimensions };
+    },
+  );
+}

package/src/functions/file-index.ts

@@ -0,0 +1,106 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type { CompressedObservation, Session } from "../types.js";
+import { KV } from "../state/schema.js";
+import { StateKV } from "../state/kv.js";
+
+interface FileHistory {
+  file: string;
+  observations: Array<{
+    sessionId: string;
+    obsId: string;
+    type: string;
+    title: string;
+    narrative: string;
+    importance: number;
+    timestamp: string;
+  }>;
+}
+
+export function registerFileIndexFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    { id: "mem::file-context" },
+    async (data: { sessionId: string; files: string[]; project?: string }) => {
+      const ctx = getContext();
+      const results: FileHistory[] = [];
+
+      const sessions = await kv.list<Session>(KV.sessions);
+      let otherSessions = sessions.filter((s) => s.id !== data.sessionId);
+      if (data.project) {
+        otherSessions = otherSessions.filter((s) => s.project === data.project);
+      }
+      otherSessions = otherSessions
+        .sort(
+          (a, b) =>
+            new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime(),
+        )
+        .slice(0, 15);
+
+      const obsCache = new Map<string, CompressedObservation[]>();
+      for (const session of otherSessions) {
+        obsCache.set(
+          session.id,
+          await kv.list<CompressedObservation>(KV.observations(session.id)),
+        );
+      }
+
+      for (const file of data.files) {
+        const history: FileHistory = { file, observations: [] };
+        const normalizedFile = file.replace(/^\.\//, "");
+
+        for (const session of otherSessions) {
+          const observations = obsCache.get(session.id) || [];
+
+          for (const obs of observations) {
+            if (!obs.files || !obs.title) continue;
+            const matches = obs.files.some(
+              (f) =>
+                f === file ||
+                f === normalizedFile ||
+                f.endsWith(`/${normalizedFile}`) ||
+                normalizedFile.endsWith(`/${f}`),
+            );
+            if (matches && obs.importance >= 4) {
+              history.observations.push({
+                sessionId: session.id,
+                obsId: obs.id,
+                type: obs.type,
+                title: obs.title,
+                narrative: obs.narrative,
+                importance: obs.importance,
+                timestamp: obs.timestamp,
+              });
+            }
+          }
+        }
+
+        history.observations.sort((a, b) => b.importance - a.importance);
+        history.observations = history.observations.slice(0, 5);
+
+        if (history.observations.length > 0) {
+          results.push(history);
+        }
+      }
+
+      if (results.length === 0) {
+        return { context: "" };
+      }
+
+      const lines: string[] = ["<agentmemory-file-context>"];
+      for (const fh of results) {
+        lines.push(`## ${fh.file}`);
+        for (const obs of fh.observations) {
+          lines.push(`- [${obs.type}] ${obs.title}: ${obs.narrative}`);
+        }
+      }
+      lines.push("</agentmemory-file-context>");
+
+      const context = lines.join("\n");
+      ctx.logger.info("File context generated", {
+        files: data.files.length,
+        results: results.length,
+      });
+      return { context };
+    },
+  );
+}

package/src/functions/flow-compress.ts

@@ -0,0 +1,214 @@
+import type { ISdk } from "iii-sdk";
+import type { StateKV } from "../state/kv.js";
+import { KV, generateId } from "../state/schema.js";
+import type { Action, ActionEdge, RoutineRun, MemoryProvider } from "../types.js";
+
+const FLOW_COMPRESS_SYSTEM = `You are a workflow summarizer. Given a completed action chain, produce a concise summary capturing:
+1. The overall goal and outcome
+2. Key steps taken and their results
+3. Any notable decisions or discoveries
+4. Lessons learned
+
+Output as XML:
+<summary>
+<goal>What was the workflow trying to achieve</goal>
+<outcome>What happened</outcome>
+<steps>Numbered list of key steps</steps>
+<discoveries>Any new insights or discoveries</discoveries>
+<lesson>What to remember for next time</lesson>
+</summary>`;
+
+export function registerFlowCompressFunction(
+  sdk: ISdk,
+  kv: StateKV,
+  provider: MemoryProvider,
+): void {
+  sdk.registerFunction(
+    { id: "mem::flow-compress" },
+    async (data: { runId?: string; actionIds?: string[]; project?: string }) => {
+      let actionsToCompress: Action[] = [];
+
+      if (data.runId) {
+        const run = await kv.get<RoutineRun>(KV.routineRuns, data.runId);
+        if (!run) {
+          return { success: false, error: "run not found" };
+        }
+        for (const id of run.actionIds) {
+          const action = await kv.get<Action>(KV.actions, id);
+          if (action) actionsToCompress.push(action);
+        }
+      } else if (data.actionIds && data.actionIds.length > 0) {
+        for (const id of data.actionIds) {
+          const action = await kv.get<Action>(KV.actions, id);
+          if (action) actionsToCompress.push(action);
+        }
+      } else if (data.project) {
+        const allActions = await kv.list<Action>(KV.actions);
+        actionsToCompress = allActions.filter(
+          (a) => a.project === data.project && a.status === "done",
+        );
+      } else {
+        return {
+          success: false,
+          error: "runId, actionIds, or project is required",
+        };
+      }
+
+      const doneActions = actionsToCompress.filter(
+        (a) => a.status === "done",
+      );
+      if (doneActions.length === 0) {
+        return {
+          success: true,
+          message: "No completed actions to compress",
+          compressed: 0,
+        };
+      }
+
+      const allEdges = await kv.list<ActionEdge>(KV.actionEdges);
+      const relevantIds = new Set(doneActions.map((a) => a.id));
+      const relevantEdges = allEdges.filter(
+        (e) =>
+          relevantIds.has(e.sourceActionId) ||
+          relevantIds.has(e.targetActionId),
+      );
+
+      const prompt = buildFlowPrompt(doneActions, relevantEdges);
+
+      try {
+        const response = await provider.summarize(
+          FLOW_COMPRESS_SYSTEM,
+          prompt,
+        );
+        const summary = parseFlowSummary(response);
+
+        const memory = {
+          id: generateId("mem"),
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          type: "workflow" as const,
+          title: summary.goal || `Workflow: ${doneActions.length} actions`,
+          content: formatSummary(summary),
+          concepts: extractConcepts(doneActions),
+          files: extractFiles(doneActions),
+          sessionIds: [],
+          strength: 1.0,
+          version: 1,
+          isLatest: true,
+          metadata: {
+            flowCompressed: true,
+            actionCount: doneActions.length,
+            actionIds: doneActions.map((a) => a.id),
+          },
+        };
+
+        await kv.set(KV.memories, memory.id, memory);
+
+        return {
+          success: true,
+          compressed: doneActions.length,
+          memoryId: memory.id,
+          summary,
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: `compression failed: ${String(err)}`,
+          compressed: 0,
+        };
+      }
+    },
+  );
+}
+
+function buildFlowPrompt(
+  actions: Action[],
+  edges: ActionEdge[],
+): string {
+  const lines: string[] = ["## Completed Action Chain\n"];
+
+  const sorted = [...actions].sort(
+    (a, b) =>
+      new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
+  );
+
+  for (const action of sorted) {
+    lines.push(`### ${action.title}`);
+    if (action.description) lines.push(action.description);
+    if (action.result) lines.push(`Result: ${action.result}`);
+    lines.push(`Priority: ${action.priority}, Tags: ${(action.tags ?? []).join(", ")}`);
+    lines.push("");
+  }
+
+  if (edges.length > 0) {
+    lines.push("## Dependencies");
+    for (const edge of edges) {
+      lines.push(`- ${edge.sourceActionId} --${edge.type}--> ${edge.targetActionId}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function parseFlowSummary(response: string): {
+  goal: string;
+  outcome: string;
+  steps: string;
+  discoveries: string;
+  lesson: string;
+} {
+  const extract = (tag: string): string => {
+    const match = response.match(
+      new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`),
+    );
+    return match ? match[1].trim() : "";
+  };
+  return {
+    goal: extract("goal"),
+    outcome: extract("outcome"),
+    steps: extract("steps"),
+    discoveries: extract("discoveries"),
+    lesson: extract("lesson"),
+  };
+}
+
+function formatSummary(s: {
+  goal: string;
+  outcome: string;
+  steps: string;
+  discoveries: string;
+  lesson: string;
+}): string {
+  const parts: string[] = [];
+  if (s.goal) parts.push(`Goal: ${s.goal}`);
+  if (s.outcome) parts.push(`Outcome: ${s.outcome}`);
+  if (s.steps) parts.push(`Steps: ${s.steps}`);
+  if (s.discoveries) parts.push(`Discoveries: ${s.discoveries}`);
+  if (s.lesson) parts.push(`Lesson: ${s.lesson}`);
+  return parts.join("\n\n");
+}
+
+function extractConcepts(actions: Action[]): string[] {
+  const concepts = new Set<string>();
+  for (const a of actions) {
+    for (const tag of a.tags ?? []) {
+      if (!tag.startsWith("routine:")) concepts.add(tag);
+    }
+  }
+  return Array.from(concepts);
+}
+
+function extractFiles(actions: Action[]): string[] {
+  const files = new Set<string>();
+  for (const a of actions) {
+    if (a.metadata && typeof a.metadata === "object") {
+      const meta = a.metadata as Record<string, unknown>;
+      if (Array.isArray(meta.files)) {
+        for (const f of meta.files) {
+          if (typeof f === "string") files.add(f);
+        }
+      }
+    }
+  }
+  return Array.from(files);
+}