mcp-win-stdio-arch 0.3.0__tar.gz

mcp_win_stdio_arch-0.3.0/.gitignore

@@ -0,0 +1,63 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+*.manifest
+*.spec
+api.txt
+pypi-api.txt
+
+
+pip-log.txt
+pip-delete-this-directory.txt
+pypi api.txt
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+*.mo
+*.pot
+
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+.idea/
+.vscode/
+*.swp
+*.swo
+
+*.log

mcp_win_stdio_arch-0.3.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.5
+Name: mcp-win-stdio-arch
+Version: 0.3.0
+Summary: Universal Architecture Knowledge Graph & Blueprint Model Context Protocol (MCP) server for full-stack codebases (Next.js, NestJS, Drizzle, PostgreSQL/MySQL).
+Author: Mohan Kumar Indala
+License-Expression: MIT
+Keywords: ai,architecture,claude,drizzle,erd,knowledge-graph,llm,mcp,nestjs,nextjs,postgres,uml
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.10
+Requires-Dist: mcp-win-stdio>=0.3.0
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: networkx>=3.2.1
+Description-Content-Type: text/markdown
+
+# mcp-win-stdio-arch
+
+Universal Architecture Knowledge Graph & Blueprint Model Context Protocol (MCP) server.
+
+Traces full-stack applications from Frontend UI (`Next.js`), Client Transport (`TanStack Query`, `Axios`), Ingress Routes (`NestJS`), Domain Services, and Data Storage (`Drizzle ORM`, `PostgreSQL`/`MySQL`).
+
+## Tools Provided
+
+1. `blueprint_feature(domain, workspace_root)`: Generates full-stack vertical blueprint with Mermaid flowchart.
+2. `blueprint_trace(target, workspace_root)`: Ordered vertical execution path with source evidence and line numbers.
+3. `blueprint_erd(domain, workspace_root)`: Entity-Relationship Diagram (ERD) with tables, columns, and foreign keys.
+4. `blueprint_impact(node_id, direction, workspace_root)`: Upstream & downstream blast-radius analysis.
+5. `blueprint_audit(workspace_root)`: Architectural linting (missing FK indexes, broken routes, layer leaks, orphan entities).

mcp_win_stdio_arch-0.3.0/README.md

@@ -0,0 +1,13 @@
+# mcp-win-stdio-arch
+
+Universal Architecture Knowledge Graph & Blueprint Model Context Protocol (MCP) server.
+
+Traces full-stack applications from Frontend UI (`Next.js`), Client Transport (`TanStack Query`, `Axios`), Ingress Routes (`NestJS`), Domain Services, and Data Storage (`Drizzle ORM`, `PostgreSQL`/`MySQL`).
+
+## Tools Provided
+
+1. `blueprint_feature(domain, workspace_root)`: Generates full-stack vertical blueprint with Mermaid flowchart.
+2. `blueprint_trace(target, workspace_root)`: Ordered vertical execution path with source evidence and line numbers.
+3. `blueprint_erd(domain, workspace_root)`: Entity-Relationship Diagram (ERD) with tables, columns, and foreign keys.
+4. `blueprint_impact(node_id, direction, workspace_root)`: Upstream & downstream blast-radius analysis.
+5. `blueprint_audit(workspace_root)`: Architectural linting (missing FK indexes, broken routes, layer leaks, orphan entities).

mcp_win_stdio_arch-0.3.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcp-win-stdio-arch"
+version = "0.3.0"
+description = "Universal Architecture Knowledge Graph & Blueprint Model Context Protocol (MCP) server for full-stack codebases (Next.js, NestJS, Drizzle, PostgreSQL/MySQL)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Mohan Kumar Indala" }
+]
+keywords = ["mcp", "claude", "architecture", "knowledge-graph", "erd", "uml", "nextjs", "nestjs", "drizzle", "postgres", "ai", "llm"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Win32 (MS Windows)",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Documentation",
+]
+
+dependencies = [
+    "mcp-win-stdio>=0.3.0",
+    "mcp>=1.2.0",
+    "networkx>=3.2.1",
+]
+
+[project.scripts]
+mcp-win-stdio-arch = "mcp_win_stdio.arch.cli:main"
+mws-arch = "mcp_win_stdio.arch.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_win_stdio"]

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/__init__.py

@@ -0,0 +1,6 @@
+"""
+Universal Architecture Blueprint & Knowledge Graph module.
+Part of mcp-win-stdio.
+"""
+
+__version__ = "0.3.0"

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/cli.py

