@contextos/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,741 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/provider.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+var core = null;
+async function loadCore() {
+  if (core) return core;
+  try {
+    core = await import("@contextos/core");
+    return core;
+  } catch {
+    return null;
+  }
+}
+var ContextOSProvider = class {
+  projectDir;
+  contextDir;
+  lastContext = "";
+  constructor(projectDir) {
+    this.projectDir = projectDir || process.cwd();
+    this.contextDir = join(this.projectDir, ".contextos");
+  }
+  /**
+   * Check if ContextOS is initialized in the current directory
+   */
+  isInitialized() {
+    return existsSync(this.contextDir);
+  }
+  /**
+   * Build optimized context for a goal
+   */
+  async buildContext(goal) {
+    const core2 = await loadCore();
+    if (core2) {
+      try {
+        const builder = await core2.getContextBuilder();
+        const result = await builder.build({ goal, maxTokens: 32e3 });
+        this.lastContext = result.context;
+        return this.formatContext(goal, result);
+      } catch (error) {
+      }
+    }
+    return this.buildSimpleContext(goal);
+  }
+  /**
+   * Analyze codebase with RLM
+   */
+  async analyze(query) {
+    const core2 = await loadCore();
+    if (core2) {
+      try {
+        const engine = new core2.RLMEngine({
+          maxDepth: 3,
+          maxTokenBudget: 5e4
+        });
+        const result = await engine.execute(query, await this.getCurrentContext());
+        return result.answer;
+      } catch (error) {
+        return `Analysis requires AI API key. Error: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+    return "Full analysis requires @contextos/core with AI API key configured.";
+  }
+  /**
+   * Find files matching pattern
+   */
+  async findFiles(pattern) {
+    const files = this.walkDirectory(this.projectDir, pattern);
+    if (files.length === 0) {
+      return `No files found matching pattern: ${pattern}`;
+    }
+    return `# Files matching "${pattern}"
+
+${files.map((f) => `- ${f}`).join("\n")}`;
+  }
+  /**
+   * Get dependencies of a file
+   */
+  async getDependencies(file, depth = 2) {
+    const core2 = await loadCore();
+    if (core2) {
+      try {
+        const fullPath = join(this.projectDir, file);
+        if (!existsSync(fullPath)) {
+          return `File not found: ${file}`;
+        }
+        const content = readFileSync(fullPath, "utf-8");
+        const result = core2.parseWithRegex(content, this.detectLanguage(file));
+        const deps = result.imports.map((i) => i.source);
+        return `# Dependencies of ${file}
+
+${deps.map((d) => `- ${d}`).join("\n") || "No imports found"}`;
+      } catch (error) {
+      }
+    }
+    return this.extractImportsSimple(file);
+  }
+  /**
+   * Explain a file
+   */
+  async explainFile(file) {
+    const fullPath = join(this.projectDir, file);
+    if (!existsSync(fullPath)) {
+      return `File not found: ${file}`;
+    }
+    const content = readFileSync(fullPath, "utf-8");
+    const lines = content.split("\n").length;
+    const core2 = await loadCore();
+    let analysis = "";
+    if (core2) {
+      try {
+        const result = core2.parseWithRegex(content, this.detectLanguage(file));
+        analysis = `
+## Structure
+
+- **Functions**: ${result.functions.join(", ") || "None"}
+- **Classes**: ${result.classes.join(", ") || "None"}
+- **Imports**: ${result.imports.length} imports
+`;
+      } catch {
+      }
+    }
+    return `# ${file}
+
+## Overview
+
+- **Lines**: ${lines}
+- **Language**: ${this.detectLanguage(file)}
+${analysis}
+
+## Content Preview
+
+\`\`\`${this.detectLanguage(file)}
+${content.slice(0, 2e3)}${content.length > 2e3 ? "\n... (truncated)" : ""}
+\`\`\`
+`;
+  }
+  /**
+   * Get current status
+   */
+  async getStatus() {
+    const initialized = this.isInitialized();
+    let status = `# ContextOS Status
+
+`;
+    status += `- **Project Directory**: ${this.projectDir}
+`;
+    status += `- **Initialized**: ${initialized ? "\u2705 Yes" : "\u274C No"}
+`;
+    if (initialized) {
+      const configPath = join(this.contextDir, "context.yaml");
+      if (existsSync(configPath)) {
+        status += `- **Config**: context.yaml found
+`;
+      }
+    } else {
+      status += `
+> Run \`ctx init\` to initialize ContextOS in this project.`;
+    }
+    return status;
+  }
+  /**
+   * Get current context
+   */
+  async getCurrentContext() {
+    if (this.lastContext) {
+      return this.lastContext;
+    }
+    const cachePath = join(this.contextDir, "cache", "last-context.md");
+    if (existsSync(cachePath)) {
+      return readFileSync(cachePath, "utf-8");
+    }
+    return "No context built yet. Use contextos_build tool first.";
+  }
+  /**
+   * Get project info
+   */
+  async getProjectInfo() {
+    const configPath = join(this.contextDir, "context.yaml");
+    if (!existsSync(configPath)) {
+      return JSON.stringify({
+        error: "ContextOS not initialized",
+        suggestion: "Run ctx init"
+      }, null, 2);
+    }
+    const content = readFileSync(configPath, "utf-8");
+    const info = {};
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const match = line.match(/^\s*(name|language|framework|description):\s*["']?([^"'\n]+)["']?/);
+      if (match) {
+        info[match[1]] = match[2].trim();
+      }
+    }
+    return JSON.stringify(info, null, 2);
+  }
+  /**
+   * Get constraints
+   */
+  async getConstraints() {
+    const configPath = join(this.contextDir, "context.yaml");
+    if (!existsSync(configPath)) {
+      return "No constraints defined (ContextOS not initialized)";
+    }
+    const content = readFileSync(configPath, "utf-8");
+    const constraintsMatch = content.match(/constraints:\s*\n((?:\s+-[^\n]+\n?)+)/);
+    if (!constraintsMatch) {
+      return "No constraints defined in context.yaml";
+    }
+    return `# Project Constraints
+
+${constraintsMatch[1]}`;
+  }
+  /**
+   * Get project structure
+   */
+  async getProjectStructure() {
+    const tree = this.buildTree(this.projectDir, "", 0, 3);
+    return `# Project Structure
+
+\`\`\`
+${tree}\`\`\``;
+  }
+  /**
+   * Get file with dependencies
+   */
+  async getFileWithDeps(file) {
+    const content = await this.explainFile(file);
+    const deps = await this.getDependencies(file);
+    return `${content}
+
+${deps}`;
+  }
+  // ═══════════════════════════════════════════════════════════
+  // PRIVATE HELPERS
+  // ═══════════════════════════════════════════════════════════
+  formatContext(goal, result) {
+    return `# Context for: ${goal}
+
+## Statistics
+- Files included: ${result.files.length}
+- Total tokens: ~${result.tokens}
+
+## Files
+${result.files.map((f) => `- ${f}`).join("\n")}
+
+## Content
+
+${result.context}
+`;
+  }
+  async buildSimpleContext(goal) {
+    const keywords = goal.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+    const files = this.walkDirectory(this.projectDir);
+    const relevant = files.filter((file) => {
+      const lower = file.toLowerCase();
+      return keywords.some((kw) => lower.includes(kw));
+    }).slice(0, 10);
+    if (relevant.length === 0) {
+      return `No files found related to: ${goal}
+
+Try running \`ctx index\` first.`;
+    }
+    let context = `# Context for: ${goal}
+
+`;
+    for (const file of relevant) {
+      const fullPath = join(this.projectDir, file);
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        context += `## ${file}
+
+\`\`\`
+${content.slice(0, 3e3)}
+\`\`\`
+
+`;
+      } catch {
+      }
+    }
+    this.lastContext = context;
+    return context;
+  }
+  walkDirectory(dir, pattern, maxFiles = 100) {
+    const results = [];
+    const ignored = ["node_modules", ".git", "dist", "build", ".contextos", "coverage"];
+    const walk = (currentDir) => {
+      if (results.length >= maxFiles) return;
+      try {
+        const entries = readdirSync(currentDir);
+        for (const entry of entries) {
+          if (results.length >= maxFiles) break;
+          if (ignored.includes(entry)) continue;
+          const fullPath = join(currentDir, entry);
+          const relativePath = relative(this.projectDir, fullPath);
+          try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+              walk(fullPath);
+            } else if (stat.isFile()) {
+              if (!pattern || this.matchPattern(relativePath, pattern)) {
+                results.push(relativePath);
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    };
+    walk(dir);
+    return results;
+  }
+  matchPattern(path, pattern) {
+    const regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+    return new RegExp(regex).test(path);
+  }
+  detectLanguage(file) {
+    const ext = file.split(".").pop()?.toLowerCase() || "";
+    const langMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      py: "python",
+      go: "go",
+      rs: "rust",
+      java: "java"
+    };
+    return langMap[ext] || ext;
+  }
+  extractImportsSimple(file) {
+    const fullPath = join(this.projectDir, file);
+    if (!existsSync(fullPath)) {
+      return `File not found: ${file}`;
+    }
+    const content = readFileSync(fullPath, "utf-8");
+    const imports = [];
+    const patterns = [
+      /import\s+.*from\s+['"]([^'"]+)['"]/g,
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      /^import\s+([\w.]+)/gm,
+      /^from\s+([\w.]+)\s+import/gm
+    ];
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        if (match[1] && !imports.includes(match[1])) {
+          imports.push(match[1]);
+        }
+      }
+    }
+    return `# Dependencies of ${file}
+
+${imports.map((i) => `- ${i}`).join("\n") || "No imports found"}`;
+  }
+  buildTree(dir, prefix, depth, maxDepth) {
+    if (depth >= maxDepth) return "";
+    const ignored = ["node_modules", ".git", "dist", "build", ".contextos", "coverage", "__pycache__"];
+    let result = "";
+    try {
+      const entries = readdirSync(dir).filter((e) => !ignored.includes(e)).sort();
+      for (let i = 0; i < entries.length && i < 20; i++) {
+        const entry = entries[i];
+        const isLast = i === entries.length - 1 || i === 19;
+        const fullPath = join(dir, entry);
+        try {
+          const stat = statSync(fullPath);
+          const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          result += `${prefix}${connector}${entry}${stat.isDirectory() ? "/" : ""}
+`;
+          if (stat.isDirectory()) {
+            const newPrefix = prefix + (isLast ? "    " : "\u2502   ");
+            result += this.buildTree(fullPath, newPrefix, depth + 1, maxDepth);
+          }
+        } catch {
+        }
+      }
+      if (entries.length > 20) {
+        result += `${prefix}\u2514\u2500\u2500 ... (${entries.length - 20} more)
+`;
+      }
+    } catch {
+    }
+    return result;
+  }
+};
+
+// src/definitions.ts
+var TOOLS = [
+  {
+    name: "contextos_build",
+    description: "Build optimized context for a specific goal. Returns the most relevant files from the codebase based on semantic similarity, dependency graph, and custom rules.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        goal: {
+          type: "string",
+          description: 'The coding task or goal (e.g., "Add authentication to UserController")'
+        }
+      },
+      required: ["goal"]
+    }
+  },
+  {
+    name: "contextos_analyze",
+    description: "Perform deep analysis of the codebase using RLM engine. Can find patterns, security issues, or answer complex questions about the code.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Analysis query (e.g., "Find potential security vulnerabilities")'
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "contextos_find",
+    description: "Find files matching a pattern in the indexed codebase.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Glob pattern to match (e.g., "**/auth/**/*.ts")'
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  {
+    name: "contextos_deps",
+    description: "Get dependencies of a file up to a specified depth.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "File path to analyze dependencies for"
+        },
+        depth: {
+          type: "number",
+          description: "Maximum depth to traverse (default: 2)"
+        }
+      },
+      required: ["file"]
+    }
+  },
+  {
+    name: "contextos_explain",
+    description: "Get an AI-powered explanation of a file, including its purpose, key functions, and how it relates to other parts of the codebase.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "File path to explain"
+        }
+      },
+      required: ["file"]
+    }
+  },
+  {
+    name: "contextos_status",
+    description: "Get the current status of ContextOS: project info, index status, and configuration.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+var RESOURCES = [
+  {
+    uri: "contextos://context/current",
+    name: "Current Context",
+    description: "The most recently built context (output of ctx build/goal)",
+    mimeType: "text/markdown"
+  },
+  {
+    uri: "contextos://project/info",
+    name: "Project Info",
+    description: "Project configuration from context.yaml (name, language, framework, stack)",
+    mimeType: "application/json"
+  },
+  {
+    uri: "contextos://project/constraints",
+    name: "Coding Constraints",
+    description: "Project coding rules and constraints that should be followed",
+    mimeType: "text/markdown"
+  },
+  {
+    uri: "contextos://project/structure",
+    name: "Project Structure",
+    description: "Directory tree of the project (excluding node_modules, etc.)",
+    mimeType: "text/plain"
+  }
+];
+var PROMPTS = [
+  {
+    name: "code_with_context",
+    description: "Start a coding task with optimized context from ContextOS",
+    arguments: [
+      {
+        name: "goal",
+        description: "The coding task or goal",
+        required: true
+      }
+    ]
+  },
+  {
+    name: "review_code",
+    description: "Review a file and its dependencies",
+    arguments: [
+      {
+        name: "file",
+        description: "File path to review",
+        required: true
+      }
+    ]
+  },
+  {
+    name: "debug_issue",
+    description: "Debug an issue with relevant context",
+    arguments: [
+      {
+        name: "issue",
+        description: "Description of the issue",
+        required: true
+      }
+    ]
+  }
+];
+
+// src/index.ts
+var server = new Server(
+  {
+    name: "contextos",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+      prompts: {}
+    }
+  }
+);
+var provider = new ContextOSProvider();
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: TOOLS
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "contextos_build": {
+        const goal = args.goal;
+        const result = await provider.buildContext(goal);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "contextos_analyze": {
+        const query = args.query;
+        const result = await provider.analyze(query);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "contextos_find": {
+        const pattern = args.pattern;
+        const result = await provider.findFiles(pattern);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "contextos_deps": {
+        const file = args.file;
+        const depth = args.depth || 2;
+        const result = await provider.getDependencies(file, depth);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "contextos_explain": {
+        const file = args.file;
+        const result = await provider.explainFile(file);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "contextos_status": {
+        const result = await provider.getStatus();
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: RESOURCES
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  try {
+    if (uri === "contextos://context/current") {
+      const content = await provider.getCurrentContext();
+      return {
+        contents: [{ uri, mimeType: "text/markdown", text: content }]
+      };
+    }
+    if (uri === "contextos://project/info") {
+      const content = await provider.getProjectInfo();
+      return {
+        contents: [{ uri, mimeType: "application/json", text: content }]
+      };
+    }
+    if (uri === "contextos://project/constraints") {
+      const content = await provider.getConstraints();
+      return {
+        contents: [{ uri, mimeType: "text/markdown", text: content }]
+      };
+    }
+    if (uri === "contextos://project/structure") {
+      const content = await provider.getProjectStructure();
+      return {
+        contents: [{ uri, mimeType: "text/plain", text: content }]
+      };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  } catch (error) {
+    throw new Error(`Failed to read resource: ${error instanceof Error ? error.message : String(error)}`);
+  }
+});
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+  prompts: PROMPTS
+}));
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  switch (name) {
+    case "code_with_context": {
+      const goal = args?.goal || "general coding task";
+      const context = await provider.buildContext(goal);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `# Project Context
+
+${context}
+
+# Task
+
+${goal}`
+            }
+          }
+        ]
+      };
+    }
+    case "review_code": {
+      const file = args?.file || "";
+      const content = await provider.getFileWithDeps(file);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `# Code Review Request
+
+Please review the following code and its dependencies:
+
+${content}`
+            }
+          }
+        ]
+      };
+    }
+    case "debug_issue": {
+      const issue = args?.issue || "unknown issue";
+      const context = await provider.buildContext(`debug: ${issue}`);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `# Debug Request
+
+## Issue
+${issue}
+
+## Relevant Context
+
+${context}`
+            }
+          }
+        ]
+      };
+    }
+    default:
+      throw new Error(`Unknown prompt: ${name}`);
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("ContextOS MCP Server started");
+}
+main().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});