@context-os/mcp 1.0.0 → 1.6.1

package/dist/{workspace-mcp/src/index.js → index.js}

@@ -8,6 +8,8 @@ import { registerContextTool } from "./tools/context.js";
 import { registerDecisionTool } from "./tools/decision.js";
 import { registerMemoryTool } from "./tools/memory.js";
 import { registerDailyTool } from "./tools/daily.js";
+import { registerSamplingTool } from "./tools/sampling.js";
+import { registerResources } from "./resources.js";
 async function main() {
     const server = new McpServer({
         name: "workspace-mcp",
@@ -21,6 +23,9 @@ async function main() {
     registerDecisionTool(server);
     registerMemoryTool(server);
     registerDailyTool(server);
+    registerSamplingTool(server);
+    // Register Resources
+    registerResources(server);
     // Connect via stdio
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/resources.js

@@ -0,0 +1,29 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { samplingService, knowledgeGraphService } from "@context-os/core";
+export function registerResources(server) {
+    // 1. Static Resource: Workspace Health Pulse
+    server.resource("workspace_health", "context://workspace/health", async (uri) => {
+        const pulse = await samplingService.getPulse();
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: JSON.stringify(pulse, null, 2),
+                    mimeType: "application/json"
+                }]
+        };
+    });
+    // 2. Resource Template: Project Relationship Graph
+    server.resource("project_graph", new ResourceTemplate("context://projects/{path}/graph", { list: undefined }), async (uri, { path }) => {
+        const graph = await knowledgeGraphService.getGraph();
+        // Filter graph for specific project context (simplified for now)
+        const projectNodes = graph.nodes.filter((n) => n.id.includes(path));
+        const projectEdges = graph.edges.filter((e) => e.source.includes(path) || e.target.includes(path));
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: JSON.stringify({ nodes: projectNodes, edges: projectEdges }, null, 2),
+                    mimeType: "application/json"
+                }]
+        };
+    });
+}

package/dist/tests/mcp-tools.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerSearchTool } from "../tools/search.js";
+import { registerWriteTool } from "../tools/write.js";
+describe("MCP Interface Layer (Registration Tests)", () => {
+    let server;
+    beforeEach(() => {
+        server = new McpServer({
+            name: "test-server",
+            version: "1.0.0"
+        });
+    });
+    it("should register search tools without error", () => {
+        assert.doesNotThrow(() => {
+            registerSearchTool(server);
+        });
+    });
+    it("should register write tools without error", () => {
+        assert.doesNotThrow(() => {
+            registerWriteTool(server);
+        });
+    });
+});

package/dist/tools/sampling.js

