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

package/src/db.ts

@@ -1,48 +0,0 @@
-import Database from "better-sqlite3";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { mkdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-export function resolveDbPath(cliDbPath?: string): string {
-  if (cliDbPath) return cliDbPath;
-  if (process.env.AO_MEMORY_DB) return process.env.AO_MEMORY_DB;
-  const home = process.env.HOME || process.env.USERPROFILE || ".";
-  const aoDir = join(home, ".ao");
-  mkdirSync(aoDir, { recursive: true });
-  return join(aoDir, "memory.db");
-}
-
-export function initDb(dbPath: string): Database.Database {
-  const db = new Database(dbPath);
-  const schema = readFileSync(join(__dirname, "schema.sql"), "utf-8");
-  db.exec(schema);
-  return db;
-}
-
-export function contentHash(
-  entryType: string,
-  agentRole: string,
-  project: string,
-  title: string,
-  body: string
-): string {
-  return createHash("sha256")
-    .update(`${entryType}\0${agentRole}\0${project}\0${title}\0${body}`)
-    .digest("hex");
-}
-
-export function now(): string {
-  return new Date().toISOString();
-}
-
-export function jsonResult(data: unknown) {
-  return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
-}
-
-export function errorResult(message: string) {
-  return { content: [{ type: "text" as const, text: JSON.stringify({ error: message }) }], isError: true };
-}

package/src/server.ts

@@ -1,59 +0,0 @@
-#!/usr/bin/env node --experimental-strip-types
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { resolveDbPath, initDb, errorResult } from "./db.ts";
-import { storeTools, handleStore } from "./tools/store.ts";
-import { recallTools, handleRecall } from "./tools/recall.ts";
-import { statsTools, handleStats } from "./tools/stats.ts";
-import { contextTools, handleContext } from "./tools/context.ts";
-import { summarizeTools, handleSummarize } from "./tools/summarize.ts";
-import { patternTools, handlePatterns } from "./tools/patterns.ts";
-
-// Parse CLI args
-const args = process.argv.slice(2);
-let dbPath: string | undefined;
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--db" && args[i + 1]) {
-    dbPath = args[++i];
-  }
-}
-
-const db = initDb(resolveDbPath(dbPath));
-
-const allTools = [
-  ...storeTools,
-  ...recallTools,
-  ...statsTools,
-  ...contextTools,
-  ...summarizeTools,
-  ...patternTools,
-];
-
-const handlers = [handleStore, handleRecall, handleStats, handleContext, handleSummarize, handlePatterns];
-
-const server = new Server(
-  { name: "ao-memory-mcp", version: "1.0.0" },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: allTools,
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const { name, arguments: input } = req.params;
-
-  for (const handler of handlers) {
-    const result = handler(db, name, input || {});
-    if (result) return result;
-  }
-
-  return errorResult(`Unknown tool: ${name}`);
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);

package/src/tools/context.ts

