@mycontxt/mcp 0.1.1

package/dist/server.js

@@ -0,0 +1,988 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/index.ts
+import { SQLiteDatabase as SQLiteDatabase3 } from "@mycontxt/adapters/sqlite";
+import { MemoryEngine } from "@mycontxt/core";
+
+// src/utils/project.ts
+import { join } from "path";
+function getContxtDir(cwd) {
+  return join(cwd, ".contxt");
+}
+function getDbPath(cwd) {
+  return join(getContxtDir(cwd), "local.db");
+}
+
+// src/tools/suggest-context.ts
+import { SQLiteDatabase } from "@mycontxt/adapters/sqlite";
+import { rankEntries, fitToBudget, buildContext } from "@mycontxt/core";
+async function suggestContext(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found. Run `memocore init` to initialize.";
+    }
+    const activeBranch = await db.getActiveBranch(project.id);
+    const entries = await db.listEntries({
+      projectId: project.id,
+      branch: activeBranch,
+      isArchived: false
+    });
+    if (entries.length === 0) {
+      return "No memory entries found. Add some decisions, patterns, or context to get started.";
+    }
+    const options = {
+      projectId: project.id,
+      taskDescription: args.taskDescription,
+      activeFiles: args.activeFiles,
+      maxTokens: args.maxTokens || 4e3,
+      minRelevance: args.minRelevance || 0.3
+    };
+    const ranked = rankEntries(entries, options);
+    if (ranked.length === 0) {
+      return "No relevant entries found for the given task.";
+    }
+    const fitted = fitToBudget(ranked, options.maxTokens);
+    const context = buildContext(fitted, {
+      includeReasons: true,
+      includeStats: true
+    });
+    return context;
+  } finally {
+    await db.close();
+  }
+}
+
+// src/tools/auto-capture.ts
+import { SQLiteDatabase as SQLiteDatabase2 } from "@mycontxt/adapters/sqlite";
+
+// src/utils/usage-gate.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { UsageGate } from "@mycontxt/core/engine/usage";
+import { resolveUserPlan } from "@mycontxt/core/engine/plan-resolver";
+import { SupabaseDatabase } from "@mycontxt/adapters/supabase";
+var AUTH_FILE = join2(homedir(), ".contxt", "auth.json");
+function getCurrentUserId() {
+  if (!existsSync(AUTH_FILE)) return null;
+  try {
+    const content = readFileSync(AUTH_FILE, "utf-8");
+    const auth = JSON.parse(content);
+    return auth.userId;
+  } catch {
+    return null;
+  }
+}
+function getRemoteDb() {
+  if (!existsSync(AUTH_FILE)) return null;
+  try {
+    const content = readFileSync(AUTH_FILE, "utf-8");
+    const auth = JSON.parse(content);
+    return new SupabaseDatabase({
+      url: process.env.SUPABASE_URL || "",
+      anonKey: process.env.SUPABASE_ANON_KEY || "",
+      accessToken: auth.accessToken
+    });
+  } catch {
+    return null;
+  }
+}
+async function getUsageCounts(localDb, userId, projectId) {
+  const projectCountQuery = "SELECT COUNT(*) as count FROM projects";
+  const projectRow = localDb.db.prepare(projectCountQuery).get();
+  const totalProjects = projectRow.count;
+  const totalEntriesQuery = "SELECT COUNT(*) as count FROM memory_entries WHERE is_archived = 0";
+  const totalEntriesRow = localDb.db.prepare(totalEntriesQuery).get();
+  const totalEntries = totalEntriesRow.count;
+  let entriesInProject = 0;
+  if (projectId) {
+    const projectEntriesQuery = "SELECT COUNT(*) as count FROM memory_entries WHERE project_id = ? AND is_archived = 0";
+    const projectEntriesRow = localDb.db.prepare(projectEntriesQuery).get(projectId);
+    entriesInProject = projectEntriesRow.count;
+  }
+  return {
+    totalProjects,
+    totalEntries,
+    entriesInProject,
+    totalSeats: 1
+  };
+}
+async function checkEntryAllowed(localDb, projectId) {
+  try {
+    const userId = getCurrentUserId();
+    const remoteDb = getRemoteDb();
+    const planId = await resolveUserPlan(localDb, remoteDb, userId);
+    const gate = new UsageGate(planId, () => getUsageCounts(localDb, userId, projectId));
+    const result = await gate.checkEntryCreate();
+    if (!result.allowed) {
+      return {
+        allowed: false,
+        message: `
+
+---
+\u{1F4A1} ${result.reason}
+${result.upgradeHint}`
+      };
+    }
+    return { allowed: true };
+  } catch (error) {
+    console.error("Usage gate error:", error);
+    return { allowed: true };
+  }
+}
+
+// src/tools/auto-capture.ts
+async function autoCaptureDecision(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase2(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return JSON.stringify({ status: "error", message: "No Contxt project found." });
+    }
+    const gateCheck = await checkEntryAllowed(db, project.id);
+    if (!gateCheck.allowed) {
+      return JSON.stringify({
+        status: "limit_reached",
+        message: `Decision noted (not saved - usage limit reached).${gateCheck.message}`
+      });
+    }
+    const entry = await db.createEntry({
+      projectId: project.id,
+      type: "decision",
+      title: args.decision,
+      content: args.rationale,
+      metadata: {
+        source: "mcp:auto",
+        category: args.category,
+        alternatives: args.alternatives,
+        decisionStatus: args.status || "active",
+        conversationId: args.conversationId,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      status: "draft"
+    });
+    return JSON.stringify({
+      status: "captured",
+      id: entry.id,
+      message: `Decision captured: ${args.decision} (draft \u2014 run \`contxt review\` to confirm)`
+    });
+  } finally {
+    await db.close();
+  }
+}
+async function autoCapturePattern(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase2(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return JSON.stringify({ status: "error", message: "No Contxt project found." });
+    }
+    const gateCheck = await checkEntryAllowed(db, project.id);
+    if (!gateCheck.allowed) {
+      return JSON.stringify({
+        status: "limit_reached",
+        message: `Pattern noted (not saved - usage limit reached).${gateCheck.message}`
+      });
+    }
+    const entry = await db.createEntry({
+      projectId: project.id,
+      type: "pattern",
+      title: args.pattern,
+      content: args.description,
+      metadata: {
+        source: "mcp:auto",
+        category: args.category,
+        when: args.when,
+        conversationId: args.conversationId,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      status: "draft"
+    });
+    return JSON.stringify({
+      status: "captured",
+      id: entry.id,
+      message: `Pattern captured: ${args.pattern} (draft \u2014 run \`contxt review\` to confirm)`
+    });
+  } finally {
+    await db.close();
+  }
+}
+async function captureDiscussion(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase2(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return JSON.stringify({ status: "error", message: "No Contxt project found." });
+    }
+    const gateCheck = await checkEntryAllowed(db, project.id);
+    if (!gateCheck.allowed) {
+      return JSON.stringify({
+        status: "limit_reached",
+        message: `Discussion noted (not saved - usage limit reached).${gateCheck.message}`
+      });
+    }
+    const content = [
+      args.summary,
+      "",
+      `**Context:** ${args.context}`,
+      args.rejected ? `**Rejected:** ${args.rejected}` : ""
+    ].filter(Boolean).join("\n");
+    const entry = await db.createEntry({
+      projectId: project.id,
+      type: args.type,
+      title: args.title,
+      content,
+      metadata: {
+        source: "mcp:discussion",
+        context: args.context,
+        rejected: args.rejected,
+        conversationId: args.conversationId,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      status: "draft"
+    });
+    return JSON.stringify({
+      status: "captured",
+      id: entry.id,
+      message: `Discussion captured: ${args.title} (draft \u2014 run \`contxt review\` to confirm)`
+    });
+  } finally {
+    await db.close();
+  }
+}
+async function updateSession(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase2(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return JSON.stringify({ status: "error", message: "No Contxt project found." });
+    }
+    const branch = await db.getActiveBranch(project.id);
+    const entries = await db.listEntries({
+      projectId: project.id,
+      branch,
+      type: "context"
+    });
+    const activeContext = entries.find((e) => e.status === "active");
+    if (activeContext) {
+      await db.updateEntry(activeContext.id, {
+        metadata: {
+          ...activeContext.metadata,
+          lastSessionSummary: args.summary,
+          lastSessionFiles: args.filesChanged,
+          lastSessionDecisions: args.decisions,
+          lastSessionAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    } else {
+      const gateCheck = await checkEntryAllowed(db, project.id);
+      if (!gateCheck.allowed) {
+        return JSON.stringify({
+          status: "limit_reached",
+          message: `Session noted (not saved - usage limit reached).${gateCheck.message}`
+        });
+      }
+      await db.createEntry({
+        projectId: project.id,
+        type: "session",
+        title: `Session: ${(/* @__PURE__ */ new Date()).toLocaleDateString()}`,
+        content: args.summary,
+        metadata: {
+          source: "mcp:auto",
+          filesChanged: args.filesChanged,
+          decisions: args.decisions,
+          conversationId: args.conversationId,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        status: "draft"
+      });
+    }
+    return JSON.stringify({
+      status: "updated",
+      message: "Session summary updated."
+    });
+  } finally {
+    await db.close();
+  }
+}
+async function getDrafts(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase2(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return JSON.stringify({ status: "error", message: "No Contxt project found." });
+    }
+    const branch = await db.getActiveBranch(project.id);
+    const allEntries = await db.listEntries({ projectId: project.id, branch });
+    let drafts = allEntries.filter((e) => e.status === "draft");
+    if (args.source) {
+      const sourceFilter = `mcp:${args.source}`;
+      drafts = drafts.filter((e) => e.metadata.source?.includes(sourceFilter));
+    }
+    if (drafts.length === 0) {
+      return JSON.stringify({ status: "ok", count: 0, message: "No drafts pending review." });
+    }
+    const summary = drafts.map((d) => ({
+      id: d.id,
+      type: d.type,
+      title: d.title,
+      source: d.metadata.source,
+      conversationId: d.metadata.conversationId,
+      capturedAt: d.metadata.capturedAt || d.createdAt
+    }));
+    return JSON.stringify({
+      status: "ok",
+      count: drafts.length,
+      drafts: summary,
+      message: `${drafts.length} draft${drafts.length !== 1 ? "s" : ""} pending. Run \`contxt review\` to confirm them.`
+    });
+  } finally {
+    await db.close();
+  }
+}
+async function confirmDraft(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase2(dbPath);
+  await db.initialize();
+  try {
+    const entry = await db.getEntry(args.id);
+    if (!entry) {
+      return JSON.stringify({ status: "error", message: `Draft ${args.id} not found.` });
+    }
+    if (entry.status !== "draft") {
+      return JSON.stringify({ status: "error", message: `Entry ${args.id} is not a draft.` });
+    }
+    await db.updateEntry(args.id, { status: "active" });
+    return JSON.stringify({
+      status: "confirmed",
+      id: args.id,
+      message: `"${entry.title}" confirmed and added to memory.`
+    });
+  } finally {
+    await db.close();
+  }
+}
+
+// src/tools/index.ts
+async function getProjectContext(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const activeBranch = await db.getActiveBranch(project.id);
+    const context = await engine.getContext(project.id);
+    const decisions = await engine.listDecisions(project.id);
+    const patterns = await engine.listPatterns(project.id);
+    const lines = [];
+    lines.push(`# Project: ${project.name}`);
+    lines.push("");
+    lines.push(`**Branch:** ${activeBranch}`);
+    lines.push(`**Stack:** ${project.stack?.join(", ") || "Not specified"}`);
+    lines.push("");
+    if (context) {
+      lines.push("## Current Context");
+      if (context.metadata.feature) {
+        lines.push(`**Feature:** ${context.metadata.feature}`);
+      }
+      if (context.metadata.blockers?.length > 0) {
+        lines.push(`**Blockers:** ${context.metadata.blockers.join(", ")}`);
+      }
+      lines.push("");
+    }
+    lines.push(`## Summary`);
+    lines.push(`- ${decisions.length} decisions`);
+    lines.push(`- ${patterns.length} patterns`);
+    return lines.join("\n");
+  } finally {
+    await db.close();
+  }
+}
+async function getDecisions(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const decisions = await engine.listDecisions(project.id);
+    const limited = args.limit ? decisions.slice(0, args.limit) : decisions;
+    if (limited.length === 0) {
+      return "No decisions found.";
+    }
+    const lines = [];
+    lines.push("# Architectural Decisions");
+    lines.push("");
+    for (const decision of limited) {
+      lines.push(`## ${decision.title}`);
+      lines.push("");
+      lines.push(decision.content);
+      if (decision.metadata.alternatives?.length > 0) {
+        lines.push("");
+        lines.push(`**Alternatives considered:** ${decision.metadata.alternatives.join(", ")}`);
+      }
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    return lines.join("\n");
+  } finally {
+    await db.close();
+  }
+}
+async function getPatterns(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const patterns = await engine.listPatterns(project.id);
+    const limited = args.limit ? patterns.slice(0, args.limit) : patterns;
+    if (limited.length === 0) {
+      return "No patterns found.";
+    }
+    const lines = [];
+    lines.push("# Code Patterns & Conventions");
+    lines.push("");
+    for (const pattern of limited) {
+      lines.push(`## ${pattern.title}`);
+      lines.push("");
+      lines.push(pattern.content);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    return lines.join("\n");
+  } finally {
+    await db.close();
+  }
+}
+async function searchMemory(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const results = await engine.searchEntries(project.id, args.query);
+    const limited = args.limit ? results.slice(0, args.limit) : results;
+    if (limited.length === 0) {
+      return `No results found for "${args.query}".`;
+    }
+    const lines = [];
+    lines.push(`# Search Results for "${args.query}"`);
+    lines.push("");
+    for (const entry of limited) {
+      lines.push(`## ${entry.type.toUpperCase()}: ${entry.title}`);
+      lines.push("");
+      lines.push(entry.content);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    return lines.join("\n");
+  } finally {
+    await db.close();
+  }
+}
+async function logDecision(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const input = {
+      title: args.title,
+      rationale: args.rationale,
+      alternatives: args.alternatives
+    };
+    const entry = await engine.addDecision(project.id, input);
+    return `Decision "${entry.title}" logged successfully.`;
+  } finally {
+    await db.close();
+  }
+}
+async function updateContext(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const input = {
+      feature: args.feature,
+      blockers: args.blockers,
+      nextSteps: args.nextSteps
+    };
+    await engine.setContext(project.id, input);
+    return "Project context updated successfully.";
+  } finally {
+    await db.close();
+  }
+}
+async function savePattern(args) {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+  const db = new SQLiteDatabase3(dbPath);
+  await db.initialize();
+  try {
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return "No MemoCore project found.";
+    }
+    const engine = new MemoryEngine(db);
+    const input = {
+      title: args.title,
+      content: args.content,
+      category: args.category
+    };
+    const entry = await engine.addPattern(project.id, input);
+    return `Pattern "${entry.title}" saved successfully.`;
+  } finally {
+    await db.close();
+  }
+}
+
+// src/server.ts
+var server = new Server(
+  {
+    name: "contxt",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "suggest_context",
+        description: "Smart context retrieval - returns relevant memory entries based on task description and active files. This is the primary tool for getting project context.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskDescription: {
+              type: "string",
+              description: "Description of the task or feature being worked on"
+            },
+            activeFiles: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of files currently being worked on"
+            },
+            maxTokens: {
+              type: "number",
+              description: "Maximum tokens for context (default: 4000)"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          }
+        }
+      },
+      {
+        name: "get_project_context",
+        description: "Get project overview including stack, configuration, active context, and summary statistics",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          }
+        }
+      },
+      {
+        name: "get_decisions",
+        description: "Get architectural decisions with optional limit",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Maximum number of decisions to return"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          }
+        }
+      },
+      {
+        name: "get_patterns",
+        description: "Get code patterns and conventions with optional limit",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Maximum number of patterns to return"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          }
+        }
+      },
+      {
+        name: "search_memory",
+        description: "Search across all memory entries using full-text search",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "log_decision",
+        description: "Log a new architectural decision",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: {
+              type: "string",
+              description: "Decision title"
+            },
+            rationale: {
+              type: "string",
+              description: "Rationale for the decision"
+            },
+            alternatives: {
+              type: "array",
+              items: { type: "string" },
+              description: "Alternative approaches considered"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          },
+          required: ["title", "rationale"]
+        }
+      },
+      {
+        name: "update_context",
+        description: "Update the current working context",
+        inputSchema: {
+          type: "object",
+          properties: {
+            feature: {
+              type: "string",
+              description: "Feature being worked on"
+            },
+            blockers: {
+              type: "array",
+              items: { type: "string" },
+              description: "Current blockers"
+            },
+            nextSteps: {
+              type: "array",
+              items: { type: "string" },
+              description: "Next steps to take"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          }
+        }
+      },
+      {
+        name: "save_pattern",
+        description: "Save a new code pattern or convention",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: {
+              type: "string",
+              description: "Pattern title"
+            },
+            content: {
+              type: "string",
+              description: "Pattern content/code"
+            },
+            category: {
+              type: "string",
+              description: "Pattern category"
+            },
+            projectPath: {
+              type: "string",
+              description: "Path to project directory (default: current directory)"
+            }
+          },
+          required: ["title", "content"]
+        }
+      },
+      // ── Auto-capture tools (called by AI silently during conversation) ──
+      {
+        name: "contxt_auto_capture_decision",
+        description: "Silently capture an architectural decision made during the conversation. Call this when the developer chooses one technology/approach over another. Saves as a draft for later review.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            decision: { type: "string", description: "The decision title" },
+            rationale: { type: "string", description: "Why this decision was made" },
+            category: { type: "string", description: "Category (infrastructure, frontend, backend, etc.)" },
+            alternatives: { type: "string", description: "Alternatives considered" },
+            conversationId: { type: "string", description: "ID to group entries from the same conversation" },
+            projectPath: { type: "string", description: "Project directory path" }
+          },
+          required: ["decision", "rationale"]
+        }
+      },
+      {
+        name: "contxt_auto_capture_pattern",
+        description: "Silently capture a reusable code pattern or convention. Call this when the developer establishes a pattern that should be followed consistently. Saves as a draft.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: { type: "string", description: "Pattern name" },
+            description: { type: "string", description: "What the pattern does and when to use it" },
+            category: { type: "string", description: "Pattern category (api, component, testing, etc.)" },
+            when: { type: "string", description: "When to apply this pattern" },
+            conversationId: { type: "string", description: "ID to group entries from the same conversation" },
+            projectPath: { type: "string", description: "Project directory path" }
+          },
+          required: ["pattern", "description"]
+        }
+      },
+      {
+        name: "contxt_capture_discussion",
+        description: "Capture an insight that emerged from conversation \u2014 richer than auto_capture_decision. Use when a decision or pattern came out of back-and-forth; captures context, what was rejected, and why. Saves as a draft.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: ["decision", "pattern", "context"], description: "Entry type" },
+            title: { type: "string", description: "Short title for the decision or pattern" },
+            summary: { type: "string", description: "Full statement of the decision or pattern" },
+            context: { type: "string", description: "What problem or question prompted this" },
+            rejected: { type: "string", description: "What was considered and rejected, and why" },
+            conversationId: { type: "string", description: "ID to group entries from the same conversation" },
+            projectPath: { type: "string", description: "Project directory path" }
+          },
+          required: ["type", "title", "summary", "context"]
+        }
+      },
+      {
+        name: "contxt_update_session",
+        description: "Log what was accomplished in this AI conversation session. Call at the end of a session.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            summary: { type: "string", description: "Summary of what was accomplished" },
+            filesChanged: { type: "array", items: { type: "string" }, description: "Files modified" },
+            decisions: { type: "array", items: { type: "string" }, description: "Key decisions made" },
+            conversationId: { type: "string", description: "ID to group entries from the same conversation" },
+            projectPath: { type: "string", description: "Project directory path" }
+          },
+          required: ["summary"]
+        }
+      },
+      {
+        name: "contxt_get_drafts",
+        description: "Get pending draft entries awaiting developer review. Show when asked what was captured.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: { type: "string", description: "Filter by source (auto, hooks, scan)" },
+            projectPath: { type: "string", description: "Project directory path" }
+          }
+        }
+      },
+      {
+        name: "contxt_confirm_draft",
+        description: "Confirm and activate a draft entry when the developer explicitly approves it.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Draft entry ID to confirm" },
+            projectPath: { type: "string", description: "Project directory path" }
+          },
+          required: ["id"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    let result;
+    switch (name) {
+      case "suggest_context":
+        result = await suggestContext(args || {});
+        break;
+      case "get_project_context":
+        result = await getProjectContext(args || {});
+        break;
+      case "get_decisions":
+        result = await getDecisions(args || {});
+        break;
+      case "get_patterns":
+        result = await getPatterns(args || {});
+        break;
+      case "search_memory":
+        if (!args?.query) {
+          throw new Error("query parameter is required");
+        }
+        result = await searchMemory(args);
+        break;
+      case "log_decision":
+        if (!args?.title || !args?.rationale) {
+          throw new Error("title and rationale parameters are required");
+        }
+        result = await logDecision(args);
+        break;
+      case "update_context":
+        result = await updateContext(args || {});
+        break;
+      case "save_pattern":
+        if (!args?.title || !args?.content) {
+          throw new Error("title and content parameters are required");
+        }
+        result = await savePattern(args);
+        break;
+      // Auto-capture tools
+      case "contxt_capture_discussion":
+        if (!args?.type || !args?.title || !args?.summary || !args?.context) {
+          throw new Error("type, title, summary, and context parameters are required");
+        }
+        result = await captureDiscussion(args);
+        break;
+      case "contxt_auto_capture_decision":
+        if (!args?.decision || !args?.rationale) {
+          throw new Error("decision and rationale parameters are required");
+        }
+        result = await autoCaptureDecision(args);
+        break;
+      case "contxt_auto_capture_pattern":
+        if (!args?.pattern || !args?.description) {
+          throw new Error("pattern and description parameters are required");
+        }
+        result = await autoCapturePattern(args);
+        break;
+      case "contxt_update_session":
+        if (!args?.summary) {
+          throw new Error("summary parameter is required");
+        }
+        result = await updateSession(args);
+        break;
+      case "contxt_get_drafts":
+        result = await getDrafts(args || {});
+        break;
+      case "contxt_confirm_draft":
+        if (!args?.id) {
+          throw new Error("id parameter is required");
+        }
+        result = await confirmDraft(args);
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: result
+        }
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${errorMessage}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Contxt MCP Server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map