@@ -0,0 +1,71 @@
+"""
+CLI entry point for mcp-win-stdio-arch.
+"""
+
+import argparse
+import sys
+
+from mcp_win_stdio.arch import __version__
+from mcp_win_stdio.arch.server import mcp
+
+
+def cmd_run(args: argparse.Namespace) -> None:
+    """Run Architecture Blueprint MCP server over stdio."""
+    mcp.run()
+
+
+def cmd_doctor(args: argparse.Namespace) -> None:
+    """Check Architecture Blueprint MCP health."""
+    print(f"\n=== mcp-win-stdio-arch Doctor Diagnostic (v{__version__}) ===\n")
+    print(f"[OK] Python: {sys.version.split()[0]} ({sys.executable})")
+
+    for dep in ("mcp", "networkx"):
+        try:
+            __import__(dep)
+            print(f"[OK] Library: {dep:<14}")
+        except ImportError:
+            print(f"[FAIL] Library: {dep:<14} (MISSING - run `pip install {dep}`)")
+
+    print("\nDiagnostic complete.\n")
+
+
+def cmd_guide(args: argparse.Namespace) -> None:
+    """Print guide and prompt recipes."""
+    print("""
+=== mcp-win-stdio-arch Guide & Recipes ===
+
+Tools Provided:
+  - blueprint_feature(domain, workspace_root)
+  - blueprint_erd(domain, workspace_root)
+  - blueprint_trace(target, workspace_root)
+  - blueprint_impact(node_id, direction, workspace_root)
+  - blueprint_audit(workspace_root)
+""")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="mcp-win-stdio-arch",
+        description="Universal Architecture Blueprint MCP Server",
+    )
+    subparsers = parser.add_subparsers(dest="subcommand", help="Available subcommands")
+
+    run_parser = subparsers.add_parser("run", help="Run MCP server over stdio")
+    run_parser.set_defaults(func=cmd_run)
+
+    doc_parser = subparsers.add_parser("doctor", help="Check dependencies and health")
+    doc_parser.set_defaults(func=cmd_doctor)
+
+    guide_parser = subparsers.add_parser("guide", help="Print tool guide")
+    guide_parser.set_defaults(func=cmd_guide)
+
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        # Default action: run stdio server
+        cmd_run(args)
+
+
+if __name__ == "__main__":
+    main()

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/graph.py