@@ -1,77 +0,0 @@
-import type Database from "better-sqlite3";
-import { jsonResult } from "../db.ts";
-
-export const contextTools = [
-  {
-    name: "memory.context",
-    description:
-      "Agent boot tool — call at the start of each run to load relevant memory. Returns recent entries, active decisions, cross-project patterns, summaries, and a summarization_needed flag.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        agent_role: { type: "string", description: "Agent role requesting context" },
-        project: { type: "string", description: "Project the agent is working on" },
-        limit: { type: "number", description: "Max entries per section (default 10)" },
-      },
-      required: ["agent_role", "project"],
-    },
-  },
-];
-
-export function handleContext(db: Database.Database, name: string, args: any) {
-  if (name === "memory.context") return memoryContext(db, args);
-  return null;
-}
-
-function memoryContext(db: Database.Database, args: any) {
-  const { agent_role, project } = args;
-  const limit = args.limit || 10;
-
-  const recentEntries = db.prepare(`
-    SELECT * FROM memory_entries
-    WHERE agent_role = ? AND project = ? AND status = 'active'
-    ORDER BY occurred_at DESC LIMIT ?
-  `).all(agent_role, project, limit);
-
-  const activeDecisions = db.prepare(`
-    SELECT * FROM memory_entries
-    WHERE project = ? AND entry_type = 'decision' AND status = 'active'
-    ORDER BY occurred_at DESC LIMIT ?
-  `).all(project, limit);
-
-  const activePatterns = db.prepare(`
-    SELECT * FROM memory_patterns
-    WHERE status = 'active'
-      AND EXISTS (SELECT 1 FROM json_each(projects) WHERE json_each.value = ?)
-    ORDER BY last_seen DESC LIMIT ?
-  `).all(project, limit);
-
-  const recentSummaries = db.prepare(`
-    SELECT * FROM memory_summaries
-    WHERE agent_role = ? AND project = ?
-    ORDER BY created_at DESC LIMIT 5
-  `).all(agent_role, project);
-
-  const crossProjectAlerts = db.prepare(`
-    SELECT * FROM memory_patterns
-    WHERE status = 'active' AND occurrence_count >= 3
-    ORDER BY last_seen DESC LIMIT 5
-  `).all();
-
-  // Check if summarization is needed: 20+ active entries older than 3 days
-  const threeDaysAgo = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
-  const staleCount = (db.prepare(`
-    SELECT COUNT(*) as count FROM memory_entries
-    WHERE agent_role = ? AND project = ? AND status = 'active' AND occurred_at < ?
-  `).get(agent_role, project, threeDaysAgo) as any).count;
-
-  return jsonResult({
-    recent_entries: recentEntries,
-    active_decisions: activeDecisions,
-    active_patterns: activePatterns,
-    recent_summaries: recentSummaries,
-    cross_project_alerts: crossProjectAlerts,
-    summarization_needed: staleCount >= 20,
-    stale_entry_count: staleCount,
-  });
-}

package/src/tools/patterns.ts

