@agentmemory/agentmemory 0.7.0

package/src/functions/patterns.ts

@@ -0,0 +1,138 @@
+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 Pattern {
+  type: "co_change" | "error_repeat" | "workflow";
+  description: string;
+  files: string[];
+  frequency: number;
+  sessions: string[];
+}
+
+export function registerPatternsFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    { id: "mem::patterns" },
+    async (data: { project?: string }) => {
+      const ctx = getContext();
+      const patterns: Pattern[] = [];
+
+      const sessions = await kv.list<Session>(KV.sessions);
+      const filtered = data.project
+        ? sessions.filter((s) => s.project === data.project)
+        : sessions;
+
+      const fileCoOccurrences = new Map<string, number>();
+      const fileSessionMap = new Map<string, Set<string>>();
+      const errorPatterns = new Map<
+        string,
+        { count: number; sessions: Set<string> }
+      >();
+
+      for (const session of filtered) {
+        const observations = await kv.list<CompressedObservation>(
+          KV.observations(session.id),
+        );
+        if (!observations.length) continue;
+
+        const sessionFiles = new Set<string>();
+        for (const obs of observations) {
+          if (!obs.files) continue;
+          for (const f of obs.files) {
+            sessionFiles.add(f);
+            if (!fileSessionMap.has(f)) fileSessionMap.set(f, new Set());
+            fileSessionMap.get(f)!.add(session.id);
+          }
+
+          if (obs.type === "error" && obs.title) {
+            const key = obs.title.toLowerCase();
+            if (!errorPatterns.has(key)) {
+              errorPatterns.set(key, { count: 0, sessions: new Set() });
+            }
+            const ep = errorPatterns.get(key)!;
+            ep.count++;
+            ep.sessions.add(session.id);
+          }
+        }
+
+        const fileList = [...sessionFiles].sort();
+        for (let i = 0; i < fileList.length; i++) {
+          for (let j = i + 1; j < fileList.length; j++) {
+            const pair = `${fileList[i]}::${fileList[j]}`;
+            fileCoOccurrences.set(pair, (fileCoOccurrences.get(pair) || 0) + 1);
+          }
+        }
+      }
+
+      for (const [pair, count] of fileCoOccurrences) {
+        if (count < 3) continue;
+        const [fileA, fileB] = pair.split("::");
+        const sessionsA = fileSessionMap.get(fileA) || new Set();
+        const sessionsB = fileSessionMap.get(fileB) || new Set();
+        const commonSessions = [...sessionsA].filter((s) => sessionsB.has(s));
+
+        patterns.push({
+          type: "co_change",
+          description: `${fileA} and ${fileB} are frequently modified together`,
+          files: [fileA, fileB],
+          frequency: count,
+          sessions: commonSessions,
+        });
+      }
+
+      for (const [
+        errorKey,
+        { count, sessions: errorSessions },
+      ] of errorPatterns) {
+        if (count < 2) continue;
+        patterns.push({
+          type: "error_repeat",
+          description: `Recurring error: ${errorKey}`,
+          files: [],
+          frequency: count,
+          sessions: [...errorSessions],
+        });
+      }
+
+      patterns.sort((a, b) => b.frequency - a.frequency);
+
+      ctx.logger.info("Pattern detection complete", {
+        patterns: patterns.length,
+        sessions: filtered.length,
+      });
+
+      return { patterns: patterns.slice(0, 20) };
+    },
+  );
+
+  sdk.registerFunction(
+    { id: "mem::generate-rules" },
+    async (data: { project?: string }) => {
+      const ctx = getContext();
+      const result = await sdk.trigger<
+        { project?: string },
+        { patterns: Pattern[] }
+      >("mem::patterns", data);
+
+      const rules: string[] = [];
+
+      for (const pattern of result.patterns) {
+        if (pattern.type === "co_change" && pattern.frequency >= 4) {
+          rules.push(
+            `When modifying ${pattern.files[0]}, also check ${pattern.files[1]} (co-changed ${pattern.frequency} times).`,
+          );
+        }
+        if (pattern.type === "error_repeat" && pattern.frequency >= 3) {
+          rules.push(
+            `Watch for: ${pattern.description} (occurred ${pattern.frequency} times across ${pattern.sessions.length} sessions).`,
+          );
+        }
+      }
+
+      ctx.logger.info("Rules generated", { count: rules.length });
+      return { rules };
+    },
+  );
+}