@@ -0,0 +1,214 @@
+"""
+Core Directed Multigraph Engine using NetworkX
+"""
+
+from typing import Any, Dict, List, Optional, Set
+import networkx as nx
+
+from .models import (
+    ArchitectureEdge,
+    ArchitectureNode,
+    EdgeType,
+    NodeKind,
+    ScanDiagnostic,
+)
+
+
+class ArchitectureGraph:
+    def __init__(self) -> None:
+        self.g = nx.MultiDiGraph()
+        self.nodes_map: Dict[str, ArchitectureNode] = {}
+        self.edges_map: Dict[str, ArchitectureEdge] = {}
+        self.diagnostics: List[ScanDiagnostic] = []
+
+    def clear(self) -> None:
+        self.g.clear()
+        self.nodes_map.clear()
+        self.edges_map.clear()
+        self.diagnostics.clear()
+
+    # --- Node Operations ---
+
+    def add_node(self, node: ArchitectureNode) -> None:
+        self.nodes_map[node.id] = node
+        self.g.add_node(
+            node.id,
+            kind=node.kind.value if isinstance(node.kind, NodeKind) else str(node.kind),
+            name=node.name,
+            domain=node.domain,
+            file_path=node.file_path,
+        )
+
+    def get_node(self, node_id: str) -> Optional[ArchitectureNode]:
+        return self.nodes_map.get(node_id)
+
+    def has_node(self, node_id: str) -> bool:
+        return node_id in self.nodes_map
+
+    def get_all_nodes(self) -> List[ArchitectureNode]:
+        return list(self.nodes_map.values())
+
+    def get_nodes_by_kind(self, kind: NodeKind) -> List[ArchitectureNode]:
+        return [n for n in self.nodes_map.values() if n.kind == kind]
+
+    def get_nodes_by_domain(self, domain: str) -> List[ArchitectureNode]:
+        return [n for n in self.nodes_map.values() if n.domain == domain]
+
+    # --- Edge Operations ---
+
+    def add_edge(self, edge: ArchitectureEdge) -> None:
+        if edge.source not in self.nodes_map or edge.target not in self.nodes_map:
+            raise ValueError(
+                f"Cannot add edge {edge.id}: source ({edge.source}) or target ({edge.target}) does not exist"
+            )
+
+        self.edges_map[edge.id] = edge
+        self.g.add_edge(
+            edge.source,
+            edge.target,
+            key=edge.id,
+            type=edge.type.value if isinstance(edge.type, EdgeType) else str(edge.type),
+            confidence=edge.confidence.value,
+            resolution=edge.resolution.value,
+        )
+
+    def get_edge(self, edge_id: str) -> Optional[ArchitectureEdge]:
+        return self.edges_map.get(edge_id)
+
+    def get_all_edges(self) -> List[ArchitectureEdge]:
+        return list(self.edges_map.values())
+
+    def get_outgoing_edges(self, node_id: str) -> List[ArchitectureEdge]:
+        if not self.g.has_node(node_id):
+            return []
+        edges = []
+        for _, _, key in self.g.out_edges(node_id, keys=True):
+            if key in self.edges_map:
+                edges.append(self.edges_map[key])
+        return edges
+
+    def get_incoming_edges(self, node_id: str) -> List[ArchitectureEdge]:
+        if not self.g.has_node(node_id):
+            return []
+        edges = []
+        for _, _, key in self.g.in_edges(node_id, keys=True):
+            if key in self.edges_map:
+                edges.append(self.edges_map[key])
+        return edges
+
+    # --- Diagnostics ---
+
+    def add_diagnostic(self, diagnostic: ScanDiagnostic) -> None:
+        self.diagnostics.append(diagnostic)
+
+    def get_diagnostics(self) -> List[ScanDiagnostic]:
+        return list(self.diagnostics)
+
+    # --- Traversals & Blast Radius ---
+
+    def trace_paths(
+        self,
+        from_node_id: str,
+        target_kind: Optional[NodeKind] = None,
+        max_depth: int = 10,
+        max_paths: int = 20,
+    ) -> List[List[str]]:
+        """
+        Traces paths from from_node_id to target_kind with cycle protection.
+        Returns list of path node ID lists.
+        """
+        if not self.has_node(from_node_id):
+            return []
+
+        results: List[List[str]] = []
+
+        def dfs(current_id: str, path: List[str], depth: int, visited: Set[str]):
+            if len(results) >= max_paths or depth >= max_depth:
+                return
+
+            curr_node = self.nodes_map.get(current_id)
+            if target_kind and curr_node and curr_node.kind == target_kind and len(path) > 1:
+                results.append(list(path))
+                return
+
+            extended = False
+            for edge in self.get_outgoing_edges(current_id):
+                nxt = edge.target
+                if nxt in visited:
+                    continue
+
+                extended = True
+                visited.add(nxt)
+                path.append(nxt)
+
+                dfs(nxt, path, depth + 1, visited)
+
+                path.pop()
+                visited.remove(nxt)
+
+            if not extended and not target_kind and len(path) > 1:
+                results.append(list(path))
+
+        dfs(from_node_id, [from_node_id], 0, {from_node_id})
+        return results
+
+    def compute_blast_radius(
+        self,
+        node_id: str,
+        direction: str = "both",
+        max_depth: int = 8,
+    ) -> Dict[str, Any]:
+        """
+        Calculates upstream/downstream blast radius for refactoring.
+        """
+        if not self.has_node(node_id):
+            return {"root_node_id": node_id, "total_affected": 0, "impacted": []}
+
+        impacted: Dict[str, Dict[str, Any]] = {}
+
+        queue: List[tuple[str, int, str]] = []
+        if direction in ("downstream", "both"):
+            queue.append((node_id, 0, "downstream"))
+        if direction in ("upstream", "both"):
+            queue.append((node_id, 0, "upstream"))
+
+        visited: Set[str] = set()
+
+        while queue:
+            curr_id, depth, d = queue.pop(0)
+            vkey = f"{curr_id}:{d}"
+            if vkey in visited:
+                continue
+            visited.add(vkey)
+
+            if depth > 0 and curr_id not in impacted:
+                impacted[curr_id] = {
+                    "node_id": curr_id,
+                    "depth": depth,
+                    "direction": d,
+                    "kind": self.nodes_map[curr_id].kind.value,
+                    "name": self.nodes_map[curr_id].name,
+                }
+
+            if depth >= max_depth:
+                continue
+
+            if d == "downstream":
+                for edge in self.get_outgoing_edges(curr_id):
+                    queue.append((edge.target, depth + 1, "downstream"))
+            else:
+                for edge in self.get_incoming_edges(curr_id):
+                    queue.append((edge.source, depth + 1, "upstream"))
+
+        return {
+            "root_node_id": node_id,
+            "total_affected": len(impacted),
+            "impacted": list(impacted.values()),
+        }
+
+    def stats(self) -> Dict[str, int]:
+        return {
+            "node_count": len(self.nodes_map),
+            "edge_count": len(self.edges_map),
+            "diagnostic_count": len(self.diagnostics),
+        }

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/identity.py

