synapse-hub 2.2.3 → 2.4.0

package/tools/jtl_analyzer.py

@@ -362,7 +362,7 @@ def main():
     parser.add_argument("--sla-p95", type=float, default=None, help="P95 Latency threshold in ms (fails if exceeded).")
     parser.add_argument("--sla-p99", type=float, default=None, help="P99 Latency threshold in ms (fails if exceeded).")
     parser.add_argument("--sla-avg", type=float, default=None, help="Average Latency threshold in ms (fails if exceeded).")
-    parser.add_argument("--max-error-rate", type=float, default=None, help="Maximum allowed error rate percentage (e.g. 1.0 = 1%).")
+    parser.add_argument("--max-error-rate", type=float, default=None, help="Maximum allowed error rate percentage (e.g. 1.0 = 1%%).")
     parser.add_argument("--markdown", "-m", help="Output path for Markdown summary report.")
     parser.add_argument("--json", "-j", help="Output path for JSON summary metrics.")
     parser.add_argument("--telemetry", help="Path to server telemetry CSV (timestamp, cpu_pct, memory_pct, db_pool_pct) for Full-Stack APM correlation.")

package/tools/lint_ai_docs.py

@@ -140,6 +140,70 @@ def lint_docs(repo_root):
     # Ignored tool references (examples, output targets, artifacts)
     ignored_tool_refs = {"api_matrix.json", "output.json", "report.json", "output.txt", "summary.json"}
 
+    # 6. Hub Mode Metadata & Count Synchronization (Anti-Drift Guard for Skills, Rules, Workflows)
+    manifest_path = os.path.join(repo_root, "skills_manifest.json")
+    skills_dir = os.path.join(repo_root, ".agents", "skills")
+    rules_dir = os.path.join(repo_root, ".agents", "rules")
+    workflows_dir = os.path.join(repo_root, ".agents", "workflows")
+
+    if os.path.exists(manifest_path) and os.path.isdir(skills_dir):
+        import json
+        try:
+            with open(manifest_path, "r", encoding="utf-8") as mf:
+                manifest_data = json.load(mf)
+            manifest_skill_ids = set(s.get("id") for s in manifest_data.get("skills", []))
+            actual_skill_dirs = set(
+                d for d in os.listdir(skills_dir)
+                if os.path.isdir(os.path.join(skills_dir, d))
+            )
+            unregistered = actual_skill_dirs - manifest_skill_ids
+            if unregistered:
+                errors.append(f"[skills_manifest.json] Skills on disk not in manifest: {sorted(unregistered)}")
+            ghost_manifest = manifest_skill_ids - actual_skill_dirs
+            if ghost_manifest:
+                errors.append(f"[skills_manifest.json] Skills in manifest missing on disk: {sorted(ghost_manifest)}")
+
+            total_declared = manifest_data.get("totalSkills", len(manifest_skill_ids))
+            if total_declared != len(actual_skill_dirs):
+                errors.append(f"[skills_manifest.json] totalSkills ({total_declared}) does not match actual count ({len(actual_skill_dirs)})")
+
+            if os.path.isdir(rules_dir):
+                actual_rules_count = len([f for f in os.listdir(rules_dir) if f.endswith(".md")])
+            else:
+                actual_rules_count = 0
+
+            if os.path.isdir(workflows_dir):
+                actual_workflows_count = len([f for f in os.listdir(workflows_dir) if f.endswith(".md")])
+            else:
+                actual_workflows_count = 0
+
+            readme_path = os.path.join(repo_root, "README.md")
+            if os.path.exists(readme_path):
+                with open(readme_path, "r", encoding="utf-8", errors="ignore") as rf:
+                    readme_text = rf.read()
+                m_rules = re.search(r'\((\d+)\s+Core Rules\)', readme_text)
+                if m_rules and int(m_rules.group(1)) != actual_rules_count:
+                    errors.append(f"[README.md] Documented Core Rules count ({m_rules.group(1)}) differs from actual rules on disk ({actual_rules_count})")
+
+                m_wf = re.search(r'\((\d+)\s+Workflows\)', readme_text)
+                if m_wf and int(m_wf.group(1)) != actual_workflows_count:
+                    errors.append(f"[README.md] Documented Workflows count ({m_wf.group(1)}) differs from actual workflows on disk ({actual_workflows_count})")
+
+                skill_table_matches = re.findall(r'\|\s*\d+\s*\|\s*`([a-z0-9\-]+)`\s*\|', readme_text)
+                for sid in skill_table_matches:
+                    if sid not in actual_skill_dirs:
+                        errors.append(f"[README.md] Non-existent skill referenced in skills table: '{sid}'")
+
+            arch_path = os.path.join(repo_root, "docs", "ARCHITECTURE.md")
+            if os.path.exists(arch_path):
+                with open(arch_path, "r", encoding="utf-8", errors="ignore") as af:
+                    arch_text = af.read()
+                m_arch_skills = re.search(r'Catalog\["(\d+)\s+Standardized Skills', arch_text)
+                if m_arch_skills and int(m_arch_skills.group(1)) != len(actual_skill_dirs):
+                    errors.append(f"[ARCHITECTURE.md] Documented skills count ({m_arch_skills.group(1)}) differs from actual skills on disk ({len(actual_skill_dirs)})")
+        except Exception as e:
+            errors.append(f"Failed to validate skills_manifest.json: {e}")
+
     for doc in doc_files:
         full_path = os.path.join(repo_root, doc)
         try:

