archgraph-argo 0.9.6 → 0.9.8

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

@@ -18,6 +18,7 @@ const {
   getWorkspaceRoot,
   hasStaticWorkspace,
   resolveArgoPath,
+  resolveCallWorkspaceRoot,
   setMcpWorkspaceRoots,
 } = require('./argo-paths.js');
 const canonicalSemanticInitStorage = new AsyncLocalStorage();
@@ -304,6 +305,25 @@ const TOOLS = [
   },
 ];
 
+// Every tool accepts an optional per-call `workspaceRoot` (absolute path,
+// honored only when listed in ARGO_WORKSPACE_ROOTS). The DeepSeek Harness
+// bridge injects the current session's workspace directory here automatically.
+// (tools/list dedupes with systemArchitectureMcp/validatorMcp tools, which
+// carry the same field; this covers the local-only rows like initializeWorkspace.)
+const WORKSPACE_ROOT_PARAM = Object.freeze({
+  type: 'string',
+  description:
+    'Optional absolute workspace root for this call. Honored only when listed in ARGO_WORKSPACE_ROOTS; otherwise the server launch directory is used.',
+});
+for (const tool of TOOLS) {
+  const inputSchema = tool && tool.inputSchema;
+  if (inputSchema && inputSchema.type === 'object' && inputSchema.properties) {
+    if (!Object.prototype.hasOwnProperty.call(inputSchema.properties, 'workspaceRoot')) {
+      inputSchema.properties.workspaceRoot = WORKSPACE_ROOT_PARAM;
+    }
+  }
+}
+
 function intentElementContextInputSchema() {
   return {
     type: 'object',
@@ -374,14 +394,20 @@ function resolveWorkspaceRoot() {
   return getWorkspaceRoot();
 }
 
+function resolveWorkspaceRoot(args) {
+  // Per-call workspaceRoot override (honored only when in the
+  // ARGO_WORKSPACE_ROOTS allowlist); defaults to the launch-directory root.
+  return resolveCallWorkspaceRoot(args);
+}
+
 async function callTool(name, args = {}, progressToken = null, dependencies = undefined) {
-  loadRepositoryArgoEnvironment(resolveWorkspaceRoot());
+  loadRepositoryArgoEnvironment(resolveWorkspaceRoot(args));
   if (name === 'initializeWorkspace') {
-    const workspace = await initializeWorkspace(resolveWorkspaceRoot());
+    const workspace = await initializeWorkspace(resolveWorkspaceRoot(args));
     const composition = canonicalSemanticInitStorage.getStore()
       || systemArchitectureMcp.createDefaultCanonicalSemanticInitComposition();
     const semanticLifecycle = await runCanonicalSemanticInit(composition, {
-      repositoryRoot: resolveWorkspaceRoot(),
+      repositoryRoot: resolveWorkspaceRoot(args),
       workspace,
     });
     return toolResult({

package/argo/scripts/argo-paths.js

@@ -121,6 +121,48 @@ function normalizeRelativePath(value) {
   return String(value == null ? '' : value).replace(/\\/g, '/').replace(/^\/+/, '');
 }
 
+/**
+ * Resolve the workspace root for one tool call.
+ *
+ * Defaults to the launch-directory root (`getWorkspaceRoot()`). A per-call
+ * `workspaceRoot` argument (absolute path) is honored only when it appears in
+ * the `ARGO_WORKSPACE_ROOTS` allowlist (semicolon or comma separated absolute
+ * paths). Without an allowlist the override is ignored, so existing
+ * deployments keep launch-directory resolution with zero behavior change.
+ * This powers the DeepSeek Harness bridge, which injects the current session's
+ * workspace directory into every call so one dsh instance can follow the
+ * workspace the user switched to.
+ *
+ * @param {object} [args] - tool call arguments (may carry `workspaceRoot`).
+ * @returns {string} resolved absolute workspace root.
+ * @throws when the requested root is not in the allowlist.
+ */
+function resolveCallWorkspaceRoot(args = {}) {
+  const requested =
+    typeof args === 'object' && args !== null && typeof args.workspaceRoot === 'string'
+      ? String(args.workspaceRoot).trim()
+      : '';
+  if (requested === '') {
+    return getWorkspaceRoot();
+  }
+  const allowlist = (process.env.ARGO_WORKSPACE_ROOTS || '')
+    .split(/[;,]/)
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => path.resolve(entry));
+  if (allowlist.length === 0) {
+    return getWorkspaceRoot();
+  }
+  const resolved = path.resolve(requested);
+  const allowed = allowlist.some(
+    (root) => resolved === root || resolved.startsWith(root + path.sep),
+  );
+  if (!allowed) {
+    throw new Error(`workspaceRoot not in ARGO_WORKSPACE_ROOTS allowlist: ${requested}`);
+  }
+  return resolved;
+}
+
 module.exports = {
   getArgoRoot,
   getArgoEnvPath,
@@ -128,6 +170,7 @@ module.exports = {
   hasStaticWorkspace,
   normalizeRelativePath,
   resolveArgoPath,
+  resolveCallWorkspaceRoot,
   resolveWorkspacePath,
   setMcpWorkspaceRoots,
 };

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

@@ -5,7 +5,7 @@ const crypto = require('node:crypto');
 
 const {
   getArgoRoot,
-  getWorkspaceRoot,
+  resolveCallWorkspaceRoot,
 } = require('./argo-paths.js');
 
 const DEFAULT_GRAPH_PATH = 'design/KG/SystemArchitecture.json';
@@ -381,6 +381,23 @@ const TOOLS = [
   },
 ];
 
+// Every tool accepts an optional per-call `workspaceRoot` (absolute path,
+// honored only when listed in ARGO_WORKSPACE_ROOTS). The DeepSeek Harness
+// bridge injects the current session's workspace directory here automatically.
+const WORKSPACE_ROOT_PARAM = Object.freeze({
+  type: 'string',
+  description:
+    'Optional absolute workspace root for this call. Honored only when listed in ARGO_WORKSPACE_ROOTS; otherwise the server launch directory is used.',
+});
+for (const tool of TOOLS) {
+  const inputSchema = tool && tool.inputSchema;
+  if (inputSchema && inputSchema.type === 'object' && inputSchema.properties) {
+    if (!Object.prototype.hasOwnProperty.call(inputSchema.properties, 'workspaceRoot')) {
+      inputSchema.properties.workspaceRoot = WORKSPACE_ROOT_PARAM;
+    }
+  }
+}
+
 function intentElementContextInputSchema() {
   return {
     type: 'object',
@@ -448,13 +465,15 @@ function mutationInputSchema() {
   };
 }
 
-function resolveWorkspaceRoot() {
-  return getWorkspaceRoot();
+function resolveWorkspaceRoot(args) {
+  // Per-call workspaceRoot override (honored only when in the
+  // ARGO_WORKSPACE_ROOTS allowlist); defaults to the launch-directory root.
+  return resolveCallWorkspaceRoot(args);
 }
 
 function initializeWorkspace(request) {
   return require('./argo-mcp-server.js').initializeWorkspace(
-    request && request.repositoryRoot ? request.repositoryRoot : resolveWorkspaceRoot(),
+    request && request.repositoryRoot ? request.repositoryRoot : resolveWorkspaceRoot(request),
   );
 }
 
@@ -508,7 +527,7 @@ function readJson(filePath, label) {
 }
 
 async function loadContext(args = {}) {
-  const workspaceRoot = resolveWorkspaceRoot();
+  const workspaceRoot = resolveWorkspaceRoot(args);
   const graphPath = resolveWorkspacePath(workspaceRoot, args.architecturePath || DEFAULT_GRAPH_PATH);
   const schemaPath = resolveSchemaPath(workspaceRoot);
   const context = {

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

@@ -9,6 +9,7 @@ const execFileAsync = promisify(execFile);
 const {
   getArgoRoot,
   getWorkspaceRoot,
+  resolveCallWorkspaceRoot,
 } = require('./argo-paths.js');
 
 const HANDOFF_STAGES = ['intent-to-implementation', 'implementation-to-coding'];
@@ -85,8 +86,27 @@ const TOOLS = [
   },
 ];
 
-function resolveWorkspaceRoot() {
-  return getWorkspaceRoot();
+// Every tool accepts an optional per-call `workspaceRoot` (absolute path,
+// honored only when listed in ARGO_WORKSPACE_ROOTS). The DeepSeek Harness
+// bridge injects the current session's workspace directory here automatically.
+const WORKSPACE_ROOT_PARAM = Object.freeze({
+  type: 'string',
+  description:
+    'Optional absolute workspace root for this call. Honored only when listed in ARGO_WORKSPACE_ROOTS; otherwise the server launch directory is used.',
+});
+for (const tool of TOOLS) {
+  const inputSchema = tool && tool.inputSchema;
+  if (inputSchema && inputSchema.type === 'object' && inputSchema.properties) {
+    if (!Object.prototype.hasOwnProperty.call(inputSchema.properties, 'workspaceRoot')) {
+      inputSchema.properties.workspaceRoot = WORKSPACE_ROOT_PARAM;
+    }
+  }
+}
+
+function resolveWorkspaceRoot(args) {
+  // Per-call workspaceRoot override (honored only when in the
+  // ARGO_WORKSPACE_ROOTS allowlist); defaults to the launch-directory root.
+  return resolveCallWorkspaceRoot(args);
 }
 
 function resolveScriptPath(workspaceRoot, candidates) {
@@ -231,7 +251,7 @@ function toolResult(payload) {
 }
 
 async function callTool(name, args, progressToken = null) {
-  const workspaceRoot = resolveWorkspaceRoot();
+  const workspaceRoot = resolveWorkspaceRoot(args);
 
   if (name === 'validateSystemArchitecture') {
     return toolResult(await runValidatorScript(workspaceRoot, 'validateSystemArchitecture'));

package/install-argo.ps1

@@ -18,6 +18,8 @@ param(
     [switch]$SkipMcp,
     [switch]$SkipDsh,
     [string]$DshHome = "$env:USERPROFILE\.dsh",
+    [string]$DshCwd = '',
+    [string]$DshWorkspaces = '',
     [string]$McpPath
 )
 
@@ -264,44 +266,25 @@ function Get-WakeupGuideline {
 }
 
 function Write-DshAgentRule {
-    # Merge the frontmatter-stripped ArchGraph rule (plus a DSH adapter note
-    # explaining the mcp__argo__ tool prefix) into ~/.dsh/AGENTS.md, replacing
-    # the previous ArchGraph block while preserving surrounding user content.
+    # Merge the frontmatter-stripped ArchGraph rule into ~/.dsh/AGENTS.md,
+    # replacing the previous ArchGraph block while preserving surrounding user
+    # content. The rule body is injected verbatim - no adapter prose, so the
+    # working prompt stays identical to the Copilot / Cursor / OpenCode rules.
     param(
         [string]$DshHome,
         [string]$RuleText
     )
-    $adapterNote = @'
-# ArchGraph ARGO Workflow Rules (DeepSeek Harness edition)
-
-> Deployed by install-argo.ps1 from argo/rules/archgraph.instructions.md
-> (single source of truth; this file is a deployment artifact).
-> DeepSeek Harness injects ~/.dsh/AGENTS.md through dsh-agent-instructions as
-> user-global instructions; the file is injected verbatim, so the YAML
-> frontmatter of the source rule is stripped here.
-
-## DSH adapter note
-- The ARGO MCP server is registered under serverName "argo" through the
-  @deepseek-ai/dsh-mcp-client plugin; its tools are exposed to the model with
-  the mcp__argo__ prefix (e.g. mcp__argo__getSystemArchitecture). When a rule
-  below names a tool like getSystemArchitecture, call the mcp__argo__* form.
-- The argo-init skill is installed at ~/.dsh/skills/argo-init/SKILL.md and is
-  loadable through the harness skill tool.
-'@
-    $body = Get-MarkdownBody -Content $RuleText
-    $ruleContent = $adapterNote + "`n`n" + $body
+    $ruleContent = Get-MarkdownBody -Content $RuleText
     $dest = Join-Path $DshHome 'AGENTS.md'
-    $marker = 'ArchGraph ARGO Workflow Rules'
+    $marker = '<WakeupGuideline>'
     New-Item -ItemType Directory -Force -Path $DshHome | Out-Null
     if (Test-Path $dest) {
         $existing = Get-Content $dest -Raw -Encoding UTF8
         if ($existing -like "*$marker*") {
             $endTag = '</ToolsGuideline>'
-            $markerIdx = $existing.IndexOf($marker)
-            if ($markerIdx -lt 0) { $markerIdx = 0 }
-            $startIdx = $existing.LastIndexOf('# ArchGraph', $markerIdx)
+            $startIdx = $existing.IndexOf($marker)
             if ($startIdx -lt 0) { $startIdx = 0 }
-            $endIdx = $existing.IndexOf($endTag, $markerIdx)
+            $endIdx = $existing.IndexOf($endTag, $startIdx)
             $before = $existing.Substring(0, $startIdx).TrimEnd()
             if ($endIdx -lt 0) {
                 $combined = $before
@@ -398,6 +381,156 @@ export function apply(ctx) {
     return $indexPath
 }
 
+function New-DshWorkspaceBridge {
+    # Generate the DSH workspace bridge plugin under ~/.dsh/plugins. It
+    # connects directly to the argo MCP server (no dsh-mcp-client row needed)
+    # with a zero-dependency minimal MCP stdio client, registers every tool as
+    # mcp__argo__* and injects the current session's workspace directory
+    # (SessionHeader.cwd) as the per-call `workspaceRoot`, so ONE dsh instance
+    # follows whichever workspace the user switched to - no model-visible
+    # parameters, no internal tool names, no restart. The argo server honors
+    # workspaceRoot only when listed in ARGO_WORKSPACE_ROOTS (install-argo.ps1
+    # -DshWorkspaces).
+    param(
+        [string]$DshHome
+    )
+    $dir = Join-Path (Join-Path $DshHome 'plugins') 'dsh-argo-workspace'
+    New-Item -ItemType Directory -Force -Path $dir | Out-Null
+    $plugin = @'
+// dsh-argo-workspace - generated by install-argo.ps1 (single source of truth:
+// the installer; this file is a deployment artifact, do not edit by hand).
+//
+// Direct MCP bridge to the argo server for DeepSeek Harness. Registers every
+// argo tool as mcp__argo__* and injects the current session's workspace
+// directory (SessionHeader.cwd) as the per-call `workspaceRoot` argument, so
+// one dsh instance follows whichever workspace the user switched to - the
+// model sees no extra parameters and no internal tool names. The argo server
+// honors workspaceRoot only when the workspace is listed in its
+// ARGO_WORKSPACE_ROOTS allowlist.
+//
+// Zero dependencies on purpose: implements the minimal MCP stdio client
+// (JSON-RPC 2.0, one JSON object per line) with Node built-ins only, so the
+// plugin runs from any DSH layout without resolving @modelcontextprotocol/sdk.
+import { spawn } from 'node:child_process'
+import readline from 'node:readline'
+
+export const name = 'dsh-argo-workspace'
+export const inject = ['tools']
+
+/** Minimal MCP stdio client over the argo server process. */
+function createArgoClient(serverPath, env, cwd) {
+  const child = spawn('node', [serverPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env,
+    ...(cwd ? { cwd } : {}),
+  })
+  const pending = new Map()
+  let nextId = 1
+  readline.createInterface({ input: child.stdout }).on('line', (line) => {
+    let message
+    try { message = JSON.parse(line) } catch { return }
+    if (message && typeof message.id === 'number' && pending.has(message.id)) {
+      const { resolve, reject } = pending.get(message.id)
+      pending.delete(message.id)
+      if (message.error) reject(new Error(JSON.stringify(message.error)))
+      else resolve(message.result)
+    }
+  })
+  child.stderr.on('data', () => {}) // drain; the argo server logs to stderr
+  const request = (method, params) => new Promise((resolve, reject) => {
+    const id = nextId++
+    pending.set(id, { resolve, reject })
+    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n')
+  })
+  return {
+    request,
+    notify: (method, params) => {
+      child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n')
+    },
+    close: () => child.kill(),
+  }
+}
+
+/** Connect, list tools, register them, and keep the client until disposal. */
+export async function apply(ctx, config) {
+  const serverPath = config.serverPath
+  const workspaces = Array.isArray(config.workspaces) ? config.workspaces : []
+  const env = { ...process.env }
+  if (workspaces.length > 0) env.ARGO_WORKSPACE_ROOTS = workspaces.join(';')
+  const client = createArgoClient(serverPath, env, config.cwd)
+  ctx.effect(() => () => client.close(), 'dsh-argo-workspace.dispose()')
+
+  let tools = []
+  try {
+    await client.request('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'dsh-argo-workspace', version: '0.1.0' },
+    })
+    client.notify('notifications/initialized', {})
+    const listed = await client.request('tools/list', {})
+    tools = (listed && Array.isArray(listed.tools)) ? listed.tools : []
+  } catch (error) {
+    console.warn(`[dsh-argo-workspace] failed to connect to the argo MCP server (${serverPath}): ${error && error.message ? error.message : error}`)
+    return
+  }
+
+  const disposers = []
+  for (const tool of tools) {
+    const publicName = 'mcp__argo__' + tool.name
+    disposers.push(ctx.tools.register({
+      name: publicName,
+      description: tool.description ?? '',
+      parameters: tool.inputSchema,
+      output: {
+        schema: {
+          type: 'object',
+          properties: { content: { type: 'array', items: {} } },
+          required: ['content'],
+          additionalProperties: false,
+        },
+      },
+      execute: async (args, exec) => {
+        const sessionCwd = exec && exec.agent && exec.agent.session
+          ? exec.agent.session.requestHeader().cwd
+          : undefined
+        const injected = { ...(args && typeof args === 'object' ? args : {}) }
+        if (typeof sessionCwd === 'string' && sessionCwd !== '') {
+          injected.workspaceRoot = sessionCwd
+        }
+        if (exec && exec.signal && exec.signal.aborted) {
+          throw new Error('aborted')
+        }
+        const result = await client.request('tools/call', {
+          name: tool.name,
+          arguments: injected,
+        })
+        const text = Array.isArray(result.content)
+          ? result.content
+              .map((block) => block && block.type === 'text' && typeof block.text === 'string'
+                ? block.text
+                : JSON.stringify(block))
+              .join('\n')
+          : (result.toolResult !== undefined ? JSON.stringify(result.toolResult) : '(no output)')
+        if (result.isError === true) throw new Error(text)
+        return {
+          content: [{ type: 'text', text }],
+          ...(result.structuredContent !== undefined ? { structuredContent: result.structuredContent } : {}),
+        }
+      },
+    }))
+  }
+  ctx.effect(() => () => {
+    for (const dispose of disposers) dispose()
+  }, 'dsh-argo-workspace.tools')
+}
+'@
+    $indexPath = Join-Path $dir 'index.js'
+    [System.IO.File]::WriteAllText($indexPath, $plugin, (New-Object System.Text.UTF8Encoding $false))
+    Write-Host "  DSH workspace bridge generated -> $indexPath"
+    return $indexPath
+}
+
 function New-DshAgentPresets {
     # Generate DSH agent presets under ~/.dsh/.agent-presets/<id>/ from
     # argo/agents/*.agent.md (the same single source the Copilot / Cursor /
@@ -557,20 +690,52 @@ if ($SkipDsh) {
     Write-Host "[17/19] argo\rules\<WakeupGuideline> -> $DshHome\plugins\dsh-argo-wakeup\index.js (DeepSeek Harness wakeup plugin)"
     $wakeupDshPath = New-DshWakeupPlugin -DshHome $DshHome -RuleText $ruleSrcContent
 
-    Write-Host "[18/19] mcp-argo + argo-wakeup rows -> $patchPath (DeepSeek Harness MCP + wakeup plugin)"
-    $rows = "  - id: mcp-argo`n    name: '@deepseek-ai/dsh-mcp-client'`n    config:`n      serverName: argo`n      transport: stdio`n      command: node`n      args:`n        - $argoServer`n"
+    Write-Host "[18/19] argo-workspace + argo-wakeup rows -> $patchPath (DeepSeek Harness MCP bridge + wakeup plugin)"
+    # The generated dsh-argo-workspace bridge connects directly to the argo
+    # server (no dsh-mcp-client row), registers every tool as mcp__argo__* and
+    # injects the current session's workspace (SessionHeader.cwd) as the
+    # per-call workspaceRoot, so one dsh instance follows the workspace the
+    # user switched to. The server honors workspaceRoot only when the workspace
+    # is listed in ARGO_WORKSPACE_ROOTS (pass -DshWorkspaces "D:/a;D:/b").
+    $bridgeDshPath = New-DshWorkspaceBridge -DshHome $DshHome
+    if ($bridgeDshPath) {
+        $bridgeUrl = 'file:///' + (($bridgeDshPath -replace '\\', '/').TrimStart('/'))
+        $bridgeConfig = "    config:`n      serverPath: '$argoServer'`n"
+        if ($DshWorkspaces) {
+            $wsList = @($DshWorkspaces.Replace('\', '/').Split(';') | ForEach-Object { "        - $_" }) -join "`n"
+            $bridgeConfig += "      workspaces:`n" + $wsList + "`n"
+        }
+        if ($DshCwd) {
+            $bridgeConfig += "      cwd: $($DshCwd.Replace('\', '/'))`n"
+        }
+        $rows = "  - id: argo-workspace`n    name: '$bridgeUrl'`n" + $bridgeConfig
+    } else {
+        $rows = ''
+    }
     if ($wakeupDshPath) {
         $pluginUrl = 'file:///' + (($wakeupDshPath -replace '\\', '/').TrimStart('/'))
         $rows += "  - id: argo-wakeup`n    name: '$pluginUrl'`n"
     }
-    $block = "# BEGIN ArchGraph ARGO deployment (managed by install-argo.ps1)`n- insert:`n" + $rows + "# END ArchGraph ARGO deployment"
-    Write-DshManagedBlock -Path $patchPath -Block $block -MarkerStart '# BEGIN ArchGraph ARGO deployment' -MarkerEnd '# END ArchGraph ARGO deployment'
+    if ($rows) {
+        $block = "# BEGIN ArchGraph ARGO deployment (managed by install-argo.ps1)`n- insert:`n" + $rows + "# END ArchGraph ARGO deployment"
+        Write-DshManagedBlock -Path $patchPath -Block $block -MarkerStart '# BEGIN ArchGraph ARGO deployment' -MarkerEnd '# END ArchGraph ARGO deployment'
+    }
 
     Write-Host "[19/19] argo\agents -> $DshHome\.agent-presets\<id> (DeepSeek Harness agent presets)"
     New-DshAgentPresets -DshHome $DshHome -AgentsSrc (Join-Path $argoDir 'agents')
 
-    Write-Host '  Restart `dsh web` to activate the MCP server and the wakeup plugin;'
+    Write-Host '  Restart `dsh web` to activate the MCP bridge and the wakeup plugin;'
     Write-Host '  new sessions pick up the global rule and the argo-init skill automatically.'
+    if ($DshWorkspaces) {
+        Write-Host "  Workspace following enabled: ARGO_WORKSPACE_ROOTS=$DshWorkspaces"
+        Write-Host '  The argo tools (mcp__argo__*) now auto-follow the workspace the user switched to'
+        Write-Host '  in one dsh instance - no restart needed between workspaces.'
+    } else {
+        Write-Host '  Multi-workspace: to let one dsh instance follow whichever workspace the user'
+        Write-Host '  switches to, re-run with -DshWorkspaces "D:/proj-a;D:/proj-b" (the argo server'
+        Write-Host '  only honors workspaces listed in ARGO_WORKSPACE_ROOTS). Without it the server'
+        Write-Host '  keeps resolving from the directory dsh was launched from.'
+    }
 }
 
 if ($SkipDeps) {

package/package.json

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