@agentmemory/agentmemory 0.7.0 → 0.7.3

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;
-    },
-  );
-}

package/src/functions/branch-aware.ts

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