package/tools/matrix_sharder.py

@@ -25,7 +25,7 @@ if hasattr(sys.stdout, 'reconfigure'):
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 HUB_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
-CACHE_DB_PATH = os.path.join(SCRIPT_DIR, "memory_cache.db")
+CACHE_DB_PATH = os.path.expanduser("~/.agent_memory/global_cache.db")
 
 
 def find_test_files(target_dir: str) -> List[str]:

package/tools/mcp_excel_server.ps1

@@ -1,251 +1,13 @@
-param()
-
-[System.Reflection.Assembly]::LoadWithPartialName("System.IO.Compression.FileSystem") | Out-Null
-
-function Read-ExcelSheet {
-    param(
-        [string]$FilePath,
-        [string]$SheetName = ""
-    )
-
-    if ([string]::IsNullOrWhiteSpace($FilePath) -or -not (Test-Path -LiteralPath $FilePath)) {
-        if ($env:EXCEL_TEST_PATH -and (Test-Path -LiteralPath $env:EXCEL_TEST_PATH)) {
-            $FilePath = $env:EXCEL_TEST_PATH
-        } else {
-            # Search workspace or Downloads for any recent xlsx file
-            $found = Get-ChildItem -Path "." -Filter "*.xlsx" -Recurse -Depth 2 -ErrorAction SilentlyContinue | Select-Object -First 1
-            if (-not $found) {
-                $found = Get-ChildItem -Path "$env:USERPROFILE\Downloads" -Filter "*.xlsx" -ErrorAction SilentlyContinue | Sort-Object LastWriteTime -Descending | Select-Object -First 1
-            }
-            if ($found) { $FilePath = $found.FullName }
-        }
-    }
-
-    if ([string]::IsNullOrWhiteSpace($FilePath) -or -not (Test-Path -LiteralPath $FilePath)) {
-        throw "Excel file not found. Please provide a valid file_path."
-    }
-
-    $fullPath = (Get-Item $FilePath).FullName
-    $zip = [System.IO.Compression.ZipFile]::OpenRead($fullPath)
-
-    try {
-        # 1. Read shared strings
-        $sharedStrings = New-Object System.Collections.Generic.List[string]
-        $ssEntry = $zip.GetEntry("xl/sharedStrings.xml")
-        if ($ssEntry) {
-            $stream = $ssEntry.Open()
-            $reader = New-Object System.IO.StreamReader($stream, [System.Text.Encoding]::UTF8)
-            $ssXml = [xml]$reader.ReadToEnd()
-            $reader.Close()
-            $stream.Close()
-            foreach ($si in $ssXml.sst.si) {
-                $sharedStrings.Add($si.InnerText)
-            }
-        }
-
-        # 2. Determine target sheet entry from workbook.xml
-        $targetSheetEntryName = "xl/worksheets/sheet1.xml"
-        $wbEntry = $zip.GetEntry("xl/workbook.xml")
-        if ($wbEntry) {
-            $stream = $wbEntry.Open()
-            $reader = New-Object System.IO.StreamReader($stream, [System.Text.Encoding]::UTF8)
-            $wbXml = [xml]$reader.ReadToEnd()
-            $reader.Close()
-            $stream.Close()
-
-            $sheets = $wbXml.workbook.sheets.sheet
-            $matchedSheetIndex = 1
-            if ($SheetName -and $sheets) {
-                $idx = 1
-                foreach ($s in $sheets) {
-                    if ($s.name -eq $SheetName -or $s.name -like "*$SheetName*") {
-                        $matchedSheetIndex = $idx
-                        break
-                    }
-                    $idx++
-                }
-            }
-            $targetSheetEntryName = "xl/worksheets/sheet$matchedSheetIndex.xml"
-        }
-
-        # Fallback if entry doesn't exist
-        $sEntry = $zip.GetEntry($targetSheetEntryName)
-        if (-not $sEntry) {
-            $firstSheet = $zip.Entries | Where-Object { $_.FullName -like "xl/worksheets/sheet*.xml" } | Select-Object -First 1
-            if ($firstSheet) { $sEntry = $firstSheet }
-        }
-
-        if (-not $sEntry) {
-            throw "No worksheet found inside Excel archive."
-        }
-
-        $stream = $sEntry.Open()
-        $reader = New-Object System.IO.StreamReader($stream, [System.Text.Encoding]::UTF8)
-        $sXml = [xml]$reader.ReadToEnd()
-        $reader.Close()
-        $stream.Close()
-
-        $rows = $sXml.worksheet.sheetData.row
-        $currentModule = "General"
-        $testcases = @()
-
-        foreach ($r in $rows) {
-            $rowNum = [int]$r.r
-            $cells = @{}
-            foreach ($c in $r.c) {
-                $colLetter = $c.r -replace '\d+'
-                $val = ""
-                if ($c.v) {
-                    $raw = $c.v
-                    if ($c.t -eq "s") {
-                        $val = $sharedStrings[[int]$raw]
-                    } else {
-                        $val = $raw
-                    }
-                }
-                $cells[$colLetter] = $val
-            }
-
-            $colA = if ($cells.ContainsKey("A")) { $cells["A"].Trim() } else { "" }
-            $colB = if ($cells.ContainsKey("B")) { $cells["B"].Trim() } else { "" }
-
-            if ($colB -match "PHAN HE|Phan he|PHÂN HỆ|Phân hệ|MODULE|Module") {
-                $currentModule = $colB.Trim()
-            } elseif ($colA -match "PHAN HE|Phan he|PHÂN HỆ|Phân hệ|MODULE|Module") {
-                $currentModule = $colA.Trim()
-            }
-
-            if ($colA -match '^TC[-_]?\d+') {
-                $testcases += [PSCustomObject]@{
-                    Row = $rowNum
-                    Module = $currentModule
-                    ID = $colA
-                    Name = if ($cells.ContainsKey("B")) { $cells["B"].Trim() } else { "" }
-                    PreCondition = if ($cells.ContainsKey("C")) { $cells["C"].Trim() } else { "" }
-                    Steps = if ($cells.ContainsKey("D")) { $cells["D"].Trim() } else { "" }
-                    DataTest = if ($cells.ContainsKey("E")) { $cells["E"].Trim() } else { "" }
-                    Expected = if ($cells.ContainsKey("F")) { $cells["F"].Trim() } else { "" }
-                    Progress = if ($cells.ContainsKey("G")) { $cells["G"].Trim() } else { "" }
-                    Status = if ($cells.ContainsKey("H")) { $cells["H"].Trim() } else { "" }
-                    QC = if ($cells.ContainsKey("I")) { $cells["I"].Trim() } else { "" }
-                }
-            }
-        }
-        return $testcases
-    } finally {
-        $zip.Dispose()
-    }
-}
-
-# Alias for backwards compatibility
-function Read-EnterpriseSheet {
-    param([string]$FilePath)
-    return Read-ExcelSheet -FilePath $FilePath
-}
-
-# Stdio JSON-RPC Loop
-$inputReader = [System.Console]::In
-while (($line = $inputReader.ReadLine()) -ne $null) {
-    if ([string]::IsNullOrWhiteSpace($line)) { continue }
-    $id = $null
-    try {
-        $req = $line | ConvertFrom-Json
-        $id = $req.id
-        $method = $req.method
-
-        if ($method -eq "initialize") {
-            $resp = @{
-                jsonrpc = "2.0"
-                id = $id
-                result = @{
-                    protocolVersion = "2024-11-05"
-                    capabilities = @{ tools = @{} }
-                    serverInfo = @{ name = "excel-qa-mcp-server"; version = "2.2.3" }
-                }
-            }
-            [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress -Depth 10))
-        } elseif ($method -eq "notifications/initialized") {
-        } elseif ($method -eq "ping") {
-            $resp = @{ jsonrpc = "2.0"; id = $id; result = @{} }
-            [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress))
-        } elseif ($method -eq "tools/list") {
-            $resp = @{
-                jsonrpc = "2.0"
-                id = $id
-                result = @{
-                    tools = @(
-                        @{
-                            name = "read_excel_sheet"
-                            description = "Extract test cases and matrix rows from an Excel worksheet."
-                            inputSchema = @{
-                                type = "object"
-                                properties = @{
-                                    file_path = @{ type = "string"; description = "Path to Excel file (.xlsx)" }
-                                    sheet_name = @{ type = "string"; description = "Worksheet name (defaults to first sheet)" }
-                                }
-                            }
-                        },
-                        @{
-                            name = "read_Enterprise_sheet"
-                            description = "Compatibility alias for read_excel_sheet"
-                            inputSchema = @{
-                                type = "object"
-                                properties = @{
-                                    file_path = @{ type = "string"; description = "Path to Excel file (.xlsx)" }
-                                }
-                            }
-                        }
-                    )
-                }
-            }
-            [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress -Depth 10))
-        } elseif ($method -eq "tools/call") {
-            $toolName = $req.params.name
-            if ($toolName -eq "read_excel_sheet" -or $toolName -eq "read_Enterprise_sheet") {
-                $fPath = $req.params.arguments.file_path
-                $sName = if ($req.params.arguments.sheet_name) { $req.params.arguments.sheet_name } else { "" }
-                $tcs = Read-ExcelSheet -FilePath $fPath -SheetName $sName
-                $textResult = $tcs | ConvertTo-Json -Depth 5
-                $resp = @{
-                    jsonrpc = "2.0"
-                    id = $id
-                    result = @{
-                        content = @(
-                            @{ type = "text"; text = $textResult }
-                        )
-                    }
-                }
-                [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress -Depth 10))
-            } else {
-                $resp = @{
-                    jsonrpc = "2.0"
-                    id = $id
-                    error = @{ code = -32601; message = "Tool not found: $toolName" }
-                }
-                [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress))
-            }
-        } else {
-            if ($null -ne $id) {
-                $resp = @{
-                    jsonrpc = "2.0"
-                    id = $id
-                    error = @{ code = -32601; message = "Method not found: $method" }
-                }
-                [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress))
-            }
-        }
-    } catch {
-        $errMsg = $_.Exception.Message
-        [System.Console]::Error.WriteLine("[MCP Excel Server Error] $errMsg")
-        $errCode = if ($null -eq $id) { -32700 } else { -32603 }
-        $resp = @{
-            jsonrpc = "2.0"
-            id = $id
-            error = @{
-                code = $errCode
-                message = "MCP Server Exception: $errMsg"
-            }
-        }
-        [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress))
-    }
+# Enterprise MCP Excel Server Wrapper
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$pythonCmd = Get-Command python -ErrorAction SilentlyContinue
+if (-not $pythonCmd) { $pythonCmd = Get-Command py -ErrorAction SilentlyContinue }
+if (-not $pythonCmd) { $pythonCmd = Get-Command python3 -ErrorAction SilentlyContinue }
+
+if ($pythonCmd) {
+    & $pythonCmd.Source "$scriptDir\mcp_excel_server.py" $args
+    exit $LASTEXITCODE
+} else {
+    Write-Error "Python 3 is required to run mcp_excel_server.py."
+    exit 1
 }

