ac-framework 1.8.0 → 1.9.0

package/bin/postinstall.js

@@ -29,6 +29,10 @@ console.log('      acfm memory search       Search memories');
 console.log('      acfm memory save         Save memory manually');
 console.log('      acfm memory stats        View memory statistics');
 console.log();
+console.log('    MCP (Model Context Protocol) Servers');
+console.log('      acfm memory install-mcps   Install MCP servers for AI assistants');
+console.log('      acfm memory uninstall-mcps Uninstall MCP servers from AI assistants');
+console.log();
 console.log('    Tip: Add --json to any command for machine-readable output.');
 console.log();
 
@@ -44,3 +48,12 @@ if (isWin) {
   console.log('    4. Restart your terminal');
   console.log();
 }
+
+// Auto-detect and install MCPs for supported assistants
+try {
+  const { detectAndInstallMCPs } = require('../src/services/mcp-installer');
+  detectAndInstallMCPs();
+} catch (error) {
+  // Silently fail if MCP installer is not available yet
+  // This allows the framework to work without MCP dependencies during early development
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ac-framework",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Agentic Coding Framework - Multi-assistant configuration system with OpenSpec workflows",
   "main": "src/index.js",
   "exports": {
@@ -42,6 +42,7 @@
   },
   "homepage": "https://github.com/b4san/AC-framework#readme",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "better-sqlite3": "^11.8.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
@@ -49,7 +50,8 @@
     "inquirer": "^12.3.2",
     "js-yaml": "^4.1.1",
     "nanospinner": "^1.2.2",
-    "tar": "^7.5.7"
+    "tar": "^7.5.7",
+    "zod": "^4.3.6"
   },
   "type": "module",
   "engines": {

package/src/commands/init.js

@@ -14,6 +14,9 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import inquirer from 'inquirer';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { DESCRIPTIONS, ASSISTANT_ICONS, BUNDLED } from '../config/constants.js';
 import { IDE_MD_MAP, AVAILABLE_MD_FILES, MD_DESCRIPTIONS } from '../config/ide-mapping.js';
 import { formatFolderName, sleep } from '../utils/helpers.js';
@@ -40,6 +43,100 @@ import {
 
 const acGradient = gradient(['#6C5CE7', '#00CEC9', '#0984E3']);
 
+// ── Persistent Memory Setup ───────────────────────────────────────
+
+/**
+ * First-time persistent memory setup.
+ * Only shown when ~/.acfm/memory.db does not yet exist.
+ *
+ * The memory store is named "NexusVault" — a unique, memorable name
+ * for the embedded knowledge base that persists context across sessions.
+ */
+async function setupPersistentMemory() {
+  const memoryDbPath = join(homedir(), '.acfm', 'memory.db');
+
+  // Only ask on first run
+  if (existsSync(memoryDbPath)) return;
+
+  console.log();
+  await animatedSeparator(60);
+  console.log();
+
+  const vaultBadge = chalk.hex('#2D3436').bgHex('#6C5CE7').bold(' NexusVault ');
+  console.log(`  ${vaultBadge} ${chalk.hex('#B2BEC3').bold('Persistent Memory System')}`);
+  console.log();
+  console.log(
+    chalk.hex('#636E72')(
+      '  NexusVault is an embedded SQLite knowledge base that lives at\n' +
+      `  ${chalk.hex('#DFE6E9')('~/.acfm/memory.db')} on your machine.\n\n` +
+      '  When enabled, your AI assistants will automatically:\n' +
+      `    ${chalk.hex('#00CEC9')('◆')} Remember architectural decisions, bugfixes & patterns\n` +
+      `    ${chalk.hex('#00CEC9')('◆')} Recall relevant context when you start a new task\n` +
+      `    ${chalk.hex('#00CEC9')('◆')} Connect to assistants via MCP (Model Context Protocol)\n\n` +
+      '  Your data never leaves your machine — fully offline & private.'
+    )
+  );
+  console.log();
+
+  const { enableMemory } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'enableMemory',
+    message: chalk.hex('#B2BEC3')('Enable NexusVault persistent memory?'),
+    default: true,
+  }]);
+
+  if (!enableMemory) {
+    console.log();
+    console.log(chalk.hex('#636E72')('  Skipped. You can enable it later with: acfm memory init'));
+    console.log();
+    return;
+  }
+
+  console.log();
+  console.log(chalk.hex('#B2BEC3')('  Initializing NexusVault...'));
+
+  // Init the SQLite database
+  const { initDatabase, isDatabaseInitialized } = await import('../memory/database.js');
+  if (!isDatabaseInitialized()) {
+    initDatabase();
+  }
+  console.log(
+    chalk.hex('#00CEC9')('  ◆ ') +
+    chalk.hex('#DFE6E9')('NexusVault database created at ~/.acfm/memory.db')
+  );
+
+  // Install MCP server into detected assistants
+  console.log();
+  console.log(chalk.hex('#B2BEC3')('  Connecting NexusVault to your AI assistants via MCP...'));
+  console.log();
+
+  const { detectAndInstallMCPs, ASSISTANTS, isAssistantInstalled } = await import('../services/mcp-installer.js');
+  const { installed, success } = detectAndInstallMCPs();
+
+  if (installed === 0) {
+    console.log(chalk.hex('#636E72')('  No AI assistants detected yet.'));
+    console.log(chalk.hex('#636E72')('  Run ' + chalk.hex('#DFE6E9')('acfm memory install-mcps') + ' after installing an assistant.'));
+  } else {
+    for (const assistant of ASSISTANTS) {
+      if (isAssistantInstalled(assistant)) {
+        console.log(
+          chalk.hex('#00CEC9')('  ◆ ') +
+          chalk.hex('#DFE6E9').bold(assistant.name) +
+          chalk.hex('#636E72')(` · MCP config → ${assistant.configPath}`)
+        );
+      }
+    }
+    console.log();
+    const successBadge = chalk.hex('#2D3436').bgHex('#00CEC9').bold(` ${success}/${installed} `);
+    console.log(`  ${successBadge} ${chalk.hex('#B2BEC3')('assistants connected to NexusVault')}`);
+  }
+
+  console.log();
+  console.log(chalk.hex('#6C5CE7').bold('  NexusVault is active.'));
+  console.log(chalk.hex('#636E72')('  Use acfm memory --help to manage your knowledge base.'));
+  console.log();
+}
+
 // ── Helpers ──────────────────────────────────────────────────────
 
 function buildChoices(folders) {
@@ -423,6 +520,7 @@ export async function initCommand(options = {}) {
     // ── Final result ──────────────────────────────────────────────
     if (errors.length === 0) {
       await celebrateSuccess(installed, targetDir);
+      await setupPersistentMemory();
     } else {
       await showFailureSummary(installed, errors);
     }

package/src/commands/memory.js

@@ -706,61 +706,122 @@ export function memoryCommand() {
 
   // ─── acfm memory session ───────────────────────────────────────────────────
   const sessionCmd = new Command('session')
-    .description('Gestión de sesiones de memoria');
+  .description('Gestión de sesiones de memoria');
   
   sessionCmd
-    .command('start')
-    .description('Inicia nueva sesión')
-    .option('-p, --project <path>', 'Proyecto', process.cwd())
-    .option('-c, --change <name>', 'Change')
-    .option('--json', 'Output as JSON')
-    .action((opts) => {
-      try {
-        ensureInitialized();
-        
-        const sessionId = startSession(opts.project, opts.change);
-        
-        output({ sessionId, project: opts.project, change: opts.change }, opts.json);
-        
-        if (!opts.json) {
-          console.log(chalk.green('✓ Session started'));
-          console.log(chalk.dim(`  ID: ${sessionId}`));
-        }
-      } catch (err) {
-        output({ error: err.message }, opts.json);
-        if (!opts.json) console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
+  .command('start')
+  .description('Inicia nueva sesión')
+  .option('-p, --project <path>', 'Proyecto', process.cwd())
+  .option('-c, --change <name>', 'Change')
+  .option('--json', 'Output as JSON')
+  .action((opts) => {
+    try {
+      ensureInitialized();
+      
+      const sessionId = startSession(opts.project, opts.change);
+      
+      output({ sessionId, project: opts.project, change: opts.change }, opts.json);
+      
+      if (!opts.json) {
+        console.log(chalk.green('✓ Session started'));
+        console.log(chalk.dim(`  ID: ${sessionId}`));
       }
-    });
+    } catch (err) {
+      output({ error: err.message }, opts.json);
+      if (!opts.json) console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
   
   sessionCmd
-    .command('end <sessionId>')
-    .description('Finaliza sesión')
-    .option('-s, --summary <text>', 'Resumen de la sesión')
-    .option('--json', 'Output as JSON')
-    .action((sessionId, opts) => {
-      try {
-        ensureInitialized();
-        
-        endSession(sessionId, opts.summary);
-        
-        output({ ended: true, sessionId }, opts.json);
-        
-        if (!opts.json) {
-          console.log(chalk.green('✓ Session ended'));
-          if (opts.summary) {
-            console.log(chalk.dim('Summary saved as memory'));
-          }
+  .command('end <sessionId>')
+  .description('Finaliza sesión')
+  .option('-s, --summary <text>', 'Resumen de la sesión')
+  .option('--json', 'Output as JSON')
+  .action((sessionId, opts) => {
+    try {
+      ensureInitialized();
+      
+      endSession(sessionId, opts.summary);
+      
+      output({ ended: true, sessionId }, opts.json);
+      
+      if (!opts.json) {
+        console.log(chalk.green('✓ Session ended'));
+        if (opts.summary) {
+          console.log(chalk.dim('Summary saved as memory'));
         }
-      } catch (err) {
-        output({ error: err.message }, opts.json);
-        if (!opts.json) console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
       }
-    });
+    } catch (err) {
+      output({ error: err.message }, opts.json);
+      if (!opts.json) console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
   
   memory.addCommand(sessionCmd);
-
+  
+  // ─── acfm memory install-mcps ───────────────────────────────────────────────
+  memory
+  .command('install-mcps')
+  .description('Instala servidores MCP para asistentes de IA detectados')
+  .option('--all', 'Instalar para todos (sin requerir detección)', false)
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    try {
+      const { detectAndInstallMCPs, installAllMCPs, ASSISTANTS, isAssistantInstalled } = await import('../services/mcp-installer.js');
+      
+      const result = opts.all ? installAllMCPs() : detectAndInstallMCPs();
+      
+      output({ total: result.total ?? result.installed, success: result.success }, opts.json);
+      
+      if (!opts.json) {
+        if (!opts.all) {
+          if (result.installed === 0) {
+            console.log(chalk.yellow('No AI assistants detected.'));
+            console.log(chalk.dim('Use --all to install for all supported assistants.'));
+            return;
+          }
+          for (const assistant of ASSISTANTS) {
+            if (isAssistantInstalled(assistant)) {
+              console.log(
+                chalk.cyan('◆ ') + chalk.bold(assistant.name) +
+                chalk.dim(` → ${assistant.configPath}`)
+              );
+            }
+          }
+        }
+        console.log(chalk.green(`\n✓ MCP servers installed (${result.success}/${result.total ?? result.installed})`));
+      }
+    } catch (err) {
+      output({ error: err.message }, opts.json);
+      if (!opts.json) console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  
+  // ─── acfm memory uninstall-mcps ───────────────────────────────────────────
+  memory
+  .command('uninstall-mcps')
+  .description('Desinstala servidores MCP de asistentes de IA')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    try {
+      const { uninstallAllMCPs } = await import('../services/mcp-installer.js');
+      const result = uninstallAllMCPs();
+      
+      output({ success: result.success }, opts.json);
+      
+      if (!opts.json) {
+        console.log(chalk.green(`✓ MCP servers uninstalled (${result.success})`));
+      }
+    } catch (err) {
+      output({ error: err.message }, opts.json);
+      if (!opts.json) console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  
   return memory;
 }
 

package/src/mcp/server.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server for AC Framework Memory System
+ * Exposes memory system functionality via Model Context Protocol
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import {
+  initDatabase,
+  isDatabaseInitialized,
+  saveMemory,
+  searchMemories,
+  getContext,
+  getTimeline,
+  getMemory,
+  updateMemory,
+  deleteMemory,
+  startSession,
+  endSession,
+  getStats,
+  findPatterns,
+  getConnections,
+  anticipateNeeds,
+  exportMemories,
+  importMemories,
+  pruneMemories,
+  MEMORY_TYPES,
+  IMPORTANCE_LEVELS
+} from "../memory/index.js";
+
+function getMemoryTypeDescription(type) {
+  const descriptions = {
+    architectural_decision: "Major design decisions about system architecture",
+    bugfix_pattern: "Solutions to bugs and issues encountered",
+    api_pattern: "Patterns and best practices for API design",
+    performance_insight: "Learnings from performance optimization work",
+    security_fix: "Security vulnerability fixes and patches",
+    refactor_technique: "Successful code refactoring patterns",
+    dependency_note: "Notes about project dependencies and versions",
+    workaround: "Temporary solutions to problems",
+    convention: "Established project conventions and standards",
+    context_boundary: "Defined system boundaries and limitations",
+    general_insight: "General insights and learnings",
+    session_summary: "Summary of work completed in a session"
+  };
+  return descriptions[type] || "Memory type description not available";
+}
+
+class MCPMemoryServer {
+  constructor() {
+    // Initialize database if not already done
+    if (!isDatabaseInitialized()) {
+      initDatabase();
+      console.error("Memory system initialized for MCP server");
+    }
+
+    this.server = new McpServer({
+      name: "ac-framework-memory",
+      version: "1.0.0",
+    });
+
+    this.setupTools();
+  }
+
+  setupTools() {
+    // ── memory_save ──────────────────────────────────────────────
+    this.server.tool(
+      "memory_save",
+      "Save a memory observation to the persistent knowledge base",
+      {
+        content: z.string().describe("Content to save in memory"),
+        type: z.enum(MEMORY_TYPES).default("general_insight").describe("Type of memory"),
+        importance: z.enum(IMPORTANCE_LEVELS).default("medium").describe("Importance level"),
+        tags: z.array(z.string()).optional().describe("Tags for categorization"),
+        projectPath: z.string().optional().describe("Associated project path"),
+        changeName: z.string().optional().describe("Associated change name"),
+        confidence: z.number().min(0).max(1).default(0.8).describe("Confidence score (0-1)")
+      },
+      async ({ content, type, importance, tags, projectPath, changeName, confidence }) => {
+        try {
+          const result = saveMemory({ content, type, importance, tags, projectPath, changeName, confidence });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ success: true, id: result.id, operation: result.operation, revisionCount: result.revisionCount }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_search ─────────────────────────────────────────────
+    this.server.tool(
+      "memory_search",
+      "Search memories using full-text search (FTS5)",
+      {
+        query: z.string().describe("Search query"),
+        limit: z.number().int().positive().default(10).describe("Maximum results"),
+        type: z.enum(MEMORY_TYPES).optional().describe("Filter by memory type"),
+        importance: z.enum(IMPORTANCE_LEVELS).optional().describe("Filter by importance"),
+        projectPath: z.string().optional().describe("Filter by project path"),
+        minConfidence: z.number().min(0).max(1).default(0).describe("Minimum confidence score")
+      },
+      async ({ query, limit, type, importance, projectPath, minConfidence }) => {
+        try {
+          const results = searchMemories(query, { limit, type, importance, projectPath, minConfidence });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ query, count: results.length, results }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_recall ─────────────────────────────────────────────
+    this.server.tool(
+      "memory_recall",
+      "Recall relevant context for a task or project",
+      {
+        task: z.string().optional().describe("Specific task to recall context for"),
+        projectPath: z.string().optional().describe("Project path"),
+        changeName: z.string().optional().describe("Change name"),
+        limit: z.number().int().positive().default(5).describe("Number of memories to return"),
+        days: z.number().int().positive().default(30).describe("Days to look back")
+      },
+      async ({ task, projectPath, changeName, limit, days }) => {
+        try {
+          const results = getContext({ projectPath, changeName, currentTask: task, limit, lookbackDays: days });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ task: task || null, projectPath, count: results.length, memories: results }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_get ────────────────────────────────────────────────
+    this.server.tool(
+      "memory_get",
+      "Get a specific memory by ID",
+      {
+        id: z.number().int().positive().describe("Memory ID")
+      },
+      async ({ id }) => {
+        try {
+          const memory = getMemory(id);
+          if (!memory) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Memory not found" }) }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify({ memory }, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_timeline ───────────────────────────────────────────
+    this.server.tool(
+      "memory_timeline",
+      "Get chronological timeline around a specific memory",
+      {
+        id: z.number().int().positive().describe("Memory ID"),
+        window: z.number().int().positive().default(3).describe("Number of memories before/after")
+      },
+      async ({ id, window }) => {
+        try {
+          const timeline = getTimeline(id, { window });
+          if (!timeline) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Memory not found" }) }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(timeline, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_stats ──────────────────────────────────────────────
+    this.server.tool(
+      "memory_stats",
+      "Get memory system statistics",
+      {
+        projectPath: z.string().optional().describe("Filter by project path"),
+        since: z.string().optional().describe("ISO date string to filter from")
+      },
+      async ({ projectPath, since }) => {
+        try {
+          const stats = getStats({ projectPath, since });
+          return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_patterns ───────────────────────────────────────────
+    this.server.tool(
+      "memory_patterns",
+      "Find patterns and clusters in the memory system",
+      {
+        type: z.enum(MEMORY_TYPES).optional().describe("Filter by memory type"),
+        minFrequency: z.number().int().positive().default(2).describe("Minimum frequency for pattern detection")
+      },
+      async ({ type, minFrequency }) => {
+        try {
+          const patterns = findPatterns({ type, minFrequency });
+          return { content: [{ type: "text", text: JSON.stringify({ patterns }, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_anticipate ─────────────────────────────────────────
+    this.server.tool(
+      "memory_anticipate",
+      "Anticipate memories that will be needed for a future task",
+      {
+        task: z.string().describe("Task to anticipate needs for"),
+        projectPath: z.string().optional().describe("Project path"),
+        limit: z.number().int().positive().default(5).describe("Number of suggestions")
+      },
+      async ({ task, projectPath, limit }) => {
+        try {
+          const memories = anticipateNeeds(task, projectPath);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ task, suggestions: memories.slice(0, limit) }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_export ─────────────────────────────────────────────
+    this.server.tool(
+      "memory_export",
+      "Export memories to JSON (to file or as response)",
+      {
+        filePath: z.string().optional().describe("File path to export to (optional, returns inline if omitted)"),
+        shareableOnly: z.boolean().default(true).describe("Only export shareable memories"),
+        projectPath: z.string().optional().describe("Filter by project path"),
+        since: z.string().optional().describe("ISO date string to filter from")
+      },
+      async ({ filePath, shareableOnly, projectPath, since }) => {
+        try {
+          const memories = exportMemories({ shareableOnly, projectPath, since });
+          const exportData = { exportedAt: new Date().toISOString(), count: memories.length, memories };
+          if (filePath) {
+            const { writeFileSync } = await import("node:fs");
+            writeFileSync(filePath, JSON.stringify(exportData, null, 2));
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({ success: true, message: `Exported ${memories.length} memories to ${filePath}` }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(exportData, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_import ─────────────────────────────────────────────
+    this.server.tool(
+      "memory_import",
+      "Import memories from a JSON file",
+      {
+        filePath: z.string().describe("File path to import from"),
+        merge: z.boolean().default(true).describe("Merge with existing memories")
+      },
+      async ({ filePath, merge }) => {
+        try {
+          const { readFileSync } = await import("node:fs");
+          const data = JSON.parse(readFileSync(filePath, "utf-8"));
+          const memories = data.memories || data;
+          const results = importMemories(memories, { merge });
+          const success = results.filter(r => r.success);
+          const failed = results.filter(r => !r.success);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ imported: success.length, failed: failed.length, results }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    // ── memory_prune ──────────────────────────────────────────────
+    this.server.tool(
+      "memory_prune",
+      "Prune obsolete or low-confidence memories",
+      {
+        olderThanDays: z.number().int().positive().default(90).describe("Delete memories older than this many days"),
+        dryRun: z.boolean().default(false).describe("Show what would be pruned without actually deleting")
+      },
+      async ({ olderThanDays, dryRun }) => {
+        try {
+          const result = pruneMemories({ olderThanDays, dryRun });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("AC Framework Memory MCP Server running on stdio");
+  }
+}
+
+// Start server if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = new MCPMemoryServer();
+  server.run().catch(error => {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  });
+}
+
+export default MCPMemoryServer;