@stackmemoryai/stackmemory 0.5.58 → 0.5.61

package/dist/integrations/mcp/remote-server.js

@@ -1,691 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import express from "express";
-import cors from "cors";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { z } from "zod";
-import Database from "better-sqlite3";
-import { validateInput, StartFrameSchema, AddAnchorSchema } from "./schemas.js";
-import { readFileSync, existsSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-import { execSync } from "child_process";
-import { FrameManager } from "../../core/context/index.js";
-import { logger } from "../../core/monitoring/logger.js";
-import { isFeatureEnabled } from "../../core/config/feature-flags.js";
-const DEFAULT_PORT = 3847;
-class RemoteStackMemoryMCP {
-  server;
-  db;
-  projectRoot;
-  frameManager;
-  taskStore = null;
-  linearAuthManager = null;
-  linearSync = null;
-  projectId;
-  contexts = /* @__PURE__ */ new Map();
-  transports = /* @__PURE__ */ new Map();
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot || this.findProjectRoot();
-    this.projectId = this.getProjectId();
-    const dbDir = join(this.projectRoot, ".stackmemory");
-    if (!existsSync(dbDir)) {
-      mkdirSync(dbDir, { recursive: true });
-    }
-    const dbPath = join(dbDir, "context.db");
-    this.db = new Database(dbPath);
-    this.initDB();
-    this.frameManager = new FrameManager(this.db, this.projectId);
-    this.initLinearIfEnabled();
-    this.server = new Server(
-      {
-        name: "stackmemory-remote",
-        version: "0.1.0"
-      },
-      {
-        capabilities: {
-          tools: {}
-        }
-      }
-    );
-    this.setupHandlers();
-    this.loadInitialContext();
-    logger.info("StackMemory Remote MCP Server initialized", {
-      projectRoot: this.projectRoot,
-      projectId: this.projectId
-    });
-  }
-  findProjectRoot() {
-    let dir = process.cwd();
-    while (dir !== "/") {
-      if (existsSync(join(dir, ".git"))) {
-        return dir;
-      }
-      dir = dirname(dir);
-    }
-    return process.cwd();
-  }
-  async initLinearIfEnabled() {
-    if (!isFeatureEnabled("linear")) {
-      return;
-    }
-    try {
-      const { LinearTaskManager } = await import("../../features/tasks/linear-task-manager.js");
-      const { LinearAuthManager } = await import("../linear/auth.js");
-      const { LinearSyncEngine, DEFAULT_SYNC_CONFIG } = await import("../linear/sync.js");
-      this.taskStore = new LinearTaskManager(this.projectRoot, this.db);
-      this.linearAuthManager = new LinearAuthManager(this.projectRoot);
-      this.linearSync = new LinearSyncEngine(
-        this.taskStore,
-        this.linearAuthManager,
-        DEFAULT_SYNC_CONFIG
-      );
-    } catch (error) {
-      logger.warn("Failed to initialize Linear integration", { error });
-    }
-  }
-  initDB() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS contexts (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        content TEXT NOT NULL,
-        importance REAL DEFAULT 0.5,
-        created_at INTEGER DEFAULT (unixepoch()),
-        last_accessed INTEGER DEFAULT (unixepoch()),
-        access_count INTEGER DEFAULT 1
-      );
-
-      CREATE TABLE IF NOT EXISTS attention_log (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        context_id TEXT,
-        query TEXT,
-        response TEXT,
-        influence_score REAL,
-        timestamp INTEGER DEFAULT (unixepoch())
-      );
-    `);
-  }
-  loadInitialContext() {
-    const projectInfo = this.getProjectInfo();
-    this.addContext(
-      "project",
-      `Project: ${projectInfo.name}
-Path: ${projectInfo.path}`,
-      0.9
-    );
-    try {
-      const recentCommits = execSync("git log --oneline -10", {
-        cwd: this.projectRoot
-      }).toString();
-      this.addContext("git_history", `Recent commits:
-${recentCommits}`, 0.6);
-    } catch {
-    }
-    const readmePath = join(this.projectRoot, "README.md");
-    if (existsSync(readmePath)) {
-      const readme = readFileSync(readmePath, "utf-8");
-      const summary = readme.substring(0, 500);
-      this.addContext("readme", `Project README:
-${summary}...`, 0.8);
-    }
-    this.loadStoredContexts();
-  }
-  getProjectId() {
-    let identifier;
-    try {
-      identifier = execSync("git config --get remote.origin.url", {
-        cwd: this.projectRoot,
-        stdio: "pipe",
-        timeout: 5e3
-      }).toString().trim();
-    } catch {
-      identifier = this.projectRoot;
-    }
-    const cleaned = identifier.replace(/\.git$/, "").replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
-    return cleaned.substring(cleaned.length - 50) || "unknown";
-  }
-  getProjectInfo() {
-    const packageJsonPath = join(this.projectRoot, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-      return {
-        name: pkg.name || "unknown",
-        path: this.projectRoot
-      };
-    }
-    return {
-      name: this.projectRoot.split("/").pop() || "unknown",
-      path: this.projectRoot
-    };
-  }
-  addContext(type, content, importance = 0.5) {
-    const id = `${type}_${Date.now()}`;
-    this.db.prepare(
-      `
-      INSERT OR REPLACE INTO contexts (id, type, content, importance)
-      VALUES (?, ?, ?, ?)
-    `
-    ).run(id, type, content, importance);
-    this.contexts.set(id, { type, content, importance });
-    return id;
-  }
-  loadStoredContexts() {
-    const stored = this.db.prepare(
-      `
-      SELECT * FROM contexts
-      ORDER BY importance DESC, last_accessed DESC
-      LIMIT 50
-    `
-    ).all();
-    stored.forEach((ctx) => {
-      this.contexts.set(ctx.id, ctx);
-    });
-  }
-  setupHandlers() {
-    this.server.setRequestHandler(
-      z.object({
-        method: z.literal("tools/list")
-      }),
-      async () => {
-        return {
-          tools: [
-            {
-              name: "get_context",
-              description: "Get current project context",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  query: {
-                    type: "string",
-                    description: "What you want to know"
-                  },
-                  limit: {
-                    type: "number",
-                    description: "Max contexts to return"
-                  }
-                }
-              }
-            },
-            {
-              name: "add_decision",
-              description: "Record a decision or important information",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  content: {
-                    type: "string",
-                    description: "The decision or information"
-                  },
-                  type: {
-                    type: "string",
-                    enum: ["decision", "constraint", "learning"]
-                  }
-                },
-                required: ["content", "type"]
-              }
-            },
-            {
-              name: "start_frame",
-              description: "Start a new frame (task/subtask) on the call stack",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  name: { type: "string", description: "Frame name/goal" },
-                  type: {
-                    type: "string",
-                    enum: [
-                      "task",
-                      "subtask",
-                      "tool_scope",
-                      "review",
-                      "write",
-                      "debug"
-                    ],
-                    description: "Frame type"
-                  },
-                  constraints: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Constraints for this frame"
-                  }
-                },
-                required: ["name", "type"]
-              }
-            },
-            {
-              name: "close_frame",
-              description: "Close current frame and generate digest",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  result: {
-                    type: "string",
-                    description: "Frame completion result"
-                  },
-                  outputs: {
-                    type: "object",
-                    description: "Final outputs from frame"
-                  }
-                }
-              }
-            },
-            {
-              name: "add_anchor",
-              description: "Add anchored fact/decision/constraint to current frame",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  type: {
-                    type: "string",
-                    enum: [
-                      "FACT",
-                      "DECISION",
-                      "CONSTRAINT",
-                      "INTERFACE_CONTRACT",
-                      "TODO",
-                      "RISK"
-                    ],
-                    description: "Anchor type"
-                  },
-                  text: { type: "string", description: "Anchor content" },
-                  priority: {
-                    type: "number",
-                    description: "Priority (0-10)",
-                    minimum: 0,
-                    maximum: 10
-                  }
-                },
-                required: ["type", "text"]
-              }
-            },
-            {
-              name: "get_hot_stack",
-              description: "Get current active frames and context",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  maxEvents: {
-                    type: "number",
-                    description: "Max recent events per frame",
-                    default: 20
-                  }
-                }
-              }
-            },
-            {
-              name: "sm_search",
-              description: "Search across StackMemory - frames, events, decisions, tasks",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  query: { type: "string", description: "Search query" },
-                  scope: {
-                    type: "string",
-                    enum: ["all", "frames", "events", "decisions", "tasks"],
-                    description: "Scope of search"
-                  },
-                  limit: { type: "number", description: "Maximum results" }
-                },
-                required: ["query"]
-              }
-            }
-          ]
-        };
-      }
-    );
-    this.server.setRequestHandler(
-      z.object({
-        method: z.literal("tools/call"),
-        params: z.object({
-          name: z.string(),
-          arguments: z.record(z.unknown())
-        })
-      }),
-      async (request) => {
-        const { name, arguments: args } = request.params;
-        try {
-          switch (name) {
-            case "get_context":
-              return this.handleGetContext(args);
-            case "add_decision":
-              return this.handleAddDecision(args);
-            case "start_frame":
-              return this.handleStartFrame(args);
-            case "close_frame":
-              return this.handleCloseFrame(args);
-            case "add_anchor":
-              return this.handleAddAnchor(args);
-            case "get_hot_stack":
-              return this.handleGetHotStack(args);
-            case "sm_search":
-              return this.handleSmSearch(args);
-            default:
-              throw new Error(`Unknown tool: ${name}`);
-          }
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Error: ${error.message}` }]
-          };
-        }
-      }
-    );
-  }
-  async handleGetContext(args) {
-    const { query = "", limit = 10 } = args;
-    const contexts = Array.from(this.contexts.values()).sort((a, b) => b.importance - a.importance).slice(0, limit);
-    const response = contexts.map(
-      (ctx) => `[${ctx.type.toUpperCase()}] (importance: ${ctx.importance.toFixed(2)})
-${ctx.content}`
-    ).join("\n\n---\n\n");
-    return {
-      content: [
-        {
-          type: "text",
-          text: response || "No context available yet."
-        }
-      ]
-    };
-  }
-  async handleAddDecision(args) {
-    const { content, type = "decision" } = args;
-    const id = this.addContext(type, content, 0.8);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Added ${type}: ${content}
-ID: ${id}`
-        }
-      ]
-    };
-  }
-  async handleStartFrame(args) {
-    const { name, type, constraints } = validateInput(
-      StartFrameSchema,
-      args,
-      "start_frame"
-    );
-    const inputs = {};
-    if (constraints) {
-      inputs.constraints = constraints;
-    }
-    const frameId = this.frameManager.createFrame({
-      type,
-      name,
-      inputs
-    });
-    this.addContext("active_frame", `Active frame: ${name} (${type})`, 0.9);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Started ${type}: ${name}
-Frame ID: ${frameId}
-Stack depth: ${this.frameManager.getStackDepth()}`
-        }
-      ]
-    };
-  }
-  async handleCloseFrame(args) {
-    const { result, outputs } = args;
-    const currentFrameId = this.frameManager.getCurrentFrameId();
-    if (!currentFrameId) {
-      return {
-        content: [{ type: "text", text: "No active frame to close" }]
-      };
-    }
-    this.frameManager.closeFrame(currentFrameId, outputs);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Closed frame: ${result || "completed"}
-Stack depth: ${this.frameManager.getStackDepth()}`
-        }
-      ]
-    };
-  }
-  async handleAddAnchor(args) {
-    const { type, text, priority } = validateInput(
-      AddAnchorSchema,
-      args,
-      "add_anchor"
-    );
-    const anchorId = this.frameManager.addAnchor(type, text, priority);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Added ${type}: ${text}
-Anchor ID: ${anchorId}`
-        }
-      ]
-    };
-  }
-  async handleGetHotStack(args) {
-    const { maxEvents = 20 } = args;
-    const hotStack = this.frameManager.getHotStackContext(maxEvents);
-    const activePath = this.frameManager.getActiveFramePath();
-    if (hotStack.length === 0) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: "No active frames. Start a frame with start_frame tool."
-          }
-        ]
-      };
-    }
-    let response = "Active Call Stack:\n\n";
-    activePath.forEach((frame, index) => {
-      const indent = "  ".repeat(index);
-      const context = hotStack[index];
-      response += `${indent}${index + 1}. ${frame.name} (${frame.type})
-`;
-      if (context?.anchors?.length > 0) {
-        response += `${indent}   Anchors: ${context.anchors.length}
-`;
-      }
-      if (context?.recentEvents?.length > 0) {
-        response += `${indent}   Events: ${context.recentEvents.length}
-`;
-      }
-      response += "\n";
-    });
-    response += `Total stack depth: ${hotStack.length}`;
-    return {
-      content: [{ type: "text", text: response }]
-    };
-  }
-  async handleSmSearch(args) {
-    const { query, scope = "all", limit = 20 } = args;
-    if (!query) {
-      throw new Error("Query is required");
-    }
-    const results = [];
-    if (scope === "all" || scope === "frames") {
-      const frames = this.db.prepare(
-        `
-        SELECT frame_id, name, type, created_at
-        FROM frames
-        WHERE project_id = ? AND (name LIKE ? OR inputs LIKE ? OR outputs LIKE ?)
-        ORDER BY created_at DESC
-        LIMIT ?
-      `
-      ).all(
-        this.projectId,
-        `%${query}%`,
-        `%${query}%`,
-        `%${query}%`,
-        limit
-      );
-      frames.forEach((f) => {
-        results.push({
-          type: "frame",
-          id: f.frame_id,
-          name: f.name,
-          frameType: f.type
-        });
-      });
-    }
-    if (scope === "all" || scope === "decisions") {
-      const anchors = this.db.prepare(
-        `
-        SELECT a.anchor_id, a.type, a.text, f.name as frame_name
-        FROM anchors a
-        JOIN frames f ON a.frame_id = f.frame_id
-        WHERE f.project_id = ? AND a.text LIKE ?
-        ORDER BY a.created_at DESC
-        LIMIT ?
-      `
-      ).all(this.projectId, `%${query}%`, limit);
-      anchors.forEach((a) => {
-        results.push({
-          type: "decision",
-          id: a.anchor_id,
-          decisionType: a.type,
-          text: a.text,
-          frame: a.frame_name
-        });
-      });
-    }
-    let response = `Search Results for "${query}"
-
-`;
-    response += `Found ${results.length} results
-
-`;
-    results.slice(0, 10).forEach((r) => {
-      if (r.type === "frame") {
-        response += `[Frame] ${r.name} (${r.frameType})
-`;
-      } else if (r.type === "decision") {
-        response += `[${r.decisionType}] ${r.text.slice(0, 60)}...
-`;
-      }
-    });
-    return {
-      content: [{ type: "text", text: response }]
-    };
-  }
-  /**
-   * Start the HTTP/SSE server
-   */
-  async startHttpServer(port = DEFAULT_PORT) {
-    const app = express();
-    app.use(
-      cors({
-        origin: [
-          "https://claude.ai",
-          "https://console.anthropic.com",
-          /^http:\/\/localhost:\d+$/
-        ],
-        credentials: true
-      })
-    );
-    app.use(express.json());
-    app.get("/health", (req, res) => {
-      res.json({
-        status: "ok",
-        server: "stackmemory-remote",
-        projectId: this.projectId,
-        projectRoot: this.projectRoot
-      });
-    });
-    app.get("/sse", async (req, res) => {
-      logger.info("New SSE connection request");
-      const transport = new SSEServerTransport("/message", res);
-      const sessionId = transport.sessionId;
-      this.transports.set(sessionId, transport);
-      transport.onclose = () => {
-        this.transports.delete(sessionId);
-        logger.info("SSE connection closed", { sessionId });
-      };
-      transport.onerror = (error) => {
-        logger.error("SSE transport error", { sessionId, error });
-        this.transports.delete(sessionId);
-      };
-      await this.server.connect(transport);
-      await transport.start();
-      logger.info("SSE connection established", { sessionId });
-    });
-    app.post("/message", async (req, res) => {
-      const sessionId = req.query.sessionId;
-      if (!sessionId) {
-        res.status(400).json({ error: "Missing sessionId" });
-        return;
-      }
-      const transport = this.transports.get(sessionId);
-      if (!transport) {
-        res.status(404).json({ error: "Session not found" });
-        return;
-      }
-      await transport.handlePostMessage(req, res);
-    });
-    app.get("/info", (req, res) => {
-      res.json({
-        name: "stackmemory-remote",
-        version: "0.1.0",
-        protocol: "mcp",
-        transport: "sse",
-        endpoints: {
-          sse: "/sse",
-          message: "/message",
-          health: "/health"
-        },
-        project: {
-          id: this.projectId,
-          root: this.projectRoot,
-          name: this.getProjectInfo().name
-        }
-      });
-    });
-    return new Promise((resolve) => {
-      app.listen(port, () => {
-        console.log(
-          `StackMemory Remote MCP Server running on http://localhost:${port}`
-        );
-        console.log(`
-Endpoints:`);
-        console.log(`  SSE:     http://localhost:${port}/sse`);
-        console.log(`  Message: http://localhost:${port}/message`);
-        console.log(`  Health:  http://localhost:${port}/health`);
-        console.log(`  Info:    http://localhost:${port}/info`);
-        console.log(
-          `
-Project: ${this.getProjectInfo().name} (${this.projectId})`
-        );
-        console.log(
-          `
-For Claude.ai connector, use: http://localhost:${port}/sse`
-        );
-        resolve();
-      });
-    });
-  }
-}
-var remote_server_default = RemoteStackMemoryMCP;
-async function runRemoteMCPServer(port = DEFAULT_PORT, projectRoot) {
-  const server = new RemoteStackMemoryMCP(projectRoot);
-  await server.startHttpServer(port);
-}
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const port = parseInt(
-    process.env.PORT || process.argv[2] || String(DEFAULT_PORT),
-    10
-  );
-  const projectRoot = process.argv[3] || process.cwd();
-  runRemoteMCPServer(port, projectRoot).catch((error) => {
-    console.error("Failed to start remote MCP server:", error);
-    process.exit(1);
-  });
-}
-export {
-  remote_server_default as default,
-  runRemoteMCPServer
-};
-//# sourceMappingURL=remote-server.js.map