archgraph-argo 0.4.2 → 0.5.1

package/argo/scripts/argo-mcp-server.js

@@ -16,6 +16,8 @@ const {
 } = require('./repositoryArgoEnvironment.js');
 const {
   getWorkspaceRoot,
+  hasStaticWorkspace,
+  setMcpWorkspaceRoots,
 } = require('./argo-paths.js');
 const canonicalSemanticInitStorage = new AsyncLocalStorage();
 
@@ -503,6 +505,59 @@ function send(message) {
   process.stdout.write(`${JSON.stringify(message)}\n`);
 }
 
+let rootRequestSeq = 0;
+let rootRequestInFlight = false;
+let rootRequestTimer = null;
+let rootsSettled = false;
+const pendingRootRequests = new Map();
+const deferredToolCalls = [];
+
+function flushDeferredToolCalls() {
+  const pending = deferredToolCalls.splice(0);
+  for (const request of pending) {
+    void (async () => {
+      const response = await handleRequest(request);
+      if (response) {
+        send(response);
+      }
+    })();
+  }
+}
+
+function settleRoots() {
+  if (rootsSettled) {
+    return;
+  }
+  rootsSettled = true;
+  if (rootRequestTimer) {
+    clearTimeout(rootRequestTimer);
+    rootRequestTimer = null;
+  }
+  rootRequestInFlight = false;
+  pendingRootRequests.clear();
+  flushDeferredToolCalls();
+}
+
+function requestRoots() {
+  if (rootRequestInFlight || rootsSettled) {
+    return;
+  }
+  rootRequestInFlight = true;
+  const id = `argo-roots-${++rootRequestSeq}`;
+  rootRequestTimer = setTimeout(() => {
+    rootRequestTimer = null;
+    rootRequestInFlight = false;
+    settleRoots();
+  }, 8000);
+  pendingRootRequests.set(id, (result) => {
+    if (result && Array.isArray(result.roots)) {
+      setMcpWorkspaceRoots(result.roots);
+    }
+    settleRoots();
+  });
+  send({ jsonrpc: '2.0', id, method: 'roots/list', params: {} });
+}
+
 async function handleRequest(request, dependencies = undefined) {
   const { id, method, params } = request;
 
@@ -512,7 +567,7 @@ async function handleRequest(request, dependencies = undefined) {
       id,
       result: {
         protocolVersion: '2024-11-05',
-        capabilities: { tools: {} },
+        capabilities: { tools: {}, roots: { listChanged: true } },
         serverInfo: {
           name: 'argo',
           version: '1.0.0',
@@ -525,6 +580,14 @@ async function handleRequest(request, dependencies = undefined) {
     return null;
   }
 
+  if (method === 'notifications/roots/list_changed') {
+    setMcpWorkspaceRoots(params && params.roots);
+    if (params && Array.isArray(params.roots) && params.roots.length > 0) {
+      settleRoots();
+    }
+    return null;
+  }
+
   if (method === 'tools/list') {
     // Deduplicate tools by name — last writer wins.
     // Priority order: validatorMcp > systemArchitectureMcp > local TOOLS.
@@ -606,10 +669,32 @@ async function main() {
     } catch {
       continue;
     }
+
+    // A JSON-RPC message without a `method` is a response to a server-sent request.
+    if (typeof request.method === 'undefined' && request.id !== undefined) {
+      const resolver = pendingRootRequests.get(request.id);
+      if (resolver) {
+        pendingRootRequests.delete(request.id);
+        resolver(request.result);
+      }
+      continue;
+    }
+
+    // Workspace-dependent tool calls must wait for roots so the global server
+    // targets the current workspace instead of the home directory.
+    if (request.method === 'tools/call' && !hasStaticWorkspace() && !rootsSettled) {
+      deferredToolCalls.push(request);
+      continue;
+    }
+
     const response = await handleRequest(request);
     if (response) {
       send(response);
     }
+    if ((request.method === 'initialize' || request.method === 'notifications/initialized')
+      && !hasStaticWorkspace()) {
+      requestRoots();
+    }
   }
 }
 

package/argo/scripts/argo-paths.js

@@ -1,5 +1,6 @@
 const fs = require('node:fs');
 const path = require('node:path');
+const { fileURLToPath } = require('node:url');
 
 /**
  * Shared path resolution for the Argo toolchain.
@@ -17,10 +18,12 @@ const path = require('node:path');
  * The workspace root is resolved from, in priority order:
  *   1. ARGO_REPO_ROOT      — explicit override (set by MCP client configs).
  *   2. WORKSPACE_FOLDER    — set by some hosts.
- *   3. The embedded repo root, when the Argo installation is still inside a repo
+ *   3. The MCP `roots` advertised by the client (a global server resolves the
+ *      root that contains design/KG/SystemArchitecture.json when several roots
+ *      are present, so it never operates on an unrelated folder).
+ *   4. The embedded repo root, when the Argo installation is still inside a repo
  *      (i.e. `<argoRoot>/../design/KG/SystemArchitecture.json` exists).
- *   4. process.cwd()       — the MCP client must launch the server with its cwd
- *      set to the target workspace root.
+ *   5. process.cwd()       — last-resort fallback when no root is available.
  */
 
 function getArgoRoot() {
@@ -28,20 +31,71 @@ function getArgoRoot() {
   return path.resolve(__dirname, '..');
 }
 
+let mcpWorkspaceRoots = [];
+
+function setMcpWorkspaceRoots(roots) {
+  mcpWorkspaceRoots = Array.isArray(roots) ? roots : [];
+}
+
+function rootToPath(root) {
+  if (!root) {
+    return null;
+  }
+  const uri = typeof root === 'string' ? root : root.uri;
+  if (typeof uri !== 'string' || uri.trim() === '') {
+    return null;
+  }
+  if (uri.startsWith('file://')) {
+    try {
+      return fileURLToPath(uri);
+    } catch {
+      return null;
+    }
+  }
+  return uri;
+}
+
 function getWorkspaceRoot() {
   const explicit = process.env.ARGO_REPO_ROOT || process.env.WORKSPACE_FOLDER;
   if (explicit && String(explicit).trim() !== '') {
     return path.resolve(explicit);
   }
 
+  // The client may expose several roots (a multi-root workspace). Never
+  // silently operate on an unrelated folder: prefer the root that actually
+  // contains the ArchGraph marker before falling back to the first root.
+  const marker = path.join('design', 'KG', 'SystemArchitecture.json');
+  for (const root of mcpWorkspaceRoots) {
+    const rootPath = rootToPath(root);
+    if (rootPath && fs.existsSync(path.join(rootPath, marker))) {
+      return path.resolve(rootPath);
+    }
+  }
+
+  for (const root of mcpWorkspaceRoots) {
+    const rootPath = rootToPath(root);
+    if (rootPath) {
+      return path.resolve(rootPath);
+    }
+  }
+
   const embedded = path.resolve(getArgoRoot(), '..');
-  if (fs.existsSync(path.join(embedded, 'design', 'KG', 'SystemArchitecture.json'))) {
+  if (fs.existsSync(path.join(embedded, marker))) {
     return embedded;
   }
 
   return path.resolve(process.cwd());
 }
 
+function hasStaticWorkspace() {
+  const explicit = process.env.ARGO_REPO_ROOT || process.env.WORKSPACE_FOLDER;
+  if (explicit && String(explicit).trim() !== '') {
+    return true;
+  }
+  const embedded = path.resolve(getArgoRoot(), '..');
+  return fs.existsSync(path.join(embedded, 'design', 'KG', 'SystemArchitecture.json'));
+}
+
 function resolveArgoPath(...segments) {
   return path.resolve(getArgoRoot(), ...segments);
 }
@@ -71,7 +125,9 @@ module.exports = {
   getArgoRoot,
   getArgoEnvPath,
   getWorkspaceRoot,
+  hasStaticWorkspace,
   normalizeRelativePath,
   resolveArgoPath,
   resolveWorkspacePath,
+  setMcpWorkspaceRoots,
 };

package/install-argo.ps1

@@ -135,8 +135,6 @@ if ($SkipMcp) {
         type    = 'stdio'
         command = 'node'
         args    = @($argoServer)
-        cwd     = '${workspaceFolder}'
-        env     = [ordered]@{ ARGO_REPO_ROOT = '${workspaceFolder}' }
     }
 
     $config = [ordered]@{ servers = $servers }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {