@agentmemory/agentmemory 0.7.2 → 0.7.3

package/src/eval/schemas.ts

@@ -1,124 +0,0 @@
-import { z } from "zod";
-
-const HookTypeEnum = z.enum([
-  "session_start",
-  "prompt_submit",
-  "pre_tool_use",
-  "post_tool_use",
-  "post_tool_failure",
-  "pre_compact",
-  "subagent_start",
-  "subagent_stop",
-  "notification",
-  "task_completed",
-  "stop",
-  "session_end",
-]);
-
-const ObservationTypeEnum = z.enum([
-  "file_read",
-  "file_write",
-  "file_edit",
-  "command_run",
-  "search",
-  "web_fetch",
-  "conversation",
-  "error",
-  "decision",
-  "discovery",
-  "subagent",
-  "notification",
-  "task",
-  "other",
-]);
-
-export const ObserveInputSchema = z.object({
-  hookType: HookTypeEnum,
-  sessionId: z.string().min(1),
-  project: z.string().min(1),
-  cwd: z.string().min(1),
-  timestamp: z.string().min(1),
-  data: z.unknown(),
-});
-
-export const CompressOutputSchema = z.object({
-  type: ObservationTypeEnum,
-  title: z.string().min(1).max(120),
-  subtitle: z.string().optional(),
-  facts: z.array(z.string()).min(1),
-  narrative: z.string().min(10),
-  concepts: z.array(z.string()),
-  files: z.array(z.string()),
-  importance: z.number().int().min(1).max(10),
-});
-
-export const SummaryOutputSchema = z.object({
-  title: z.string().min(1),
-  narrative: z.string().min(20),
-  keyDecisions: z.array(z.string()),
-  filesModified: z.array(z.string()),
-  concepts: z.array(z.string()),
-});
-
-export const SearchInputSchema = z.object({
-  query: z.string().min(1),
-  limit: z.number().int().positive().optional(),
-});
-
-export const ContextInputSchema = z.object({
-  sessionId: z.string().min(1),
-  project: z.string().min(1),
-  budget: z.number().positive().optional(),
-});
-
-export const RememberInputSchema = z.object({
-  content: z.string().min(1),
-  type: z
-    .enum(["pattern", "preference", "architecture", "bug", "workflow", "fact"])
-    .optional(),
-  concepts: z.array(z.string()).optional(),
-  files: z.array(z.string()).optional(),
-});
-
-export const SmartSearchInputSchema = z.object({
-  query: z.string().optional(),
-  expandIds: z.array(z.string()).optional(),
-  limit: z.number().int().positive().optional(),
-});
-
-export const TimelineInputSchema = z.object({
-  anchor: z.string().min(1),
-  project: z.string().optional(),
-  before: z.number().int().nonnegative().optional(),
-  after: z.number().int().nonnegative().optional(),
-});
-
-export const ProfileInputSchema = z.object({
-  project: z.string().min(1),
-  refresh: z.boolean().optional(),
-});
-
-export const RelateInputSchema = z.object({
-  sourceId: z.string().min(1),
-  targetId: z.string().min(1),
-  type: z.enum(["supersedes", "extends", "derives", "contradicts", "related"]),
-});
-
-export const EvolveInputSchema = z.object({
-  memoryId: z.string().min(1),
-  newContent: z.string().min(1),
-  newTitle: z.string().optional(),
-});
-
-export const ExportImportInputSchema = z.object({
-  exportData: z.object({
-    version: z.union([z.literal("0.3.0"), z.literal("0.4.0")]),
-    exportedAt: z.string(),
-    sessions: z.array(z.unknown()),
-    observations: z.record(z.string(), z.array(z.unknown())),
-    memories: z.array(z.unknown()),
-    summaries: z.array(z.unknown()),
-    profiles: z.array(z.unknown()).optional(),
-  }),
-  strategy: z.enum(["merge", "replace", "skip"]).optional(),
-});

package/src/eval/self-correct.ts

@@ -1,28 +0,0 @@
-import type { MemoryProvider } from "../types.js";
-
-const STRICTER_SUFFIX = `
-
-IMPORTANT: Your previous response was invalid. Please ensure your output strictly follows the required XML format. Every required field must be present with valid values.`;
-
-export async function compressWithRetry(
-  provider: MemoryProvider,
-  systemPrompt: string,
-  userPrompt: string,
-  validator: (response: string) => { valid: boolean; errors?: string[] },
-  maxRetries = 1,
-): Promise<{ response: string; retried: boolean }> {
-  const first = await provider.compress(systemPrompt, userPrompt);
-  const result = validator(first);
-  if (result.valid) return { response: first, retried: false };
-
-  for (let i = 0; i < maxRetries; i++) {
-    const retry = await provider.compress(
-      systemPrompt + STRICTER_SUFFIX,
-      userPrompt,
-    );
-    const retryResult = validator(retry);
-    if (retryResult.valid) return { response: retry, retried: true };
-  }
-
-  return { response: first, retried: true };
-}

