@agentmemory/agentmemory 0.7.2 → 0.7.3

package/src/functions/context.ts

@@ -1,169 +0,0 @@
-import type { ISdk } from "iii-sdk";
-import { getContext } from "iii-sdk";
-import type {
-  Session,
-  CompressedObservation,
-  SessionSummary,
-  ContextBlock,
-  ProjectProfile,
-} from "../types.js";
-import { KV } from "../state/schema.js";
-import { StateKV } from "../state/kv.js";
-
-function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 3);
-}
-
-function escapeXmlAttr(s: string): string {
-  return s
-    .replace(/&/g, "&")
-    .replace(/"/g, """)
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-export function registerContextFunction(
-  sdk: ISdk,
-  kv: StateKV,
-  tokenBudget: number,
-): void {
-  sdk.registerFunction(
-    {
-      id: "mem::context",
-      description: "Generate context for session injection",
-    },
-    async (data: { sessionId: string; project: string; budget?: number }) => {
-      const ctx = getContext();
-      const budget = data.budget || tokenBudget;
-      const blocks: ContextBlock[] = [];
-
-      const profile = await kv
-        .get<ProjectProfile>(KV.profiles, data.project)
-        .catch(() => null);
-      if (profile) {
-        const profileParts = [];
-        if (profile.topConcepts.length > 0) {
-          profileParts.push(
-            `Concepts: ${profile.topConcepts
-              .slice(0, 8)
-              .map((c) => c.concept)
-              .join(", ")}`,
-          );
-        }
-        if (profile.topFiles.length > 0) {
-          profileParts.push(
-            `Key files: ${profile.topFiles
-              .slice(0, 5)
-              .map((f) => f.file)
-              .join(", ")}`,
-          );
-        }
-        if (profile.conventions.length > 0) {
-          profileParts.push(`Conventions: ${profile.conventions.join("; ")}`);
-        }
-        if (profile.commonErrors.length > 0) {
-          profileParts.push(
-            `Common errors: ${profile.commonErrors.slice(0, 3).join("; ")}`,
-          );
-        }
-        if (profileParts.length > 0) {
-          const profileContent = `## Project Profile\n${profileParts.join("\n")}`;
-          blocks.push({
-            type: "memory",
-            content: profileContent,
-            tokens: estimateTokens(profileContent),
-            recency: new Date(profile.updatedAt).getTime(),
-          });
-        }
-      }
-
-      const allSessions = await kv.list<Session>(KV.sessions);
-      const sessions = allSessions
-        .filter((s) => s.project === data.project && s.id !== data.sessionId)
-        .sort(
-          (a, b) =>
-            new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime(),
-        )
-        .slice(0, 10);
-
-      const summariesPerSession = await Promise.all(
-        sessions.map((s) =>
-          kv.get<SessionSummary>(KV.summaries, s.id).catch(() => null),
-        ),
-      );
-
-      const sessionsNeedingObs: number[] = [];
-      for (let i = 0; i < sessions.length; i++) {
-        const summary = summariesPerSession[i];
-        if (summary) {
-          const content = `## ${summary.title}\n${summary.narrative}\nDecisions: ${summary.keyDecisions.join("; ")}\nFiles: ${summary.filesModified.join(", ")}`;
-          blocks.push({
-            type: "summary",
-            content,
-            tokens: estimateTokens(content),
-            recency: new Date(summary.createdAt).getTime(),
-          });
-        } else {
-          sessionsNeedingObs.push(i);
-        }
-      }
-
-      const obsResults = await Promise.all(
-        sessionsNeedingObs.map((i) =>
-          kv
-            .list<CompressedObservation>(KV.observations(sessions[i].id))
-            .catch(() => []),
-        ),
-      );
-
-      for (let j = 0; j < sessionsNeedingObs.length; j++) {
-        const i = sessionsNeedingObs[j];
-        const observations = obsResults[j];
-        const important = observations.filter(
-          (o) => o.title && o.importance >= 5,
-        );
-
-        if (important.length > 0) {
-          const items = important
-            .sort((a, b) => b.importance - a.importance)
-            .slice(0, 5)
-            .map((o) => `- [${o.type}] ${o.title}: ${o.narrative}`)
-            .join("\n");
-          const content = `## Session ${sessions[i].id.slice(0, 8)} (${sessions[i].startedAt})\n${items}`;
-          blocks.push({
-            type: "observation",
-            content,
-            tokens: estimateTokens(content),
-            recency: new Date(sessions[i].startedAt).getTime(),
-          });
-        }
-      }
-
-      blocks.sort((a, b) => b.recency - a.recency);
-
-      let usedTokens = 0;
-      const selected: string[] = [];
-      const header = `<agentmemory-context project="${escapeXmlAttr(data.project)}">`;
-      const footer = `</agentmemory-context>`;
-      usedTokens += estimateTokens(header) + estimateTokens(footer);
-
-      for (const block of blocks) {
-        if (usedTokens + block.tokens > budget) break;
-        selected.push(block.content);
-        usedTokens += block.tokens;
-      }
-
-      if (selected.length === 0) {
-        ctx.logger.info("No context available", { project: data.project });
-        return { context: "", blocks: 0, tokens: 0 };
-      }
-
-      const result = `${header}\n${selected.join("\n\n")}\n${footer}`;
-      ctx.logger.info("Context generated", {
-        blocks: selected.length,
-        tokens: usedTokens,
-      });
-      return { context: result, blocks: selected.length, tokens: usedTokens };
-    },
-  );
-}

package/src/functions/crystallize.ts

@@ -1,293 +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, Crystal, MemoryProvider } from "../types.js";
-
-interface CrystalDigest {
-  narrative: string;
-  keyOutcomes: string[];
-  filesAffected: string[];
-  lessons: string[];
-}
-
-const CRYSTALLIZE_SYSTEM = `You are summarizing a completed chain of agent actions into a compact digest.
-Extract: (1) what was accomplished in 1-2 sentences, (2) key decisions as bullet points,
-(3) files affected, (4) any lessons or patterns worth remembering.
-Return as JSON: { "narrative": "...", "keyOutcomes": ["..."], "filesAffected": ["..."], "lessons": ["..."] }`;
-
-export function registerCrystallizeFunction(
-  sdk: ISdk,
-  kv: StateKV,
-  provider: MemoryProvider,
-): void {
-  sdk.registerFunction(
-    { id: "mem::crystallize" },
-    async (data: {
-      actionIds: string[];
-      sessionId?: string;
-      project?: string;
-    }) => {
-      if (!data.actionIds || data.actionIds.length === 0) {
-        return { success: false, error: "actionIds is required" };
-      }
-
-      const actions: Action[] = [];
-      for (const id of data.actionIds) {
-        const action = await kv.get<Action>(KV.actions, id);
-        if (!action) {
-          return { success: false, error: `action not found: ${id}` };
-        }
-        if (action.status !== "done" && action.status !== "cancelled") {
-          return {
-            success: false,
-            error: `action ${id} has status "${action.status}", expected "done" or "cancelled"`,
-          };
-        }
-        actions.push(action);
-      }
-
-      const allEdges = await kv.list<ActionEdge>(KV.actionEdges);
-      const idSet = new Set(data.actionIds);
-      const relevantEdges = allEdges.filter(
-        (e) => idSet.has(e.sourceActionId) || idSet.has(e.targetActionId),
-      );
-
-      const prompt = buildChainText(actions, relevantEdges);
-
-      try {
-        const response = await provider.summarize(CRYSTALLIZE_SYSTEM, prompt);
-        const digest = parseDigest(response);
-
-        const crystal: Crystal = {
-          id: generateId("crys"),
-          narrative: digest.narrative,
-          keyOutcomes: digest.keyOutcomes,
-          filesAffected: digest.filesAffected,
-          lessons: digest.lessons,
-          sourceActionIds: data.actionIds,
-          sessionId: data.sessionId,
-          project: data.project,
-          createdAt: new Date().toISOString(),
-        };
-
-        await kv.set(KV.crystals, crystal.id, crystal);
-
-        await Promise.all(
-          digest.lessons.map((lesson) =>
-            sdk.trigger("mem::lesson-save", {
-              content: lesson,
-              context: crystal.narrative,
-              confidence: 0.6,
-              project: data.project,
-              tags: [],
-              source: "crystal",
-              sourceIds: [crystal.id],
-            }).catch(() => {}),
-          ),
-        );
-
-        for (const action of actions) {
-          const updated = { ...action, crystallizedInto: crystal.id };
-          await kv.set(KV.actions, action.id, updated);
-        }
-
-        return { success: true, crystal };
-      } catch (err) {
-        return {
-          success: false,
-          error: `crystallization failed: ${String(err)}`,
-        };
-      }
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::crystal-list" },
-    async (data: {
-      project?: string;
-      sessionId?: string;
-      limit?: number;
-    }) => {
-      const limit = data.limit ?? 20;
-      let crystals = await kv.list<Crystal>(KV.crystals);
-
-      if (data.project) {
-        crystals = crystals.filter((c) => c.project === data.project);
-      }
-      if (data.sessionId) {
-        crystals = crystals.filter((c) => c.sessionId === data.sessionId);
-      }
-
-      crystals.sort(
-        (a, b) =>
-          new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
-      );
-
-      return { success: true, crystals: crystals.slice(0, limit) };
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::crystal-get" },
-    async (data: { crystalId: string }) => {
-      if (!data.crystalId) {
-        return { success: false, error: "crystalId is required" };
-      }
-
-      const crystal = await kv.get<Crystal>(KV.crystals, data.crystalId);
-      if (!crystal) {
-        return { success: false, error: "crystal not found" };
-      }
-
-      return { success: true, crystal };
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::auto-crystallize" },
-    async (data: {
-      olderThanDays?: number;
-      project?: string;
-      dryRun?: boolean;
-    }) => {
-      const olderThanDays = data.olderThanDays ?? 7;
-      const dryRun = data.dryRun ?? false;
-      const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
-
-      let allActions = await kv.list<CrystallizableAction>(KV.actions);
-
-      allActions = allActions.filter(
-        (a) =>
-          a.status === "done" &&
-          !a.crystallizedInto &&
-          new Date(a.createdAt).getTime() < cutoff,
-      );
-
-      if (data.project) {
-        allActions = allActions.filter((a) => a.project === data.project);
-      }
-
-      if (allActions.length === 0) {
-        return { success: true, groupCount: 0, crystalIds: [] };
-      }
-
-      const groups = new Map<string, Action[]>();
-      for (const action of allActions) {
-        const key = action.parentId ?? action.project ?? "_ungrouped";
-        const group = groups.get(key);
-        if (group) {
-          group.push(action);
-        } else {
-          groups.set(key, [action]);
-        }
-      }
-
-      if (dryRun) {
-        const groupSummaries = Array.from(groups.entries()).map(
-          ([key, actions]) => ({
-            groupKey: key,
-            actionCount: actions.length,
-            actionIds: actions.map((a) => a.id),
-          }),
-        );
-        return {
-          success: true,
-          dryRun: true,
-          groupCount: groups.size,
-          groups: groupSummaries,
-          crystalIds: [],
-        };
-      }
-
-      const crystalIds: string[] = [];
-      for (const [, groupActions] of groups) {
-        const actionIds = groupActions.map((a) => a.id);
-        const project = groupActions[0].project;
-
-        try {
-          const result = (await sdk.trigger("mem::crystallize", {
-            actionIds,
-            project,
-          })) as { success: boolean; crystal?: Crystal };
-
-          if (result.success && result.crystal) {
-            crystalIds.push(result.crystal.id);
-          }
-        } catch {
-          continue;
-        }
-      }
-
-      return {
-        success: true,
-        groupCount: groups.size,
-        crystalIds,
-      };
-    },
-  );
-}
-
-function buildChainText(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(
-      `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 parseDigest(response: string): CrystalDigest {
-  try {
-    const jsonMatch = response.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) {
-      return {
-        narrative: response,
-        keyOutcomes: [],
-        filesAffected: [],
-        lessons: [],
-      };
-    }
-    const parsed = JSON.parse(jsonMatch[0]) as Record<string, unknown>;
-    return {
-      narrative:
-        typeof parsed.narrative === "string" ? parsed.narrative : response,
-      keyOutcomes: Array.isArray(parsed.keyOutcomes)
-        ? (parsed.keyOutcomes as string[])
-        : [],
-      filesAffected: Array.isArray(parsed.filesAffected)
-        ? (parsed.filesAffected as string[])
-        : [],
-      lessons: Array.isArray(parsed.lessons)
-        ? (parsed.lessons as string[])
-        : [],
-    };
-  } catch {
-    return {
-      narrative: response,
-      keyOutcomes: [],
-      filesAffected: [],
-      lessons: [],
-    };
-  }
-}

package/src/functions/dedup.ts

@@ -1,57 +0,0 @@
-import { createHash } from "node:crypto";
-
-const TTL_MS = 5 * 60 * 1000;
-const CLEANUP_INTERVAL_MS = 60_000;
-
-interface DedupEntry {
-  hash: string;
-  expiresAt: number;
-}
-
-export class DedupMap {
-  private entries = new Map<string, DedupEntry>();
-  private cleanupTimer: ReturnType<typeof setInterval>;
-
-  constructor() {
-    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
-    this.cleanupTimer.unref();
-  }
-
-  computeHash(sessionId: string, toolName: string, toolInput: unknown): string {
-    const input =
-      typeof toolInput === "string"
-        ? toolInput.slice(0, 500)
-        : JSON.stringify(toolInput ?? "").slice(0, 500);
-    const raw = `${sessionId}:${toolName}:${input}`;
-    return createHash("sha256").update(raw).digest("hex");
-  }
-
-  isDuplicate(hash: string): boolean {
-    const entry = this.entries.get(hash);
-    if (!entry) return false;
-    if (Date.now() > entry.expiresAt) {
-      this.entries.delete(hash);
-      return false;
-    }
-    return true;
-  }
-
-  record(hash: string): void {
-    this.entries.set(hash, { hash, expiresAt: Date.now() + TTL_MS });
-  }
-
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.entries) {
-      if (now > entry.expiresAt) this.entries.delete(key);
-    }
-  }
-
-  stop(): void {
-    clearInterval(this.cleanupTimer);
-  }
-
-  get size(): number {
-    return this.entries.size;
-  }
-}