@@ -1,165 +0,0 @@
-import type Database from "better-sqlite3";
-import { now, jsonResult, errorResult } from "../db.ts";
-
-export const patternTools = [
-  {
-    name: "memory.patterns.detect",
-    description:
-      "Scan for recurring patterns across projects. Finds entries with similar titles or matching tags that appear in multiple projects.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        min_occurrences: { type: "number", description: "Minimum projects to count as a pattern (default 2)" },
-        entry_type: { type: "string", description: "Restrict to entry type" },
-        limit: { type: "number", description: "Max patterns to return (default 10)" },
-      },
-    },
-  },
-  {
-    name: "memory.patterns.record",
-    description:
-      "Create or update a confirmed cross-project pattern.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        id: { type: "number", description: "Existing pattern ID to update (omit to create new)" },
-        pattern_type: { type: "string", description: "Type (e.g. bug_pattern, process_pattern, architectural_pattern, anti_pattern)" },
-        title: { type: "string", description: "Pattern name" },
-        description: { type: "string", description: "Full description" },
-        projects: { type: "array", items: { type: "string" }, description: "Projects where pattern appears" },
-        agent_roles: { type: "array", items: { type: "string" }, description: "Roles that reported it" },
-        entry_ids: { type: "array", items: { type: "number" }, description: "Memory entry IDs as evidence" },
-        status: { type: "string", enum: ["active", "resolved", "archived"], description: "Pattern status" },
-      },
-      required: ["pattern_type", "title", "description"],
-    },
-  },
-  {
-    name: "memory.patterns.list",
-    description: "List known cross-project patterns.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        status: { type: "string", enum: ["active", "resolved", "archived", "all"], description: "Filter by status (default: active)" },
-        pattern_type: { type: "string", description: "Filter by pattern type" },
-        project: { type: "string", description: "Filter patterns involving this project" },
-        limit: { type: "number", description: "Max results (default 20)" },
-      },
-    },
-  },
-];
-
-export function handlePatterns(db: Database.Database, name: string, args: any) {
-  if (name === "memory.patterns.detect") return patternsDetect(db, args);
-  if (name === "memory.patterns.record") return patternsRecord(db, args);
-  if (name === "memory.patterns.list") return patternsList(db, args);
-  return null;
-}
-
-function patternsDetect(db: Database.Database, args: any) {
-  const minOccurrences = args.min_occurrences ?? 2;
-  const limit = args.limit ?? 10;
-
-  // Find tags that appear across multiple projects
-  const tagCondition = args.entry_type ? "AND e.entry_type = ?" : "";
-  const tagVals = args.entry_type ? [args.entry_type] : [];
-
-  const tagPatterns = db.prepare(`
-    SELECT t.value as tag, COUNT(DISTINCT e.project) as project_count,
-           GROUP_CONCAT(DISTINCT e.project) as projects,
-           COUNT(*) as total_entries
-    FROM memory_entries e, json_each(e.tags) t
-    WHERE e.status = 'active' ${tagCondition}
-    GROUP BY t.value
-    HAVING COUNT(DISTINCT e.project) >= ?
-    ORDER BY project_count DESC
-    LIMIT ?
-  `).all(...tagVals, minOccurrences, limit);
-
-  // Find similar titles across projects using FTS5
-  const titlePatterns = db.prepare(`
-    SELECT e1.title, COUNT(DISTINCT e1.project) as project_count,
-           GROUP_CONCAT(DISTINCT e1.project) as projects,
-           COUNT(*) as total_entries
-    FROM memory_entries e1
-    WHERE e1.status = 'active' ${tagCondition}
-    GROUP BY e1.title
-    HAVING COUNT(DISTINCT e1.project) >= ?
-    ORDER BY project_count DESC
-    LIMIT ?
-  `).all(...tagVals, minOccurrences, limit);
-
-  return jsonResult({
-    tag_patterns: tagPatterns,
-    title_patterns: titlePatterns,
-  });
-}
-
-function patternsRecord(db: Database.Database, args: any) {
-  const ts = now();
-
-  if (args.id) {
-    const existing = db.prepare("SELECT * FROM memory_patterns WHERE id = ?").get(args.id) as any;
-    if (!existing) return errorResult(`Pattern ${args.id} not found`);
-
-    const sets: string[] = [];
-    const vals: any[] = [];
-
-    if (args.pattern_type) { sets.push("pattern_type = ?"); vals.push(args.pattern_type); }
-    if (args.title) { sets.push("title = ?"); vals.push(args.title); }
-    if (args.description) { sets.push("description = ?"); vals.push(args.description); }
-    if (args.projects) { sets.push("projects = ?"); vals.push(JSON.stringify(args.projects)); }
-    if (args.agent_roles) { sets.push("agent_roles = ?"); vals.push(JSON.stringify(args.agent_roles)); }
-    if (args.entry_ids) { sets.push("entry_ids = ?"); vals.push(JSON.stringify(args.entry_ids)); }
-    if (args.status) {
-      sets.push("status = ?"); vals.push(args.status);
-      if (args.status === "resolved") { sets.push("resolved_at = ?"); vals.push(ts); }
-    }
-
-    sets.push("last_seen = ?"); vals.push(ts);
-    sets.push("updated_at = ?"); vals.push(ts);
-    sets.push("occurrence_count = occurrence_count + 1");
-
-    vals.push(args.id);
-    db.prepare(`UPDATE memory_patterns SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
-
-    return jsonResult({ id: args.id, updated: true });
-  }
-
-  const result = db.prepare(`
-    INSERT INTO memory_patterns (pattern_type, title, description, projects, agent_roles, entry_ids, occurrence_count, status, first_seen, last_seen, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, 1, 'active', ?, ?, ?, ?)
-  `).run(
-    args.pattern_type,
-    args.title,
-    args.description,
-    JSON.stringify(args.projects || []),
-    JSON.stringify(args.agent_roles || []),
-    JSON.stringify(args.entry_ids || []),
-    ts, ts, ts, ts
-  );
-
-  return jsonResult({ id: result.lastInsertRowid, created: true });
-}
-
-function patternsList(db: Database.Database, args: any) {
-  const conditions: string[] = [];
-  const vals: any[] = [];
-  const status = args.status || "active";
-
-  if (status !== "all") { conditions.push("status = ?"); vals.push(status); }
-  if (args.pattern_type) { conditions.push("pattern_type = ?"); vals.push(args.pattern_type); }
-  if (args.project) {
-    conditions.push("EXISTS (SELECT 1 FROM json_each(projects) WHERE json_each.value = ?)");
-    vals.push(args.project);
-  }
-
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
-  const limit = args.limit || 20;
-
-  const rows = db.prepare(
-    `SELECT * FROM memory_patterns ${where} ORDER BY last_seen DESC LIMIT ?`
-  ).all(...vals, limit);
-
-  return jsonResult({ patterns: rows, count: rows.length });
-}

package/src/tools/recall.ts

@@ -1,124 +0,0 @@
-import type Database from "better-sqlite3";
-import { jsonResult, errorResult } from "../db.ts";
-
-export const recallTools = [
-  {
-    name: "memory.recall",
-    description:
-      "Query memory entries with structured filters. Returns entries sorted by date. Default: 50 most recent active entries.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        agent_role: { type: "string", description: "Filter by agent role" },
-        project: { type: "string", description: "Filter by project" },
-        entry_type: { type: "string", description: "Filter by entry type" },
-        task_id: { type: "string", description: "Filter by task ID" },
-        status: { type: "string", enum: ["active", "summarized", "archived"], description: "Filter by status (default: active)" },
-        date_from: { type: "string", description: "Entries from this ISO date" },
-        date_to: { type: "string", description: "Entries up to this ISO date" },
-        tags: { type: "array", items: { type: "string" }, description: "Filter by tags (must have ALL specified)" },
-        limit: { type: "number", description: "Max results (default 50)" },
-        offset: { type: "number", description: "Pagination offset (default 0)" },
-        order: { type: "string", enum: ["newest", "oldest"], description: "Sort order (default: newest)" },
-      },
-    },
-  },
-  {
-    name: "memory.search",
-    description:
-      "Full-text search across all memory entries. Uses FTS5 for fast matching.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        query: { type: "string", description: "Search query (supports FTS5 syntax)" },
-        agent_role: { type: "string", description: "Restrict to agent role" },
-        project: { type: "string", description: "Restrict to project" },
-        entry_type: { type: "string", description: "Restrict to entry type" },
-        status: { type: "string", description: "Restrict to status" },
-        limit: { type: "number", description: "Max results (default 20)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "memory.get",
-    description: "Get a single memory entry by ID.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        id: { type: "number", description: "Memory entry ID" },
-      },
-      required: ["id"],
-    },
-  },
-];
-
-export function handleRecall(db: Database.Database, name: string, args: any) {
-  if (name === "memory.recall") return memoryRecall(db, args);
-  if (name === "memory.search") return memorySearch(db, args);
-  if (name === "memory.get") return memoryGet(db, args);
-  return null;
-}
-
-function memoryRecall(db: Database.Database, args: any) {
-  const conditions: string[] = [];
-  const vals: any[] = [];
-  const status = args.status || "active";
-
-  conditions.push("status = ?"); vals.push(status);
-  if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
-  if (args.project) { conditions.push("project = ?"); vals.push(args.project); }
-  if (args.entry_type) { conditions.push("entry_type = ?"); vals.push(args.entry_type); }
-  if (args.task_id) { conditions.push("task_id = ?"); vals.push(args.task_id); }
-  if (args.date_from) { conditions.push("occurred_at >= ?"); vals.push(args.date_from); }
-  if (args.date_to) { conditions.push("occurred_at <= ?"); vals.push(args.date_to); }
-
-  if (args.tags?.length) {
-    for (const tag of args.tags) {
-      conditions.push("EXISTS (SELECT 1 FROM json_each(tags) WHERE json_each.value = ?)");
-      vals.push(tag);
-    }
-  }
-
-  const order = args.order === "oldest" ? "ASC" : "DESC";
-  const limit = args.limit || 50;
-  const offset = args.offset || 0;
-
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
-  const rows = db.prepare(
-    `SELECT * FROM memory_entries ${where} ORDER BY occurred_at ${order} LIMIT ? OFFSET ?`
-  ).all(...vals, limit, offset);
-
-  return jsonResult({ entries: rows, count: rows.length });
-}
-
-function memorySearch(db: Database.Database, args: any) {
-  const conditions: string[] = [];
-  const vals: any[] = [];
-
-  if (args.agent_role) { conditions.push("e.agent_role = ?"); vals.push(args.agent_role); }
-  if (args.project) { conditions.push("e.project = ?"); vals.push(args.project); }
-  if (args.entry_type) { conditions.push("e.entry_type = ?"); vals.push(args.entry_type); }
-  if (args.status) { conditions.push("e.status = ?"); vals.push(args.status); }
-
-  const extraWhere = conditions.length ? `AND ${conditions.join(" AND ")}` : "";
-  const limit = args.limit || 20;
-
-  const rows = db.prepare(`
-    SELECT e.*, snippet(memory_fts, 0, '<mark>', '</mark>', '...', 32) as title_snippet,
-           snippet(memory_fts, 1, '<mark>', '</mark>', '...', 64) as body_snippet
-    FROM memory_fts f
-    JOIN memory_entries e ON e.id = f.rowid
-    WHERE memory_fts MATCH ? ${extraWhere}
-    ORDER BY rank
-    LIMIT ?
-  `).all(args.query, ...vals, limit);
-
-  return jsonResult({ entries: rows, count: rows.length });
-}
-
-function memoryGet(db: Database.Database, args: any) {
-  const entry = db.prepare("SELECT * FROM memory_entries WHERE id = ?").get(args.id);
-  if (!entry) return errorResult(`Entry ${args.id} not found`);
-  return jsonResult(entry);
-}

package/src/tools/stats.ts

@@ -1,74 +0,0 @@
-import type Database from "better-sqlite3";
-import { jsonResult } from "../db.ts";
-
-export const statsTools = [
-  {
-    name: "memory.stats",
-    description:
-      "Get aggregate statistics about memory entries. Optionally filter by project or agent role.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        project: { type: "string", description: "Filter by project" },
-        agent_role: { type: "string", description: "Filter by agent role" },
-      },
-    },
-  },
-];
-
-export function handleStats(db: Database.Database, name: string, args: any) {
-  if (name === "memory.stats") return memoryStats(db, args);
-  return null;
-}
-
-function memoryStats(db: Database.Database, args: any) {
-  const conditions: string[] = [];
-  const vals: any[] = [];
-
-  if (args.project) { conditions.push("project = ?"); vals.push(args.project); }
-  if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
-
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
-
-  const total = (db.prepare(`SELECT COUNT(*) as count FROM memory_entries ${where}`).get(...vals) as any).count;
-
-  const byType = db.prepare(
-    `SELECT entry_type, COUNT(*) as count FROM memory_entries ${where} GROUP BY entry_type ORDER BY count DESC`
-  ).all(...vals);
-
-  const byStatus = db.prepare(
-    `SELECT status, COUNT(*) as count FROM memory_entries ${where} GROUP BY status ORDER BY count DESC`
-  ).all(...vals);
-
-  const byRole = db.prepare(
-    `SELECT agent_role, COUNT(*) as count FROM memory_entries ${where} GROUP BY agent_role ORDER BY count DESC`
-  ).all(...vals);
-
-  const byProject = db.prepare(
-    `SELECT project, COUNT(*) as count FROM memory_entries ${where} GROUP BY project ORDER BY count DESC`
-  ).all(...vals);
-
-  const dateRange = db.prepare(
-    `SELECT MIN(occurred_at) as oldest, MAX(occurred_at) as newest FROM memory_entries ${where}`
-  ).get(...vals) as any;
-
-  const summaryCount = (db.prepare(
-    `SELECT COUNT(*) as count FROM memory_summaries ${where.replace("entry_type", "entry_type")}`
-  ).get(...vals) as any).count;
-
-  const patternCount = (db.prepare(
-    `SELECT COUNT(*) as count FROM memory_patterns WHERE status = 'active'`
-  ).get() as any).count;
-
-  return jsonResult({
-    total_entries: total,
-    total_summaries: summaryCount,
-    active_patterns: patternCount,
-    oldest_entry: dateRange?.oldest,
-    newest_entry: dateRange?.newest,
-    by_type: byType,
-    by_status: byStatus,
-    by_role: byRole,
-    by_project: byProject,
-  });
-}