@@ -0,0 +1,25 @@
+import { samplingService } from "@context-os/core";
+import { handleToolError } from "../utils.js";
+export function registerSamplingTool(server) {
+    server.tool("workspace_sample", {}, async () => {
+        try {
+            const pulse = await samplingService.getPulse();
+            const summary = [
+                "### Workspace Pulse Snapshot ###",
+                `Overall Health Score: ${pulse.healthScore}%`,
+                `Top Trends: ${pulse.topTags.join(", ")}`,
+                `Recent Activity:`,
+                ...pulse.recentChanges.map((path) => `- ${path}`),
+                "",
+                "Use the `workspace_search` tool for deep context on these areas."
+            ].join("\n");
+            return {
+                content: [{ type: "text", text: summary }],
+                isError: false
+            };
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/search.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { intelligenceService } from "@context-os/core";
+import { handleToolError } from "../utils.js";
+export function registerSearchTool(server) {
+    server.tool("workspace_search", {
+        query: z.string().describe("Search query string"),
+        deep: z.boolean().optional().describe("Force deep scan using grep")
+    }, async ({ query, deep }) => {
+        try {
+            const results = await intelligenceService.search(query, { deep });
+            if (results.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No results found." }],
+                };
+            }
+            const formattedResults = results.map(res => {
+                const typeTag = res.type === 'index' ? '[Index]' : '[Deep]';
+                let output = `${typeTag} ${res.path}\n`;
+                if (res.title && res.title !== 'Deep Scan Result') {
+                    output += `Title: ${res.title} ${res.tags.length ? `[${res.tags.join(', ')}]` : ''}\n`;
+                }
+                output += `Excerpt: ${res.excerpt}\n`;
+                output += `---`;
+                return output;
+            }).join('\n');
+            return {
+                content: [{ type: "text", text: formattedResults }],
+                isError: false
+            };
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-os/mcp",
-  "version": "1.0.0",
+  "version": "1.6.1",
   "description": "Model Context Protocol server for ContextOS integration",
   "type": "module",
   "publishConfig": {
@@ -21,11 +21,12 @@
     "build": "tsc",
     "watch": "tsc -w",
     "start": "node dist/index.js",
-    "test": "npm run build && PATH=/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin npx mocha dist/tests/**/*.test.js"
+    "test": "PATH=/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin npx mocha dist/tests/**/*.test.js",
+    "validate": "exit 0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.0",
-    "@context-os/core": "1.0.0"
+    "@context-os/core": "1.6.1"
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",

package/dist/packages/core/src/index.js

@@ -1,88 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import { spawn } from 'node:child_process';
-/**
- * Discovers the workspace root by looking for root/soul.md in parent directories.
- */
-export function findWorkspaceRoot() {
-    let current = process.cwd();
-    const root = path.parse(current).root;
-    while (current !== root) {
-        if (fs.existsSync(path.join(current, "root", "soul.md"))) {
-            return fs.realpathSync(current);
-        }
-        current = path.dirname(current);
-    }
-    return fs.realpathSync(process.cwd()); // Fallback to CWD
-}
-export const workspaceRoot = findWorkspaceRoot();
-/**
- * Standard ContextOS "Buckets" for security isolation.
- */
-export const ALLOWED_BUCKETS = [
-    "projects",
-    "knowledge",
-    "schemas",
-    "archive",
-    "log",
-    "orgs",
-    "root"
-];
-/**
- * Validates that a path is within the workspace root and inside an allowed bucket.
- */
-export function validatePath(requestedPath) {
-    const resolvedPath = path.resolve(workspaceRoot, requestedPath);
-    let fullPath;
-    try {
-        fullPath = fs.realpathSync(resolvedPath);
-    }
-    catch (e) {
-        fullPath = resolvedPath;
-    }
-    const relativePath = path.relative(workspaceRoot, fullPath);
-    // Security check: must be within the workspace root
-    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-        throw new Error(`Security violation: Path ${requestedPath} is outside the allowed ContextOS workspace root.`);
-    }
-    // Enterprise check: must be within an allowed bucket
-    const isAllowed = ALLOWED_BUCKETS.some(bucket => {
-        const bucketRoot = path.join(workspaceRoot, bucket);
-        const bucketRelative = path.relative(bucketRoot, fullPath);
-        return !bucketRelative.startsWith("..") && !path.isAbsolute(bucketRelative);
-    });
-    if (!isAllowed) {
-        throw new Error(`Security violation: Path ${requestedPath} is outside the allowed bucket (projects, orgs, knowledge, schemas, etc).`);
-    }
-    return { fullPath, relativePath };
-}
-/**
- * Checks if a path is in a read-only bucket for agents.
- */
-export function isReadOnly(filePath) {
-    const { fullPath } = validatePath(filePath);
-    const readOnlyBuckets = ["knowledge", "schemas", "root"];
-    return readOnlyBuckets.some(bucket => {
-        const bucketRoot = path.join(workspaceRoot, bucket);
-        const bucketRelative = path.relative(bucketRoot, fullPath);
-        return !bucketRelative.startsWith("..") && !path.isAbsolute(bucketRelative);
-    });
-}
-/**
- * Executes an atomic git transaction (Add + Commit).
- */
-export async function gitCommit(filePath, message) {
-    return new Promise((resolve, reject) => {
-        const add = spawn("git", ["add", filePath], { cwd: workspaceRoot });
-        add.on("close", (code) => {
-            if (code !== 0 && code !== null) {
-                return reject(new Error(`Git add failed with code ${code}`));
-            }
-            const commit = spawn("git", ["commit", "-m", message], { cwd: workspaceRoot });
-            commit.on("close", (code) => {
-                // If code is not 0, it might be "nothing to commit" which is fine for our tools
-                resolve();
-            });
-        });
-    });
-}

package/dist/workspace-mcp/src/tools/search.js

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { validatePath, handleToolError } from "../utils.js";
-const execFileAsync = promisify(execFile);
-export function registerSearchTool(server) {
-    server.tool("workspace_search", {
-        query: z.string().describe("Search query string"),
-        scope: z.string().optional().describe("Search scope (e.g., projects, knowledge, or specific project name)")
-    }, async ({ query, scope }) => {
-        try {
-            const target = scope === "root" ? "." : scope || "projects";
-            const { fullPath: baseDir } = validatePath(target);
-            // Use grep -rnI via execFile (no shell interpolation)
-            const { stdout } = await execFileAsync("grep", ["-rnIE", query, "."], { cwd: baseDir });
-            const results = stdout.split("\n").slice(0, 50).join("\n");
-            return {
-                content: [{ type: "text", text: results || "No results found." }],
-                isError: false
-            };
-        }
-        catch (error) {
-            // If grep fails (no results), return a friendly message
-            if (error.code === 1) {
-                return {
-                    content: [{ type: "text", text: "No results found." }],
-                    isError: false
-                };
-            }
-            return handleToolError(error);
-        }
-    });
-}