@@ -0,0 +1,61 @@
+"""
+Deterministic URN & Node ID Generators
+"""
+
+import re
+
+
+def normalize_path(path_str: str) -> str:
+    """Normalize file paths to clean POSIX format."""
+    return path_str.replace("\\", "/").lstrip("/")
+
+
+def normalize_route_path(raw_path: str) -> str:
+    """
+    Normalize route paths across frameworks:
+    Converts :id, ${id}, [id] to {param}
+    """
+    p = raw_path.strip().split("?")[0].split("#")[0]
+    p = re.sub(r"\$\{[^}]+\}", "{param}", p)
+    p = re.sub(r":([a-zA-Z0-9_]+)", "{param}", p)
+    p = re.sub(r"\[([a-zA-Z0-9_]+)\]", "{param}", p)
+    if not p.startswith("/"):
+        p = "/" + p
+    if len(p) > 1 and p.endswith("/"):
+        p = p[:-1]
+    return p.lower()
+
+
+class NodeIdentifier:
+    @staticmethod
+    def for_surface(workspace: str, file_path: str, component_name: str) -> str:
+        return f"surface:{workspace}:{normalize_path(file_path)}#{component_name}"
+
+    @staticmethod
+    def for_client_transport(workspace: str, file_path: str, symbol: str) -> str:
+        return f"client:{workspace}:{normalize_path(file_path)}#{symbol}"
+
+    @staticmethod
+    def for_ingress_route(method: str, normalized_path: str) -> str:
+        return f"route:{method.upper()}:{normalize_route_path(normalized_path)}"
+
+    @staticmethod
+    def for_domain_logic(workspace: str, file_path: str, class_name: str, method: str = "") -> str:
+        symbol = f"{class_name}.{method}" if method else class_name
+        return f"logic:{workspace}:{normalize_path(file_path)}#{symbol}"
+
+    @staticmethod
+    def for_storage_entity(schema: str, table_name: str) -> str:
+        return f"storage:{schema.lower()}:{table_name.lower()}"
+
+    @staticmethod
+    def for_field(owner_id: str, field_name: str) -> str:
+        return f"field:{owner_id}#{field_name}"
+
+    @staticmethod
+    def for_contract(workspace: str, file_path: str, type_name: str) -> str:
+        return f"contract:{workspace}:{normalize_path(file_path)}#{type_name}"
+
+    @staticmethod
+    def for_edge(source: str, edge_type: str, target: str) -> str:
+        return f"edge:{source}--{edge_type}-->{target}"

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/models.py

@@ -0,0 +1,96 @@
+"""
+Core Canonical Schema: Universal Architectural Primitives (UIR)
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class NodeKind(str, Enum):
+    SURFACE = "Surface"                  # UI Page, Component, Screen, Template
+    CLIENT_TRANSPORT = "ClientTransport" # Hook, API Client method, RPC client
+    INGRESS_ROUTE = "IngressRoute"       # HTTP Route, Controller method, RPC handler
+    DOMAIN_LOGIC = "DomainLogic"         # Service, Use Case, Business domain function
+    STORAGE_ENTITY = "StorageEntity"     # ORM Model, SQL Table, View, Collection
+    FIELD = "Field"                      # Database Column or DTO Property
+    CONTRACT = "Contract"                # DTO, Zod Schema, OpenAPI Request/Response
+    EXTERNAL_SYSTEM = "ExternalSystem"   # Third-party API, Message Broker
+    CONFIGURATION = "Configuration"      # Env var, Route prefix, Feature flag
+    JOB = "Job"                          # Cron job, Queue consumer, Worker
+
+
+class EdgeType(str, Enum):
+    DECLARES = "DECLARES"                # e.g. Controller declares method, Schema declares Table
+    IMPORTS = "IMPORTS"                  # Module imports another module
+    CALLS = "CALLS"                      # Method or function invocation
+    USES_HOOK = "USES_HOOK"              # Surface uses query/mutation hook
+    ROUTES_TO = "ROUTES_TO"              # Client request matches an ingress route
+    INJECTS = "INJECTS"                  # Dependency injection
+    READS = "READS"                      # Logic queries a table or field
+    WRITES = "WRITES"                    # Logic mutates a table or field
+    SERIALIZES_AS = "SERIALIZES_AS"      # Entity shapes into DTO
+    REFERENCES_FK = "REFERENCES_FK"      # Foreign-key relationship
+    PUBLISHES = "PUBLISHES"              # Event-driven message publishing
+    CONSUMES = "CONSUMES"                # Event-driven message consumption
+    CONFIGURED_BY = "CONFIGURED_BY"      # Component depends on configuration
+
+
+class Confidence(str, Enum):
+    HIGH = "high"       # Statically resolved symbol call, explicit foreign key, exact route match
+    MEDIUM = "medium"   # Inferred through convention or partial types
+    LOW = "low"         # Heuristic or ambiguous string matching
+
+
+class Resolution(str, Enum):
+    STATIC = "static"   # AST symbol checker or static code analysis
+    INFERRED = "inferred" # Normalized route or naming pattern match
+    RUNTIME = "runtime" # Database introspection or live trace
+    MANUAL = "manual"   # User/developer annotated
+
+
+@dataclass
+class EvidenceLocation:
+    file_path: str
+    start_line: Optional[int] = None
+    end_line: Optional[int] = None
+    symbol: Optional[str] = None
+
+
+@dataclass
+class EdgeEvidence:
+    rule_id: str
+    locations: List[EvidenceLocation] = field(default_factory=list)
+    explanation: Optional[str] = None
+    snippet: Optional[str] = None
+
+
+@dataclass
+class ArchitectureNode:
+    id: str
+    kind: NodeKind
+    name: str
+    file_path: Optional[str] = None
+    domain: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ArchitectureEdge:
+    id: str
+    source: str
+    target: str
+    type: EdgeType
+    evidence: EdgeEvidence
+    confidence: Confidence = Confidence.HIGH
+    resolution: Resolution = Resolution.STATIC
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ScanDiagnostic:
+    code: str
+    severity: str  # "info" | "warning" | "error"
+    message: str
+    location: Optional[EvidenceLocation] = None
+    attempted_resolution: Optional[Dict[str, Any]] = None

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/renderers.py

@@ -0,0 +1,96 @@
+"""
+Mermaid Flowchart and ERD Renderers
+"""
+
+import re
+from typing import List, Optional
+
+from .graph import ArchitectureGraph
+from .models import ArchitectureEdge, ArchitectureNode, NodeKind
+
+
+def sanitize(name: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9_]", "_", name)
+
+
+class MermaidRenderer:
+    @staticmethod
+    def render_flowchart(
+        graph: ArchitectureGraph,
+        nodes: Optional[List[ArchitectureNode]] = None,
+        edges: Optional[List[ArchitectureEdge]] = None,
+    ) -> str:
+        active_nodes = nodes or graph.get_all_nodes()
+        active_edges = edges or graph.get_all_edges()
+
+        lines = ["flowchart TD"]
+
+        groups: dict[str, list[ArchitectureNode]] = {}
+        for node in active_nodes:
+            kind_str = node.kind.value if isinstance(node.kind, NodeKind) else str(node.kind)
+            groups.setdefault(kind_str, []).append(node)
+
+        order = [
+            "Surface",
+            "ClientTransport",
+            "IngressRoute",
+            "DomainLogic",
+            "StorageEntity",
+            "Contract",
+        ]
+
+        for kind in order:
+            items = groups.get(kind, [])
+            if not items:
+                continue
+            lines.append(f'  subgraph {kind}_Layer ["{kind} Layer"]')
+            for n in items:
+                sid = sanitize(n.id)
+                lines.append(f'    {sid}["{n.name}\\n({kind})"]')
+            lines.append("  end")
+
+        for e in active_edges:
+            sid = sanitize(e.source)
+            tid = sanitize(e.target)
+            etype = e.type.value if hasattr(e.type, "value") else str(e.type)
+            conf = e.confidence.value if hasattr(e.confidence, "value") else str(e.confidence)
+            lines.append(f'  {sid} -->|"{etype} ({conf})"| {tid}')
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def render_erd(graph: ArchitectureGraph, domain: Optional[str] = None) -> str:
+        tables = (
+            graph.get_nodes_by_domain(domain)
+            if domain
+            else graph.get_nodes_by_kind(NodeKind.STORAGE_ENTITY)
+        )
+        tables = [t for t in tables if t.kind == NodeKind.STORAGE_ENTITY]
+
+        lines = ["erDiagram"]
+        for t in tables:
+            lines.append(f"  {sanitize(t.name)} {{")
+            # find fields
+            fields = [
+                f for f in graph.get_nodes_by_kind(NodeKind.FIELD)
+                if f.metadata.get("owner_id") == t.id
+            ]
+            if not fields:
+                lines.append("    string id PK")
+            else:
+                for f in fields:
+                    pk = "PK" if f.metadata.get("is_pk") else ""
+                    fk = "FK" if f.metadata.get("is_fk") else ""
+                    tag = ",".join(filter(None, [pk, fk]))
+                    dtype = f.metadata.get("data_type", "string")
+                    lines.append(f"    {dtype} {f.name} {tag}")
+            lines.append("  }")
+
+        for e in graph.get_all_edges():
+            if e.type == "REFERENCES_FK" or getattr(e.type, "value", None) == "REFERENCES_FK":
+                s = graph.get_node(e.source)
+                t = graph.get_node(e.target)
+                if s and t:
+                    lines.append(f'  {sanitize(s.name)} }}o--|| {sanitize(t.name)} : "references"')
+
+        return "\n".join(lines)

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/scanner.py

@@ -0,0 +1,250 @@
+"""
+Real-world AST Scanner for Showreel (Drizzle ORM + NestJS Backend + Next.js Frontend)
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .graph import ArchitectureGraph
+from .identity import NodeIdentifier, normalize_route_path
+from .models import (
+    ArchitectureEdge,
+    ArchitectureNode,
+    Confidence,
+    EdgeEvidence,
+    EdgeType,
+    EvidenceLocation,
+    NodeKind,
+    Resolution,
+)
+
+
+class ShowreelScanner:
+    """
+    Scans full-stack Showreel architecture:
+    Frontend (Next.js/TanStack) -> Backend (NestJS) -> Schema (Drizzle).
+    """
+
+    def __init__(self, workspace_root: str = r"Z:\projects\showreel") -> None:
+        self.workspace_root = Path(workspace_root)
+        self.frontend_root = self.workspace_root / "rfc_location_booking_frontend"
+        self.backend_root = self.workspace_root / "rfc_location_booking_backend"
+
+    def scan_all(self, graph: ArchitectureGraph, domain: Optional[str] = "prop-management") -> None:
+        # 1. Scan Drizzle DB Schemas
+        self.scan_drizzle_schemas(graph, domain)
+        # 2. Scan NestJS Controllers & Services
+        self.scan_nestjs_backend(graph, domain)
+        # 3. Scan Next.js Features & React Query Hooks
+        self.scan_nextjs_frontend(graph, domain)
+
+    def scan_drizzle_schemas(self, graph: ArchitectureGraph, domain: Optional[str] = None) -> None:
+        schema_dir = self.backend_root / "src" / "database" / "schema"
+        if not schema_dir.exists():
+            return
+
+        schema_files = list(schema_dir.glob("*.ts"))
+        table_var_map: Dict[str, str] = {}  # varName -> tableNodeId
+
+        for sfile in schema_files:
+            try:
+                content = sfile.read_text(encoding="utf-8")
+            except Exception:
+                continue
+
+            rel_path = str(sfile.relative_to(self.workspace_root))
+
+            # Match: export const <varName> = pgTable('tableName', { ... })
+            # or export const <varName> = publicSchema.table('tableName', { ... })
+            table_matches = re.finditer(
+                r"export\s+const\s+([a-zA-Z0-9_]+)\s*=\s*(?:pgTable|[a-zA-Z0-9_]+\.table)\s*\(\s*['\"]([^'\"]+)['\"]",
+                content,
+            )
+
+            for m in table_matches:
+                var_name = m.group(1)
+                table_name = m.group(2)
+                node_id = NodeIdentifier.for_storage_entity("public", table_name)
+
+                table_node = ArchitectureNode(
+                    id=node_id,
+                    kind=NodeKind.STORAGE_ENTITY,
+                    name=table_name,
+                    file_path=rel_path,
+                    domain=domain or "prop-management",
+                    metadata={"var_name": var_name, "orm": "drizzle"},
+                )
+                graph.add_node(table_node)
+                table_var_map[var_name] = node_id
+
+            # Parse foreign keys: .references(() => otherTable.id)
+            fk_matches = re.finditer(
+                r"export\s+const\s+([a-zA-Z0-9_]+)\s*=\s*(?:pgTable|[a-zA-Z0-9_]+\.table).*?\.references\(\s*\(\)\s*=>\s*([a-zA-Z0-9_]+)\.",
+                content,
+                re.DOTALL,
+            )
+            for fk in fk_matches:
+                src_var = fk.group(1)
+                tgt_var = fk.group(2)
+                if src_var in table_var_map and tgt_var in table_var_map and src_var != tgt_var:
+                    src_id = table_var_map[src_var]
+                    tgt_id = table_var_map[tgt_var]
+                    edge_id = NodeIdentifier.for_edge(src_id, "REFERENCES_FK", tgt_id)
+                    if not graph.get_edge(edge_id):
+                        graph.add_edge(
+                            ArchitectureEdge(
+                                id=edge_id,
+                                source=src_id,
+                                target=tgt_id,
+                                type=EdgeType.REFERENCES_FK,
+                                confidence=Confidence.HIGH,
+                                resolution=Resolution.STATIC,
+                                evidence=EdgeEvidence(
+                                    rule_id="DRIZZLE_FK_REFERENCES",
+                                    locations=[EvidenceLocation(file_path=rel_path)],
+                                    explanation=f"FK: {src_var} -> {tgt_var}",
+                                ),
+                            )
+                        )
+
+    def scan_nestjs_backend(self, graph: ArchitectureGraph, domain: Optional[str] = None) -> None:
+        modules_dir = self.backend_root / "src" / "modules"
+        if not modules_dir.exists():
+            return
+
+        for ctrl_file in modules_dir.rglob("*controller.ts"):
+            try:
+                content = ctrl_file.read_text(encoding="utf-8")
+            except Exception:
+                continue
+
+            rel_path = str(ctrl_file.relative_to(self.workspace_root))
+
+            # Match @Controller('prefix')
+            prefix_match = re.search(r"@Controller\(\s*['\"]([^'\"]*)['\"]\s*\)", content)
+            base_prefix = prefix_match.group(1) if prefix_match else ""
+            if not base_prefix.startswith("/"):
+                base_prefix = "/" + base_prefix
+
+            # Match routes: @Get(':id'), @Post(), etc.
+            method_matches = re.finditer(
+                r"@(Get|Post|Put|Patch|Delete)\(\s*(?:['\"]([^'\"]*)['\"])?\s*\)\s*(?:async\s+)?([a-zA-Z0-9_]+)\s*\(",
+                content,
+            )
+
+            for mm in method_matches:
+                http_method = mm.group(1).upper()
+                sub_path = mm.group(2) or ""
+                fn_name = mm.group(3)
+
+                full_path = f"{base_prefix}/{sub_path}".replace("//", "/")
+                # Showreel uses standard api prefix (e.g. /api/v1/prop/...)
+                norm_route_id = NodeIdentifier.for_ingress_route(http_method, full_path)
+
+                route_node = ArchitectureNode(
+                    id=norm_route_id,
+                    kind=NodeKind.INGRESS_ROUTE,
+                    name=f"{http_method} {full_path}",
+                    file_path=rel_path,
+                    domain=domain or "prop-management",
+                    metadata={"handler": fn_name, "method": http_method, "path": full_path},
+                )
+                graph.add_node(route_node)
+
+                # Link to Service in same module if called
+                svc_call_match = re.search(r"this\.([a-zA-Z0-9_]+Service)\.([a-zA-Z0-9_]+)\(", content)
+                if svc_call_match:
+                    svc_class = svc_call_match.group(1)
+                    svc_method = svc_call_match.group(2)
+                    svc_id = NodeIdentifier.for_domain_logic("showreel", rel_path, svc_class, svc_method)
+                    if not graph.has_node(svc_id):
+                        graph.add_node(
+                            ArchitectureNode(
+                                id=svc_id,
+                                kind=NodeKind.DOMAIN_LOGIC,
+                                name=f"{svc_class}.{svc_method}",
+                                file_path=rel_path,
+                                domain=domain or "prop-management",
+                            )
+                        )
+                    edge_id = NodeIdentifier.for_edge(norm_route_id, "CALLS", svc_id)
+                    if not graph.get_edge(edge_id):
+                        graph.add_edge(
+                            ArchitectureEdge(
+                                id=edge_id,
+                                source=norm_route_id,
+                                target=svc_id,
+                                type=EdgeType.CALLS,
+                                confidence=Confidence.HIGH,
+                                resolution=Resolution.STATIC,
+                                evidence=EdgeEvidence(
+                                    rule_id="NESTJS_CONTROLLER_SERVICE_CALL",
+                                    locations=[EvidenceLocation(file_path=rel_path, symbol=fn_name)],
+                                ),
+                            )
+                        )
+
+    def scan_nextjs_frontend(self, graph: ArchitectureGraph, domain: Optional[str] = None) -> None:
+        features_dir = self.frontend_root / "features"
+        if not features_dir.exists():
+            return
+
+        for hook_file in features_dir.rglob("*.ts*"):
+            try:
+                content = hook_file.read_text(encoding="utf-8")
+            except Exception:
+                continue
+
+            rel_path = str(hook_file.relative_to(self.workspace_root))
+
+            # Match TanStack Query hooks: export function useEstimationQuery or const useX =
+            hook_match = re.search(r"export\s+(?:function|const)\s+(use[a-zA-Z0-9_]+)", content)
+            if not hook_match:
+                continue
+
+            hook_name = hook_match.group(1)
+            hook_id = NodeIdentifier.for_client_transport("showreel", rel_path, hook_name)
+
+            # Look for endpoint pattern: e.g. /api/v1/prop/estimations or axios.get('/api/...')
+            endpoint_match = re.search(r"['\"](\/api\/[a-zA-Z0-9_\-\/]+(?:\$\{[^}]+\})?)['\"]", content)
+            endpoint_url = endpoint_match.group(1) if endpoint_match else None
+
+            client_node = ArchitectureNode(
+                id=hook_id,
+                kind=NodeKind.CLIENT_TRANSPORT,
+                name=hook_name,
+                file_path=rel_path,
+                domain=domain or "prop-management",
+                metadata={"endpoint": endpoint_url},
+            )
+            graph.add_node(client_node)
+
+            # Match with backend route if endpoint matches
+            if endpoint_url:
+                norm_route_id = NodeIdentifier.for_ingress_route("GET", endpoint_url)
+                # Check if route exists or starts with pattern
+                for rnode in graph.get_nodes_by_kind(NodeKind.INGRESS_ROUTE):
+                    r_path = rnode.metadata.get("path", "")
+                    if normalize_route_path(r_path) == normalize_route_path(endpoint_url) or (
+                        r_path and r_path in endpoint_url
+                    ):
+                        edge_id = NodeIdentifier.for_edge(hook_id, "ROUTES_TO", rnode.id)
+                        if not graph.get_edge(edge_id):
+                            graph.add_edge(
+                                ArchitectureEdge(
+                                    id=edge_id,
+                                    source=hook_id,
+                                    target=rnode.id,
+                                    type=EdgeType.ROUTES_TO,
+                                    confidence=Confidence.HIGH,
+                                    resolution=Resolution.INFERRED,
+                                    evidence=EdgeEvidence(
+                                        rule_id="HTTP_CLIENT_ROUTE_MATCH",
+                                        locations=[EvidenceLocation(file_path=rel_path, symbol=hook_name)],
+                                        explanation=f"Matched {endpoint_url} to backend {r_path}",
+                                    ),
+                                )
+                            )
+                        break