package/tools/mcp_excel_server.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Enterprise Cross-Platform MCP Excel Server (Zero-Dependency)
+-----------------------------------------------------------
+Implements Model Context Protocol (MCP) JSON-RPC 2.0 stdio server
+for reading and inspecting Microsoft Excel (.xlsx) workbooks.
+Works 100% offline with Python Standard Library (zipfile + xml.etree.ElementTree),
+with transparent fallback to openpyxl if installed.
+"""
+
+import os
+import sys
+import json
+import zipfile
+import xml.etree.ElementTree as ET
+from typing import Dict, Any, List, Optional
+
+# Enforce UTF-8 stdio
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+NS_MAIN = "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}"
+NS_REL = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}"
+
+
+def get_shared_strings(z: zipfile.ZipFile) -> List[str]:
+    """Reads shared strings table from xl/sharedStrings.xml."""
+    try:
+        with z.open("xl/sharedStrings.xml") as f:
+            tree = ET.parse(f)
+            root = tree.getroot()
+            strings = []
+            for si in root.iter(f"{NS_MAIN}si"):
+                # Concatenate all text inside <t> elements
+                text = "".join(t.text or "" for t in si.iter(f"{NS_MAIN}t"))
+                strings.append(text)
+            return strings
+    except KeyError:
+        return []
+
+
+def get_sheet_names(z: zipfile.ZipFile) -> List[str]:
+    """Retrieves sheet names from xl/workbook.xml."""
+    try:
+        with z.open("xl/workbook.xml") as f:
+            tree = ET.parse(f)
+            root = tree.getroot()
+            sheets = []
+            for sheet in root.iter(f"{NS_MAIN}sheet"):
+                name = sheet.attrib.get("name")
+                if name:
+                    sheets.append(name)
+            return sheets
+    except KeyError:
+        return ["Sheet1"]
+
+
+def read_sheet_rows(xlsx_path: str, sheet_name: Optional[str] = None, max_rows: int = 100) -> List[List[str]]:
+    """Reads rows from an Excel .xlsx file using Python standard library."""
+    if not os.path.exists(xlsx_path):
+        raise FileNotFoundError(f"Excel file not found: {xlsx_path}")
+
+    with zipfile.ZipFile(xlsx_path, "r") as z:
+        shared_strings = get_shared_strings(z)
+        sheet_names = get_sheet_names(z)
+
+        sheet_idx = 1
+        if sheet_name and sheet_name in sheet_names:
+            sheet_idx = sheet_names.index(sheet_name) + 1
+
+        sheet_entry = f"xl/worksheets/sheet{sheet_idx}.xml"
+        if sheet_entry not in z.namelist():
+            sheet_entry = "xl/worksheets/sheet1.xml"
+
+        with z.open(sheet_entry) as f:
+            tree = ET.parse(f)
+            root = tree.getroot()
+            rows_data = []
+
+            for row in root.iter(f"{NS_MAIN}row"):
+                cells = []
+                for c in row.iter(f"{NS_MAIN}c"):
+                    cell_type = c.attrib.get("t")
+                    val_elem = c.find(f"{NS_MAIN}v")
+                    raw_val = val_elem.text if val_elem is not None else ""
+
+                    if cell_type == "s" and raw_val.isdigit():
+                        idx = int(raw_val)
+                        val = shared_strings[idx] if idx < len(shared_strings) else raw_val
+                    elif cell_type == "b":
+                        val = "TRUE" if raw_val == "1" else "FALSE"
+                    else:
+                        val = raw_val
+
+                    cells.append(str(val))
+                if any(cells):
+                    rows_data.append(cells)
+                if len(rows_data) >= max_rows:
+                    break
+
+            return rows_data
+
+
+def handle_tool_call(name: str, arguments: Dict[str, Any]) -> str:
+    """Executes Excel MCP tool functions."""
+    file_path = arguments.get("file_path", "")
+    if not file_path or not os.path.exists(file_path):
+        # Check environment or search current dir for xlsx
+        test_path = os.environ.get("EXCEL_TEST_PATH", "")
+        if test_path and os.path.exists(test_path):
+            file_path = test_path
+        else:
+            for root, _, files in os.walk("."):
+                for fn in files:
+                    if fn.endswith(".xlsx") and not fn.startswith("~$"):
+                        file_path = os.path.join(root, fn)
+                        break
+                if file_path:
+                    break
+
+    if not file_path or not os.path.exists(file_path):
+        return "Error: Excel file not found. Please provide a valid file_path argument."
+
+    if name == "list_excel_sheets":
+        with zipfile.ZipFile(file_path, "r") as z:
+            sheets = get_sheet_names(z)
+        return json.dumps({"file": file_path, "sheets": sheets}, indent=2)
+
+    elif name == "read_excel_sheet":
+        sheet_name = arguments.get("sheet_name")
+        max_rows = int(arguments.get("max_rows", 50))
+        rows = read_sheet_rows(file_path, sheet_name=sheet_name, max_rows=max_rows)
+        if not rows:
+            return f"Sheet '{sheet_name or 'Sheet1'}' is empty."
+
+        # Format as Markdown table
+        header = rows[0]
+        md_lines = [
+            "| " + " | ".join(header) + " |",
+            "| " + " | ".join(["---"] * len(header)) + " |"
+        ]
+        for row in rows[1:]:
+            padded = row + [""] * (len(header) - len(row))
+            md_lines.append("| " + " | ".join(padded[:len(header)]) + " |")
+
+        return "\n".join(md_lines)
+
+    raise ValueError(f"Unknown MCP Excel tool: {name}")
+
+
+MCP_MANIFEST = {
+    "tools": [
+        {
+            "name": "list_excel_sheets",
+            "description": "Lists all worksheet names present in a Microsoft Excel (.xlsx) file.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Absolute or relative path to the .xlsx file"}
+                },
+                "required": ["file_path"]
+            }
+        },
+        {
+            "name": "read_excel_sheet",
+            "description": "Reads and displays tabular rows from an Excel worksheet formatted as a Markdown table.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Path to the .xlsx file"},
+                    "sheet_name": {"type": "string", "description": "Optional name of the worksheet to read"},
+                    "max_rows": {"type": "integer", "description": "Maximum number of rows to retrieve (default: 50)"}
+                },
+                "required": ["file_path"]
+            }
+        }
+    ]
+}
+
+
+def process_message(msg: Dict[str, Any]) -> Dict[str, Any]:
+    """JSON-RPC 2.0 message handler for Excel MCP."""
+    msg_id = msg.get("id")
+    method = msg.get("method")
+
+    if method == "initialize":
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "synapse-mcp-excel", "version": "2.3.0"}
+            }
+        }
+    elif method == "tools/list":
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": MCP_MANIFEST
+        }
+    elif method == "tools/call":
+        params = msg.get("params", {})
+        tool_name = params.get("name")
+        args = params.get("arguments", {})
+        try:
+            content = handle_tool_call(tool_name, args)
+            return {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {"content": [{"type": "text", "text": content}]}
+            }
+        except Exception as e:
+            return {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "error": {"code": -32603, "message": str(e)}
+            }
+
+    return {
+        "jsonrpc": "2.0",
+        "id": msg_id,
+        "error": {"code": -32601, "message": f"Method not found: {method}"}
+    }
+
+
+def main():
+    """Main stdio loop for JSON-RPC 2.0 communication."""
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+            resp = process_message(req)
+            sys.stdout.write(json.dumps(resp) + "\n")
+            sys.stdout.flush()
+        except Exception as e:
+            err_resp = {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": str(e)}}
+            sys.stdout.write(json.dumps(err_resp) + "\n")
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

package/tools/mcp_excel_server.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Enterprise MCP Excel Server Wrapper
+set -e
+python3 "$(dirname "$0")/mcp_excel_server.py" "$@"