@agentmemory/agentmemory 0.7.2 → 0.7.3

package/src/functions/patterns.ts

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

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

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

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