mcp_win_stdio_arch-0.3.0/src/mcp_win_stdio/arch/server.py

@@ -0,0 +1,133 @@
+"""
+Server definition for mcp-win-stdio-arch (FastMCP)
+Part of mcp-win-stdio.
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+try:
+    from mcp.server.mcpserver import MCPServer as FastMCP
+except (ImportError, ModuleNotFoundError):
+    from mcp.server.fastmcp import FastMCP  # type: ignore[import-not-found]
+
+from .graph import ArchitectureGraph
+from .models import NodeKind
+from .renderers import MermaidRenderer
+from .scanner import ShowreelScanner
+
+mcp = FastMCP("arch-mcp")
+
+# In-memory graph cache
+_GRAPH = ArchitectureGraph()
+_SCANNED_ROOT: Optional[str] = None
+
+
+def _ensure_graph(workspace_root: str = r"Z:\projects\showreel") -> ArchitectureGraph:
+    global _GRAPH, _SCANNED_ROOT
+    if _SCANNED_ROOT != workspace_root or _GRAPH.stats()["node_count"] == 0:
+        _GRAPH.clear()
+        scanner = ShowreelScanner(workspace_root)
+        scanner.scan_all(_GRAPH)
+        _SCANNED_ROOT = workspace_root
+    return _GRAPH
+
+
+@mcp.tool()
+def blueprint_feature(
+    domain: str = "prop-management",
+    workspace_root: str = r"Z:\projects\showreel",
+) -> Dict[str, Any]:
+    """
+    Generates a full-stack vertical architecture blueprint for a domain feature.
+    Connects: UI Views -> TanStack Hooks -> NestJS Controllers -> Services -> Drizzle DB Tables.
+    Returns: Mermaid flowchart and structured node/edge statistics.
+    """
+    graph = _ensure_graph(workspace_root)
+    nodes = graph.get_nodes_by_domain(domain)
+    if not nodes:
+        nodes = graph.get_all_nodes()
+
+    mermaid = MermaidRenderer.render_flowchart(graph, nodes=nodes)
+    return {
+        "domain": domain,
+        "mermaid": mermaid,
+        "stats": graph.stats(),
+        "node_sample": [n.name for n in nodes[:15]],
+    }
+
+
+@mcp.tool()
+def blueprint_erd(
+    domain: Optional[str] = "prop-management",
+    workspace_root: str = r"Z:\projects\showreel",
+) -> Dict[str, Any]:
+    """
+    Generates an Entity-Relationship Diagram (ERD) with tables, columns, and foreign keys.
+    """
+    graph = _ensure_graph(workspace_root)
+    mermaid_erd = MermaidRenderer.render_erd(graph, domain=domain)
+    tables = [
+        n.name for n in graph.get_nodes_by_kind(NodeKind.STORAGE_ENTITY)
+        if not domain or n.domain == domain
+    ]
+    return {
+        "domain": domain,
+        "mermaid_erd": mermaid_erd,
+        "tables_count": len(tables),
+        "tables": tables,
+    }
+
+
+@mcp.tool()
+def blueprint_trace(
+    target: str,
+    workspace_root: str = r"Z:\projects\showreel",
+) -> Dict[str, Any]:
+    """
+    Traces the ordered execution path starting from a component, hook, or endpoint down to DB tables.
+    """
+    graph = _ensure_graph(workspace_root)
+    paths = graph.trace_paths(target, target_kind=NodeKind.STORAGE_ENTITY)
+    return {
+        "target": target,
+        "paths_found": len(paths),
+        "paths": paths,
+    }
+
+
+@mcp.tool()
+def blueprint_impact(
+    node_id: str,
+    direction: str = "upstream",
+    workspace_root: str = r"Z:\projects\showreel",
+) -> Dict[str, Any]:
+    """
+    Calculates the architectural blast radius before refactoring a table, column, or service.
+    """
+    graph = _ensure_graph(workspace_root)
+    return graph.compute_blast_radius(node_id, direction=direction)
+
+
+@mcp.tool()
+def blueprint_audit(
+    workspace_root: str = r"Z:\projects\showreel",
+) -> Dict[str, Any]:
+    """
+    Audits the architecture for broken routes, unindexed foreign keys, or layer leaks.
+    """
+    graph = _ensure_graph(workspace_root)
+    diagnostics = [
+        {
+            "code": d.code,
+            "severity": d.severity,
+            "message": d.message,
+            "location": d.location.file_path if d.location else None,
+        }
+        for d in graph.get_diagnostics()
+    ]
+    return {
+        "diagnostics_count": len(diagnostics),
+        "diagnostics": diagnostics,
+        "stats": graph.stats(),
+    }