package/src/functions/privacy.ts

@@ -0,0 +1,39 @@
+import type { ISdk } from "iii-sdk";
+
+const PRIVATE_TAG_RE = /<private>[\s\S]*?<\/private>/gi;
+
+const SECRET_PATTERN_SOURCES = [
+  /(?:api[_-]?key|secret|token|password|credential|auth)[\s]*[=:]\s*["']?[A-Za-z0-9_\-/.+]{20,}["']?/gi,
+  /(?:sk|pk|rk|ak)-[A-Za-z0-9]{20,}/g,
+  /sk-ant-[A-Za-z0-9\-_]{20,}/g,
+  /ghp_[A-Za-z0-9]{36}/g,
+  /github_pat_[A-Za-z0-9_]{22,}/g,
+  /xoxb-[A-Za-z0-9\-]+/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /AIza[A-Za-z0-9\-_]{35}/g,
+  /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+  /npm_[A-Za-z0-9]{36}/g,
+  /glpat-[A-Za-z0-9\-_]{20,}/g,
+  /dop_v1_[A-Za-z0-9]{64}/g,
+];
+
+export function stripPrivateData(input: string): string {
+  let result = input.replace(PRIVATE_TAG_RE, "[REDACTED]");
+  for (const source of SECRET_PATTERN_SOURCES) {
+    const pattern = new RegExp(source.source, source.flags);
+    result = result.replace(pattern, "[REDACTED_SECRET]");
+  }
+  return result;
+}
+
+export function registerPrivacyFunction(sdk: ISdk): void {
+  sdk.registerFunction(
+    {
+      id: "mem::privacy",
+      description: "Strip private tags and secrets from input",
+    },
+    async (data: { input: string }) => {
+      return { output: stripPrivateData(data.input) };
+    },
+  );
+}

package/src/functions/profile.ts

@@ -0,0 +1,155 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type {
+  CompressedObservation,
+  Session,
+  ProjectProfile,
+} from "../types.js";
+import { KV } from "../state/schema.js";
+import { StateKV } from "../state/kv.js";
+
+export function registerProfileFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    {
+      id: "mem::profile",
+      description: "Generate or retrieve a project profile from aggregated data",
+    },
+    async (data: { project: string; refresh?: boolean }) => {
+      const ctx = getContext();
+
+      if (!data.refresh) {
+        const cached = await kv
+          .get<ProjectProfile>(KV.profiles, data.project)
+          .catch(() => null);
+        if (cached) {
+          const age = Date.now() - new Date(cached.updatedAt).getTime();
+          if (age < 3600_000) {
+            return { profile: cached, cached: true };
+          }
+        }
+      }
+
+      const sessions = await kv.list<Session>(KV.sessions);
+      const projectSessions = sessions.filter(
+        (s) => s.project === data.project,
+      );
+
+      if (projectSessions.length === 0) {
+        return { profile: null, reason: "no_sessions" };
+      }
+
+      const conceptFreq = new Map<string, number>();
+      const fileFreq = new Map<string, number>();
+      const errors: string[] = [];
+      const recentActivity: string[] = [];
+      let totalObs = 0;
+
+      const sortedSessions = projectSessions.sort(
+        (a, b) =>
+          new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime(),
+      );
+
+      const top20Sessions = sortedSessions.slice(0, 20);
+      const obsPerSession = await Promise.all(
+        top20Sessions.map((s) =>
+          kv
+            .list<CompressedObservation>(KV.observations(s.id))
+            .catch(() => [] as CompressedObservation[]),
+        ),
+      );
+
+      for (let i = 0; i < top20Sessions.length; i++) {
+        const session = top20Sessions[i];
+        const observations = obsPerSession[i];
+        totalObs += observations.length;
+
+        for (const obs of observations) {
+          for (const concept of obs.concepts || []) {
+            conceptFreq.set(concept, (conceptFreq.get(concept) || 0) + 1);
+          }
+          for (const file of obs.files || []) {
+            fileFreq.set(file, (fileFreq.get(file) || 0) + 1);
+          }
+          if (obs.type === "error") {
+            errors.push(obs.title);
+          }
+        }
+
+        const important = observations
+          .filter((o) => o.importance >= 7)
+          .sort((a, b) => b.importance - a.importance);
+        if (important.length > 0) {
+          recentActivity.push(
+            `[${session.startedAt.slice(0, 10)}] ${important[0].title}`,
+          );
+        }
+      }
+
+      const topConcepts = Array.from(conceptFreq.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 15)
+        .map(([concept, frequency]) => ({ concept, frequency }));
+
+      const topFiles = Array.from(fileFreq.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 15)
+        .map(([file, frequency]) => ({ file, frequency }));
+
+      const uniqueErrors = [...new Set(errors)].slice(0, 10);
+
+      const profile: ProjectProfile = {
+        project: data.project,
+        updatedAt: new Date().toISOString(),
+        topConcepts,
+        topFiles,
+        conventions: extractConventions(topConcepts, topFiles),
+        commonErrors: uniqueErrors,
+        recentActivity: recentActivity.slice(0, 10),
+        sessionCount: projectSessions.length,
+        totalObservations: totalObs,
+      };
+
+      await kv.set(KV.profiles, data.project, profile);
+
+      ctx.logger.info("Profile generated", {
+        project: data.project,
+        sessions: projectSessions.length,
+        observations: totalObs,
+      });
+      return { profile, cached: false };
+    },
+  );
+}
+
+function extractConventions(
+  concepts: Array<{ concept: string; frequency: number }>,
+  files: Array<{ file: string; frequency: number }>,
+): string[] {
+  const conventions: string[] = [];
+
+  const tsFiles = files.filter((f) => f.file.endsWith(".ts")).length;
+  const jsFiles = files.filter((f) => f.file.endsWith(".js")).length;
+  if (tsFiles > jsFiles && tsFiles > 0) {
+    conventions.push("TypeScript project");
+  }
+
+  const srcFiles = files.filter((f) => f.file.includes("/src/")).length;
+  if (srcFiles > files.length * 0.5) {
+    conventions.push("Standard src/ directory structure");
+  }
+
+  const testFiles = files.filter(
+    (f) => f.file.includes("test") || f.file.includes("spec"),
+  ).length;
+  if (testFiles > 0) {
+    conventions.push("Has test files");
+  }
+
+  for (const { concept, frequency } of concepts.slice(0, 5)) {
+    if (frequency >= 3) {
+      conventions.push(`Frequently uses: ${concept}`);
+    }
+  }
+
+  return conventions;
+}

