@agentmemory/agentmemory 0.7.2 → 0.7.3

package/src/functions/facets.ts

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

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

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