@agentmemory/agentmemory 0.7.0

package/src/functions/actions.ts

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

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

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

package/src/functions/branch-aware.ts

@@ -0,0 +1,169 @@
+import type { ISdk } from "iii-sdk";
+import type { StateKV } from "../state/kv.js";
+import { KV } from "../state/schema.js";
+import type { Session } from "../types.js";
+import { execFile } from "node:child_process";
+import { resolve } from "node:path";
+
+function execAsync(
+  cmd: string,
+  args: string[],
+  cwd: string,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { cwd, timeout: 5000 }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+export function registerBranchAwareFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    { id: "mem::detect-worktree" },
+    async (data: { cwd: string }) => {
+      if (!data.cwd) {
+        return { success: false, error: "cwd is required" };
+      }
+
+      try {
+        const gitDir = await execAsync(
+          "git",
+          ["rev-parse", "--git-dir"],
+          data.cwd,
+        );
+        const commonDir = await execAsync(
+          "git",
+          ["rev-parse", "--git-common-dir"],
+          data.cwd,
+        );
+        const branch = await execAsync(
+          "git",
+          ["rev-parse", "--abbrev-ref", "HEAD"],
+          data.cwd,
+        ).catch(() => "detached");
+
+        const topLevel = await execAsync(
+          "git",
+          ["rev-parse", "--show-toplevel"],
+          data.cwd,
+        );
+
+        const isWorktree = resolve(data.cwd, gitDir) !== resolve(data.cwd, commonDir);
+        const mainRepoRoot = isWorktree
+          ? resolve(data.cwd, commonDir, "..")
+          : topLevel;
+
+        return {
+          success: true,
+          isWorktree,
+          branch,
+          topLevel,
+          mainRepoRoot,
+          gitDir: resolve(data.cwd, gitDir),
+          commonDir: resolve(data.cwd, commonDir),
+        };
+      } catch {
+        return {
+          success: true,
+          isWorktree: false,
+          branch: null,
+          topLevel: data.cwd,
+          mainRepoRoot: data.cwd,
+          gitDir: null,
+          commonDir: null,
+        };
+      }
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::list-worktrees" },
+    async (data: { cwd: string }) => {
+      if (!data.cwd) {
+        return { success: false, error: "cwd is required" };
+      }
+
+      try {
+        const output = await execAsync(
+          "git",
+          ["worktree", "list", "--porcelain"],
+          data.cwd,
+        );
+
+        const worktrees: Array<{
+          path: string;
+          head: string;
+          branch: string;
+          bare: boolean;
+        }> = [];
+
+        const blocks = output.split("\n\n").filter(Boolean);
+        for (const block of blocks) {
+          const lines = block.split("\n");
+          const wt: { path: string; head: string; branch: string; bare: boolean } = {
+            path: "",
+            head: "",
+            branch: "",
+            bare: false,
+          };
+          for (const line of lines) {
+            if (line.startsWith("worktree ")) wt.path = line.slice(9);
+            else if (line.startsWith("HEAD ")) wt.head = line.slice(5);
+            else if (line.startsWith("branch "))
+              wt.branch = line.slice(7).replace("refs/heads/", "");
+            else if (line === "bare") wt.bare = true;
+          }
+          if (wt.path) worktrees.push(wt);
+        }
+
+        return { success: true, worktrees };
+      } catch {
+        return { success: true, worktrees: [] };
+      }
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::branch-sessions" },
+    async (data: { cwd: string; branch?: string }) => {
+      if (!data.cwd) {
+        return { success: false, error: "cwd is required" };
+      }
+
+      const worktreeInfo = await sdk.trigger<
+        { cwd: string },
+        {
+          success: boolean;
+          isWorktree: boolean;
+          mainRepoRoot: string;
+          branch: string | null;
+        }
+      >("mem::detect-worktree", { cwd: data.cwd });
+
+      const projectRoot = worktreeInfo.mainRepoRoot || data.cwd;
+      const branch = data.branch || worktreeInfo.branch;
+
+      const sessions = await kv.list<Session>(KV.sessions);
+
+      const matching = sessions.filter((s) => {
+        if (s.project === projectRoot || s.cwd === projectRoot) return true;
+        if (s.cwd.startsWith(projectRoot + "/")) return true;
+        return false;
+      });
+
+      matching.sort(
+        (a, b) =>
+          new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime(),
+      );
+
+      return {
+        success: true,
+        sessions: matching,
+        projectRoot,
+        branch,
+        isWorktree: worktreeInfo.isWorktree,
+      };
+    },
+  );
+}