package/src/functions/query-expansion.ts

@@ -0,0 +1,186 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type { MemoryProvider, QueryExpansion } from "../types.js";
+
+const QUERY_EXPANSION_SYSTEM = `You are a query expansion engine for a memory retrieval system. Given a user query, generate diverse reformulations to maximize recall.
+
+Output EXACTLY this XML:
+<expansion>
+  <reformulations>
+    <query>semantically diverse rephrasing 1</query>
+    <query>semantically diverse rephrasing 2</query>
+    <query>semantically diverse rephrasing 3</query>
+  </reformulations>
+  <temporal>
+    <query>time-concretized version if applicable</query>
+  </temporal>
+  <entities>
+    <entity>extracted entity name 1</entity>
+    <entity>extracted entity name 2</entity>
+  </entities>
+</expansion>
+
+Rules:
+- Generate 3-5 reformulations capturing different interpretations
+- Include paraphrases, domain-specific restatements, and abstract/concrete variants
+- Extract any named entities (people, files, projects, libraries, concepts)
+- If the query mentions time ("last week", "recently"), generate temporal concretizations
+- Each reformulation should capture a distinct facet of intent
+- Keep reformulations concise (under 100 chars each)`;
+
+function parseExpansionXml(xml: string): QueryExpansion | null {
+  const reformulations: string[] = [];
+  const queryRegex =
+    /<reformulations>[\s\S]*?<\/reformulations>/;
+  const reformBlock = xml.match(queryRegex);
+  if (reformBlock) {
+    const qRegex = /<query>([^<]+)<\/query>/g;
+    let match;
+    while ((match = qRegex.exec(reformBlock[0])) !== null) {
+      reformulations.push(match[1].trim());
+    }
+  }
+
+  const temporalConcretizations: string[] = [];
+  const tempBlock = xml.match(/<temporal>[\s\S]*?<\/temporal>/);
+  if (tempBlock) {
+    const qRegex = /<query>([^<]+)<\/query>/g;
+    let match;
+    while ((match = qRegex.exec(tempBlock[0])) !== null) {
+      temporalConcretizations.push(match[1].trim());
+    }
+  }
+
+  const entityExtractions: string[] = [];
+  const entityRegex = /<entity>([^<]+)<\/entity>/g;
+  let match;
+  while ((match = entityRegex.exec(xml)) !== null) {
+    entityExtractions.push(match[1].trim());
+  }
+
+  return {
+    original: "",
+    reformulations,
+    temporalConcretizations,
+    entityExtractions,
+  };
+}
+
+export function registerQueryExpansionFunction(
+  sdk: ISdk,
+  provider: MemoryProvider,
+): void {
+  sdk.registerFunction(
+    {
+      id: "mem::expand-query",
+      description:
+        "Generate diverse query reformulations for improved recall",
+    },
+    async (data: { query: string; maxReformulations?: number }) => {
+      const ctx = getContext();
+      const maxR = data.maxReformulations ?? 5;
+
+      try {
+        const response = await provider.compress(
+          QUERY_EXPANSION_SYSTEM,
+          `Expand this query for memory retrieval:\n\n"${data.query}"`,
+        );
+
+        const parsed = parseExpansionXml(response);
+        if (!parsed) {
+          ctx.logger.warn("Failed to parse query expansion");
+          return {
+            success: true,
+            expansion: {
+              original: data.query,
+              reformulations: [],
+              temporalConcretizations: [],
+              entityExtractions: [],
+            },
+          };
+        }
+
+        parsed.original = data.query;
+        parsed.reformulations = parsed.reformulations.slice(0, maxR);
+
+        ctx.logger.info("Query expanded", {
+          original: data.query,
+          reformulations: parsed.reformulations.length,
+          entities: parsed.entityExtractions.length,
+        });
+
+        return { success: true, expansion: parsed };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.logger.error("Query expansion failed", { error: msg });
+        return {
+          success: true,
+          expansion: {
+            original: data.query,
+            reformulations: [],
+            temporalConcretizations: [],
+            entityExtractions: [],
+          },
+        };
+      }
+    },
+  );
+}
+
+export function extractEntitiesFromQuery(query: string): string[] {
+  const entities: string[] = [];
+  const quoted = query.match(/"([^"]+)"/g);
+  if (quoted) {
+    for (const q of quoted) {
+      entities.push(q.replace(/"/g, ""));
+    }
+  }
+  const capitalized = query.match(/\b[A-Z][a-zA-Z0-9_.-]+\b/g);
+  if (capitalized) {
+    const stopWords = new Set([
+      "The",
+      "This",
+      "That",
+      "What",
+      "When",
+      "Where",
+      "How",
+      "Why",
+      "Who",
+      "Which",
+      "Did",
+      "Does",
+      "Do",
+      "Is",
+      "Are",
+      "Was",
+      "Were",
+      "Has",
+      "Have",
+      "Had",
+      "Can",
+      "Could",
+      "Would",
+      "Should",
+      "Will",
+      "May",
+      "Might",
+      "If",
+      "And",
+      "But",
+      "Or",
+      "Not",
+      "For",
+      "From",
+      "With",
+      "About",
+      "After",
+      "Before",
+      "Between",
+    ]);
+    for (const c of capitalized) {
+      if (!stopWords.has(c)) entities.push(c);
+    }
+  }
+  return [...new Set(entities)];
+}