@launchapp-dev/ao-memory-mcp 1.0.0 → 2.0.1

package/src/tools/store.ts

@@ -1,160 +0,0 @@
-import type Database from "better-sqlite3";
-import { contentHash, now, jsonResult, errorResult } from "../db.ts";
-
-export const storeTools = [
-  {
-    name: "memory.store",
-    description:
-      "Store a new memory entry. Deduplicates via content hash — returns existing entry if duplicate detected.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        entry_type: { type: "string", description: "Type of memory (e.g. decision, observation, task_dispatch, test_result, review, action)" },
-        agent_role: { type: "string", description: "Agent role that produced this memory (e.g. planner, reviewer, qa-tester)" },
-        project: { type: "string", description: "Project/repo name" },
-        title: { type: "string", description: "Short summary line" },
-        body: { type: "string", description: "Full markdown content" },
-        task_id: { type: "string", description: "Task ID reference (e.g. TASK-051)" },
-        pr_number: { type: "number", description: "PR number if applicable" },
-        run_id: { type: "string", description: "Run identifier (e.g. run 51)" },
-        tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
-        metadata: { type: "object", description: "Entry-type-specific metadata" },
-        occurred_at: { type: "string", description: "ISO 8601 date when event occurred (defaults to now)" },
-      },
-      required: ["entry_type", "agent_role", "project", "title", "body"],
-    },
-  },
-  {
-    name: "memory.update",
-    description: "Update an existing memory entry by ID.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        id: { type: "number", description: "Memory entry ID" },
-        title: { type: "string", description: "New title" },
-        body: { type: "string", description: "New body" },
-        status: { type: "string", enum: ["active", "summarized", "archived"], description: "New status" },
-        tags: { type: "array", items: { type: "string" }, description: "New tags" },
-        metadata: { type: "object", description: "Metadata to merge" },
-      },
-      required: ["id"],
-    },
-  },
-  {
-    name: "memory.archive",
-    description: "Bulk archive entries by filter. At least one filter required.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        ids: { type: "array", items: { type: "number" }, description: "Specific entry IDs to archive" },
-        agent_role: { type: "string", description: "Archive all active entries for this role" },
-        project: { type: "string", description: "Archive all active entries for this project" },
-        before: { type: "string", description: "Archive entries with occurred_at before this ISO date" },
-      },
-    },
-  },
-];
-
-export function handleStore(db: Database.Database, name: string, args: any) {
-  if (name === "memory.store") return memoryStore(db, args);
-  if (name === "memory.update") return memoryUpdate(db, args);
-  if (name === "memory.archive") return memoryArchive(db, args);
-  return null;
-}
-
-function memoryStore(db: Database.Database, args: any) {
-  const { entry_type, agent_role, project, title, body } = args;
-  const hash = contentHash(entry_type, agent_role, project, title, body);
-
-  const existing = db.prepare("SELECT id FROM memory_entries WHERE content_hash = ?").get(hash) as any;
-  if (existing) {
-    return jsonResult({ duplicate: true, existing_id: existing.id });
-  }
-
-  const ts = now();
-  const result = db.prepare(`
-    INSERT INTO memory_entries (entry_type, agent_role, project, title, body, task_id, pr_number, run_id, status, tags, metadata, created_at, occurred_at, updated_at, content_hash)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)
-  `).run(
-    entry_type,
-    agent_role,
-    project,
-    title,
-    body,
-    args.task_id || null,
-    args.pr_number || null,
-    args.run_id || null,
-    JSON.stringify(args.tags || []),
-    JSON.stringify(args.metadata || {}),
-    ts,
-    args.occurred_at || ts,
-    ts,
-    hash
-  );
-
-  return jsonResult({ id: result.lastInsertRowid, created: true });
-}
-
-function memoryUpdate(db: Database.Database, args: any) {
-  const { id, ...updates } = args;
-
-  const entry = db.prepare("SELECT * FROM memory_entries WHERE id = ?").get(id) as any;
-  if (!entry) return errorResult(`Entry ${id} not found`);
-
-  const sets: string[] = [];
-  const vals: any[] = [];
-
-  if (updates.title !== undefined) { sets.push("title = ?"); vals.push(updates.title); }
-  if (updates.body !== undefined) { sets.push("body = ?"); vals.push(updates.body); }
-  if (updates.status !== undefined) {
-    sets.push("status = ?"); vals.push(updates.status);
-    if (updates.status === "archived") { sets.push("archived_at = ?"); vals.push(now()); }
-  }
-  if (updates.tags !== undefined) { sets.push("tags = ?"); vals.push(JSON.stringify(updates.tags)); }
-  if (updates.metadata !== undefined) {
-    const merged = { ...JSON.parse(entry.metadata), ...updates.metadata };
-    sets.push("metadata = ?"); vals.push(JSON.stringify(merged));
-  }
-
-  if (sets.length === 0) return errorResult("No fields to update");
-
-  sets.push("updated_at = ?"); vals.push(now());
-
-  if (updates.title !== undefined || updates.body !== undefined) {
-    const newTitle = updates.title || entry.title;
-    const newBody = updates.body || entry.body;
-    const hash = contentHash(entry.entry_type, entry.agent_role, entry.project, newTitle, newBody);
-    sets.push("content_hash = ?"); vals.push(hash);
-  }
-
-  vals.push(id);
-  db.prepare(`UPDATE memory_entries SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
-
-  return jsonResult({ id, updated: true });
-}
-
-function memoryArchive(db: Database.Database, args: any) {
-  const { ids, agent_role, project, before } = args;
-
-  if (!ids && !agent_role && !project && !before) {
-    return errorResult("At least one filter required");
-  }
-
-  const conditions: string[] = ["status = 'active'"];
-  const vals: any[] = [];
-
-  if (ids?.length) {
-    conditions.push(`id IN (${ids.map(() => "?").join(",")})`);
-    vals.push(...ids);
-  }
-  if (agent_role) { conditions.push("agent_role = ?"); vals.push(agent_role); }
-  if (project) { conditions.push("project = ?"); vals.push(project); }
-  if (before) { conditions.push("occurred_at < ?"); vals.push(before); }
-
-  const ts = now();
-  const result = db.prepare(
-    `UPDATE memory_entries SET status = 'archived', archived_at = ?, updated_at = ? WHERE ${conditions.join(" AND ")}`
-  ).run(ts, ts, ...vals);
-
-  return jsonResult({ archived_count: result.changes });
-}

package/src/tools/summarize.ts

@@ -1,140 +0,0 @@
-import type Database from "better-sqlite3";
-import { now, jsonResult, errorResult } from "../db.ts";
-
-export const summarizeTools = [
-  {
-    name: "memory.summarize",
-    description:
-      "Create a summary of memory entries. The calling agent provides the summary text. The server creates the summary record and transitions matching entries to 'summarized' status.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        agent_role: { type: "string", description: "Agent role being summarized" },
-        project: { type: "string", description: "Project being summarized" },
-        entry_type: { type: "string", description: "Entry type filter (omit for mixed)" },
-        summary_title: { type: "string", description: "Title for the summary" },
-        summary_body: { type: "string", description: "The summary text (markdown)" },
-        before: { type: "string", description: "Summarize entries before this ISO date (default: 3 days ago)" },
-        entry_ids: { type: "array", items: { type: "number" }, description: "Specific entry IDs to summarize (overrides date filter)" },
-      },
-      required: ["agent_role", "project", "summary_title", "summary_body"],
-    },
-  },
-  {
-    name: "memory.cleanup",
-    description:
-      "Identify entries needing summarization or archive old summarized entries. Use dry_run to preview without changes.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        older_than_days: { type: "number", description: "Entries older than N days (default 7)" },
-        min_entries: { type: "number", description: "Minimum entries per role+project to trigger (default 10)" },
-        dry_run: { type: "boolean", description: "If true, just report what would happen (default true)" },
-      },
-    },
-  },
-];
-
-export function handleSummarize(db: Database.Database, name: string, args: any) {
-  if (name === "memory.summarize") return memorySummarize(db, args);
-  if (name === "memory.cleanup") return memoryCleanup(db, args);
-  return null;
-}
-
-function memorySummarize(db: Database.Database, args: any) {
-  const { agent_role, project, entry_type, summary_title, summary_body } = args;
-
-  const summarize = db.transaction(() => {
-    let entryIds: number[];
-
-    if (args.entry_ids?.length) {
-      entryIds = args.entry_ids;
-    } else {
-      const cutoff = args.before || new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
-      const conditions = ["agent_role = ?", "project = ?", "status = 'active'", "occurred_at < ?"];
-      const vals = [agent_role, project, cutoff];
-      if (entry_type) { conditions.push("entry_type = ?"); vals.push(entry_type); }
-
-      const rows = db.prepare(
-        `SELECT id FROM memory_entries WHERE ${conditions.join(" AND ")} ORDER BY occurred_at ASC`
-      ).all(...vals) as any[];
-      entryIds = rows.map(r => r.id);
-    }
-
-    if (entryIds.length === 0) {
-      return { error: "No entries to summarize" };
-    }
-
-    const entries = db.prepare(
-      `SELECT MIN(occurred_at) as date_from, MAX(occurred_at) as date_to FROM memory_entries WHERE id IN (${entryIds.map(() => "?").join(",")})`
-    ).get(...entryIds) as any;
-
-    const ts = now();
-    const result = db.prepare(`
-      INSERT INTO memory_summaries (agent_role, project, entry_type, title, body, entry_count, date_from, date_to, entry_ids, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      agent_role, project, entry_type || null,
-      summary_title, summary_body,
-      entryIds.length, entries.date_from, entries.date_to,
-      JSON.stringify(entryIds), ts
-    );
-
-    const placeholders = entryIds.map(() => "?").join(",");
-    db.prepare(
-      `UPDATE memory_entries SET status = 'summarized', updated_at = ? WHERE id IN (${placeholders})`
-    ).run(ts, ...entryIds);
-
-    return {
-      summary_id: result.lastInsertRowid,
-      entries_summarized: entryIds.length,
-      date_from: entries.date_from,
-      date_to: entries.date_to,
-    };
-  });
-
-  const result = summarize();
-  if ((result as any).error) return errorResult((result as any).error);
-  return jsonResult(result);
-}
-
-function memoryCleanup(db: Database.Database, args: any) {
-  const olderThanDays = args.older_than_days ?? 7;
-  const minEntries = args.min_entries ?? 10;
-  const dryRun = args.dry_run ?? true;
-
-  const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000).toISOString();
-
-  // Find scopes that need summarization
-  const needsSummarization = db.prepare(`
-    SELECT agent_role, project, COUNT(*) as entry_count,
-           MIN(occurred_at) as date_from, MAX(occurred_at) as date_to
-    FROM memory_entries
-    WHERE status = 'active' AND occurred_at < ?
-    GROUP BY agent_role, project
-    HAVING COUNT(*) >= ?
-    ORDER BY entry_count DESC
-  `).all(cutoff, minEntries);
-
-  // Find old summarized entries eligible for archival
-  const archivalCutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
-  const needsArchival = (db.prepare(`
-    SELECT COUNT(*) as count FROM memory_entries
-    WHERE status = 'summarized' AND updated_at < ?
-  `).get(archivalCutoff) as any).count;
-
-  if (!dryRun && needsArchival > 0) {
-    const ts = now();
-    db.prepare(`
-      UPDATE memory_entries SET status = 'archived', archived_at = ?, updated_at = ?
-      WHERE status = 'summarized' AND updated_at < ?
-    `).run(ts, ts, archivalCutoff);
-  }
-
-  return jsonResult({
-    needs_summarization: needsSummarization,
-    needs_archival: needsArchival,
-    archived: dryRun ? 0 : needsArchival,
-    dry_run: dryRun,
-  });
-}

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "noEmit": true,
-    "strict": false,
-    "skipLibCheck": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts", "migrate.ts"]
-}