package/src/eval/validator.ts

@@ -1,31 +0,0 @@
-import type { z } from "zod";
-import type { EvalResult } from "../types.js";
-
-export function validateInput<T>(
-  schema: z.ZodType<T>,
-  data: unknown,
-  functionId: string,
-): { valid: true; data: T } | { valid: false; result: EvalResult } {
-  const parsed = schema.safeParse(data);
-  if (parsed.success) {
-    return { valid: true, data: parsed.data };
-  }
-  return {
-    valid: false,
-    result: {
-      valid: false,
-      errors: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`),
-      qualityScore: 0,
-      latencyMs: 0,
-      functionId,
-    },
-  };
-}
-
-export function validateOutput<T>(
-  schema: z.ZodType<T>,
-  data: unknown,
-  functionId: string,
-): { valid: true; data: T } | { valid: false; result: EvalResult } {
-  return validateInput(schema, data, functionId);
-}

package/src/functions/actions.ts

@@ -1,288 +0,0 @@
-import type { ISdk } from "iii-sdk";
-import type { StateKV } from "../state/kv.js";
-import { KV, generateId } from "../state/schema.js";
-import { withKeyedLock } from "../state/keyed-mutex.js";
-import type { Action, ActionEdge } from "../types.js";
-
-export function registerActionsFunction(sdk: ISdk, kv: StateKV): void {
-  sdk.registerFunction(
-    { id: "mem::action-create" },
-    async (data: {
-      title: string;
-      description?: string;
-      priority?: number;
-      createdBy?: string;
-      project?: string;
-      tags?: string[];
-      parentId?: string;
-      sourceObservationIds?: string[];
-      sourceMemoryIds?: string[];
-      edges?: Array<{ type: string; targetActionId: string }>;
-    }) => {
-      if (!data.title || typeof data.title !== "string") {
-        return { success: false, error: "title is required" };
-      }
-
-      return withKeyedLock("mem:actions", async () => {
-        const now = new Date().toISOString();
-        const action: Action = {
-          id: generateId("act"),
-          title: data.title.trim(),
-          description: (data.description || "").trim(),
-          status: "pending",
-          priority: Math.max(1, Math.min(10, data.priority || 5)),
-          createdAt: now,
-          updatedAt: now,
-          createdBy: data.createdBy || "unknown",
-          project: data.project,
-          tags: data.tags || [],
-          sourceObservationIds: data.sourceObservationIds || [],
-          sourceMemoryIds: data.sourceMemoryIds || [],
-          parentId: data.parentId,
-        };
-
-        if (data.parentId) {
-          const parent = await kv.get<Action>(KV.actions, data.parentId);
-          if (!parent) {
-            return { success: false, error: "parent action not found" };
-          }
-        }
-
-        const validEdgeTypes = [
-          "requires",
-          "unlocks",
-          "spawned_by",
-          "gated_by",
-          "conflicts_with",
-        ];
-        const pendingEdges: ActionEdge[] = [];
-        let hasRequires = false;
-        if (data.edges && Array.isArray(data.edges)) {
-          for (const e of data.edges) {
-            if (!validEdgeTypes.includes(e.type)) {
-              return { success: false, error: `invalid edge type: ${e.type}` };
-            }
-            const targetAction = await kv.get<Action>(KV.actions, e.targetActionId);
-            if (!targetAction) {
-              return { success: false, error: `target action not found: ${e.targetActionId}` };
-            }
-            if (e.type === "requires") hasRequires = true;
-            pendingEdges.push({
-              id: generateId("ae"),
-              type: e.type as ActionEdge["type"],
-              sourceActionId: action.id,
-              targetActionId: e.targetActionId,
-              createdAt: now,
-            });
-          }
-        }
-
-        if (hasRequires) {
-          action.status = "blocked";
-        }
-
-        await kv.set(KV.actions, action.id, action);
-
-        for (const edge of pendingEdges) {
-          await kv.set(KV.actionEdges, edge.id, edge);
-        }
-
-        return { success: true, action, edges: pendingEdges };
-      });
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::action-update" },
-    async (data: {
-      actionId: string;
-      status?: Action["status"];
-      title?: string;
-      description?: string;
-      priority?: number;
-      assignedTo?: string;
-      result?: string;
-      tags?: string[];
-    }) => {
-      if (!data.actionId) {
-        return { success: false, error: "actionId is required" };
-      }
-
-      return withKeyedLock(`mem:action:${data.actionId}`, async () => {
-        const action = await kv.get<Action>(KV.actions, data.actionId);
-        if (!action) {
-          return { success: false, error: "action not found" };
-        }
-
-        if (data.status !== undefined) action.status = data.status;
-        if (data.title !== undefined) action.title = data.title.trim();
-        if (data.description !== undefined)
-          action.description = data.description.trim();
-        if (data.priority !== undefined)
-          action.priority = Math.max(1, Math.min(10, data.priority));
-        if (data.assignedTo !== undefined) action.assignedTo = data.assignedTo;
-        if (data.result !== undefined) action.result = data.result;
-        if (data.tags !== undefined) action.tags = data.tags;
-        action.updatedAt = new Date().toISOString();
-
-        await kv.set(KV.actions, action.id, action);
-
-        if (data.status === "done") {
-          await propagateCompletion(kv, action.id);
-        }
-
-        return { success: true, action };
-      });
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::action-edge-create" },
-    async (data: {
-      sourceActionId: string;
-      targetActionId: string;
-      type: string;
-      metadata?: Record<string, unknown>;
-    }) => {
-      if (!data.sourceActionId || !data.targetActionId || !data.type) {
-        return {
-          success: false,
-          error: "sourceActionId, targetActionId, and type are required",
-        };
-      }
-
-      const validTypes = [
-        "requires",
-        "unlocks",
-        "spawned_by",
-        "gated_by",
-        "conflicts_with",
-      ];
-      if (!validTypes.includes(data.type)) {
-        return {
-          success: false,
-          error: `type must be one of: ${validTypes.join(", ")}`,
-        };
-      }
-
-      const sourceAction = await kv.get<Action>(KV.actions, data.sourceActionId);
-      if (!sourceAction) {
-        return { success: false, error: "source action not found" };
-      }
-      const targetAction = await kv.get<Action>(KV.actions, data.targetActionId);
-      if (!targetAction) {
-        return { success: false, error: "target action not found" };
-      }
-
-      const edge: ActionEdge = {
-        id: generateId("ae"),
-        type: data.type as ActionEdge["type"],
-        sourceActionId: data.sourceActionId,
-        targetActionId: data.targetActionId,
-        createdAt: new Date().toISOString(),
-        metadata: data.metadata,
-      };
-
-      await kv.set(KV.actionEdges, edge.id, edge);
-      return { success: true, edge };
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::action-list" },
-    async (data: {
-      status?: string;
-      project?: string;
-      parentId?: string;
-      tags?: string[];
-      limit?: number;
-    }) => {
-      let actions = await kv.list<Action>(KV.actions);
-
-      if (data.status) {
-        actions = actions.filter((a) => a.status === data.status);
-      }
-      if (data.project) {
-        actions = actions.filter((a) => a.project === data.project);
-      }
-      if (data.parentId) {
-        actions = actions.filter((a) => a.parentId === data.parentId);
-      }
-      if (data.tags && data.tags.length > 0) {
-        actions = actions.filter((a) =>
-          data.tags!.some((t) => a.tags.includes(t)),
-        );
-      }
-
-      actions.sort(
-        (a, b) =>
-          new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
-      );
-
-      const limit = data.limit || 50;
-      return { success: true, actions: actions.slice(0, limit) };
-    },
-  );
-
-  sdk.registerFunction(
-    { id: "mem::action-get" },
-    async (data: { actionId: string }) => {
-      if (!data.actionId) {
-        return { success: false, error: "actionId is required" };
-      }
-      const action = await kv.get<Action>(KV.actions, data.actionId);
-      if (!action) {
-        return { success: false, error: "action not found" };
-      }
-
-      const allEdges = await kv.list<ActionEdge>(KV.actionEdges);
-      const edges = allEdges.filter(
-        (e) =>
-          e.sourceActionId === data.actionId ||
-          e.targetActionId === data.actionId,
-      );
-
-      const children = (await kv.list<Action>(KV.actions)).filter(
-        (a) => a.parentId === data.actionId,
-      );
-
-      return { success: true, action, edges, children };
-    },
-  );
-}
-
-async function propagateCompletion(
-  kv: StateKV,
-  completedActionId: string,
-): Promise<void> {
-  const allEdges = await kv.list<ActionEdge>(KV.actionEdges);
-  const unlockEdges = allEdges.filter(
-    (e) =>
-      e.targetActionId === completedActionId &&
-      (e.type === "requires" || e.type === "unlocks"),
-  );
-
-  const allActions = await kv.list<Action>(KV.actions);
-  const actionMap = new Map(allActions.map((a) => [a.id, a]));
-
-  for (const edge of unlockEdges) {
-    const candidateId = edge.sourceActionId;
-    await withKeyedLock(`mem:action:${candidateId}`, async () => {
-      const action = await kv.get<Action>(KV.actions, candidateId);
-      if (action && action.status === "blocked") {
-        const deps = allEdges.filter(
-          (e) => e.sourceActionId === action.id && e.type === "requires",
-        );
-        const allDone = deps.every((d) => {
-          const target = actionMap.get(d.targetActionId);
-          return target && target.status === "done";
-        });
-        if (allDone) {
-          action.status = "pending";
-          action.updatedAt = new Date().toISOString();
-          await kv.set(KV.actions, action.id, action);
-        }
-      }
-    });
-  }
-}

package/src/functions/audit.ts

@@ -1,61 +0,0 @@
-import type { AuditEntry } from "../types.js";
-import { KV, generateId } from "../state/schema.js";
-import type { StateKV } from "../state/kv.js";
-
-export async function recordAudit(
-  kv: StateKV,
-  operation: AuditEntry["operation"],
-  functionId: string,
-  targetIds: string[],
-  details: Record<string, unknown> = {},
-  qualityScore?: number,
-  userId?: string,
-): Promise<AuditEntry> {
-  const entry: AuditEntry = {
-    id: generateId("aud"),
-    timestamp: new Date().toISOString(),
-    operation,
-    userId,
-    functionId,
-    targetIds,
-    details,
-    qualityScore,
-  };
-  await kv.set(KV.audit, entry.id, entry);
-  return entry;
-}
-
-export async function queryAudit(
-  kv: StateKV,
-  filter?: {
-    operation?: AuditEntry["operation"];
-    dateFrom?: string;
-    dateTo?: string;
-    limit?: number;
-  },
-): Promise<AuditEntry[]> {
-  const all = await kv.list<AuditEntry>(KV.audit);
-  let entries = [...all].sort(
-    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime(),
-  );
-
-  if (filter?.operation) {
-    entries = entries.filter((e) => e.operation === filter.operation);
-  }
-  if (filter?.dateFrom) {
-    const from = new Date(filter.dateFrom).getTime();
-    if (Number.isNaN(from)) {
-      throw new Error(`Invalid dateFrom: ${filter.dateFrom}`);
-    }
-    entries = entries.filter((e) => new Date(e.timestamp).getTime() >= from);
-  }
-  if (filter?.dateTo) {
-    const to = new Date(filter.dateTo).getTime();
-    if (Number.isNaN(to)) {
-      throw new Error(`Invalid dateTo: ${filter.dateTo}`);
-    }
-    entries = entries.filter((e) => new Date(e.timestamp).getTime() <= to);
-  }
-
-  return entries.slice(0, filter?.limit || 100);
-}

package/src/functions/auto-forget.ts

@@ -1,169 +0,0 @@
-import type { ISdk } from "iii-sdk";
-import { getContext } from "iii-sdk";
-import type { Memory, CompressedObservation, Session } from "../types.js";
-import { KV, jaccardSimilarity } from "../state/schema.js";
-import { StateKV } from "../state/kv.js";
-
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-const CONTRADICTION_THRESHOLD = 0.9;
-
-interface AutoForgetResult {
-  ttlExpired: string[];
-  contradictions: Array<{
-    memoryA: string;
-    memoryB: string;
-    similarity: number;
-  }>;
-  lowValueObs: string[];
-  dryRun: boolean;
-}
-
-export function registerAutoForgetFunction(sdk: ISdk, kv: StateKV): void {
-  sdk.registerFunction(
-    {
-      id: "mem::auto-forget",
-      description:
-        "Auto-forget expired (TTL), contradictory, and low-value data",
-    },
-    async (data: { dryRun?: boolean }): Promise<AutoForgetResult> => {
-      const ctx = getContext();
-      const dryRun = data?.dryRun ?? false;
-      const now = Date.now();
-
-      const result: AutoForgetResult = {
-        ttlExpired: [],
-        contradictions: [],
-        lowValueObs: [],
-        dryRun,
-      };
-
-      const memories = await kv.list<Memory>(KV.memories);
-      const deletedIds = new Set<string>();
-      for (const mem of memories) {
-        if (mem.forgetAfter) {
-          const expiry = new Date(mem.forgetAfter).getTime();
-          if (now > expiry) {
-            result.ttlExpired.push(mem.id);
-            deletedIds.add(mem.id);
-            if (!dryRun) {
-              await kv.delete(KV.memories, mem.id);
-            }
-          }
-        }
-      }
-
-      const latestMemories = memories
-        .filter((m) => m.isLatest !== false && !deletedIds.has(m.id))
-        .sort(
-          (a, b) =>
-            new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
-        )
-        .slice(0, 1000);
-
-      const tokenCache = new Map<string, Set<string>>();
-      for (const mem of latestMemories) {
-        tokenCache.set(
-          mem.id,
-          new Set(
-            mem.content
-              .toLowerCase()
-              .split(/\s+/)
-              .filter((t) => t.length > 2),
-          ),
-        );
-      }
-
-      const memById = new Map(latestMemories.map((m) => [m.id, m]));
-      const conceptIndex = new Map<string, string[]>();
-      for (const mem of latestMemories) {
-        const concepts = mem.concepts || [];
-        for (const c of concepts) {
-          const key = c.toLowerCase();
-          if (!conceptIndex.has(key)) conceptIndex.set(key, []);
-          conceptIndex.get(key)!.push(mem.id);
-        }
-      }
-
-      const compared = new Set<string>();
-      for (const [, memIds] of conceptIndex) {
-        for (let i = 0; i < memIds.length; i++) {
-          for (let j = i + 1; j < memIds.length; j++) {
-            const key =
-              memIds[i] < memIds[j]
-                ? `${memIds[i]}|${memIds[j]}`
-                : `${memIds[j]}|${memIds[i]}`;
-            if (compared.has(key)) continue;
-            compared.add(key);
-
-            const setA = tokenCache.get(memIds[i])!;
-            const setB = tokenCache.get(memIds[j])!;
-            let intersection = 0;
-            if (setA.size === 0 && setB.size === 0) continue;
-            if (setA.size === 0 || setB.size === 0) continue;
-            for (const word of setA) {
-              if (setB.has(word)) intersection++;
-            }
-            const sim =
-              intersection / (setA.size + setB.size - intersection);
-
-            if (sim > CONTRADICTION_THRESHOLD) {
-              const memA = memById.get(memIds[i])!;
-              const memB = memById.get(memIds[j])!;
-              result.contradictions.push({
-                memoryA: memA.id,
-                memoryB: memB.id,
-                similarity: sim,
-              });
-
-              if (!dryRun) {
-                const older =
-                  new Date(memA.createdAt).getTime() <
-                  new Date(memB.createdAt).getTime()
-                    ? memA
-                    : memB;
-                older.isLatest = false;
-                await kv.set(KV.memories, older.id, older);
-              }
-            }
-          }
-        }
-      }
-
-      const sessions = await kv.list<Session>(KV.sessions);
-      const obsPerSession: CompressedObservation[][] = [];
-      for (let batch = 0; batch < sessions.length; batch += 10) {
-        const chunk = sessions.slice(batch, batch + 10);
-        const results = await Promise.all(
-          chunk.map((s) =>
-            kv
-              .list<CompressedObservation>(KV.observations(s.id))
-              .catch(() => [] as CompressedObservation[]),
-          ),
-        );
-        obsPerSession.push(...results);
-      }
-      for (let i = 0; i < sessions.length; i++) {
-        for (const obs of obsPerSession[i]) {
-          if (!obs.timestamp) continue;
-          const age = now - new Date(obs.timestamp).getTime();
-          if (age > 180 * MS_PER_DAY && (obs.importance ?? 5) <= 2) {
-            result.lowValueObs.push(obs.id);
-            if (!dryRun) {
-              await kv
-                .delete(KV.observations(sessions[i].id), obs.id)
-                .catch(() => {});
-            }
-          }
-        }
-      }
-
-      ctx.logger.info("Auto-forget complete", {
-        ttlExpired: result.ttlExpired.length,
-        contradictions: result.contradictions.length,
-        lowValueObs: result.lowValueObs.length,
-        dryRun,
-      });
-      return result;
-    },
-  );
-}