archbyte 0.7.1 → 0.7.3

package/dist/cli/stats.js

@@ -2,10 +2,12 @@ import * as fs from "fs";
 import * as path from "path";
 import chalk from "chalk";
 import { resolveArchitecturePath, loadArchitectureFile, loadRulesConfig, getThreshold } from "./shared.js";
+import { isJsonMode, outputSuccess } from "./output.js";
 /**
- * Print an architecture health dashboard to the terminal.
+ * Compute architecture stats as a structured object.
+ * Pure data function — no console output.
  */
-export async function handleStats(options) {
+export function computeStats(options) {
     const diagramPath = resolveArchitecturePath(options);
     const arch = loadArchitectureFile(diagramPath);
     const config = loadRulesConfig(options.config);
@@ -14,12 +16,7 @@ export async function handleStats(options) {
     const databases = realNodes.filter((n) => n.type === "database");
     const externals = realNodes.filter((n) => n.type === "external");
     const totalConnections = arch.edges.length;
-    // Auto-detect project name from cwd
-    const projectName = process.cwd().split("/").pop() || "project";
-    console.log();
-    console.log(chalk.bold.cyan(`⚡ ArchByte Stats: ${projectName}`));
-    console.log();
-    // ── Scan Info (from metadata.json, fallback to analysis.json) ──
+    // Scan metadata
     const metadataJsonPath = path.join(process.cwd(), ".archbyte", "metadata.json");
     const analysisPath = path.join(process.cwd(), ".archbyte", "analysis.json");
     let scanMeta = {};
@@ -33,113 +30,80 @@ export async function handleStats(options) {
         }
     }
     catch { /* ignore */ }
-    if (scanMeta.analyzedAt || scanMeta.durationMs || scanMeta.filesScanned) {
-        const parts = [];
-        if (scanMeta.durationMs != null) {
-            parts.push(`${(scanMeta.durationMs / 1000).toFixed(1)}s`);
-        }
-        if (scanMeta.filesScanned != null) {
-            parts.push(`${scanMeta.filesScanned} files scanned`);
-        }
-        if (scanMeta.tokenUsage) {
-            const total = scanMeta.tokenUsage.input + scanMeta.tokenUsage.output;
-            parts.push(`${total.toLocaleString()} tokens`);
-        }
-        if (scanMeta.mode) {
-            parts.push(scanMeta.mode === "pipeline" ? "static + model" : "static only");
-        }
-        if (scanMeta.analyzedAt) {
-            const d = new Date(scanMeta.analyzedAt);
-            parts.push(d.toLocaleDateString("en-GB", { day: "numeric", month: "short", year: "numeric" }));
-        }
-        console.log(chalk.gray(`  Last scan: ${parts.join("  |  ")}`));
-        console.log();
-    }
-    // ── Summary ──
-    console.log(`  Components: ${chalk.bold(String(components.length))}          Connections: ${chalk.bold(String(totalConnections))}`);
-    console.log(`  Databases:  ${chalk.bold(String(databases.length))}          Ext Services: ${chalk.bold(String(externals.length))}`);
-    console.log();
-    // ── By Layer ──
-    const layers = ["presentation", "application", "data", "external", "deployment"];
+    // Layer counts
+    const layerNames = ["presentation", "application", "data", "external", "deployment"];
     const layerCounts = new Map();
     for (const node of realNodes) {
         layerCounts.set(node.layer, (layerCounts.get(node.layer) || 0) + 1);
     }
-    const maxCount = Math.max(...layerCounts.values(), 1);
-    console.log(chalk.bold("  By Layer:"));
-    for (const layer of layers) {
+    const layers = {};
+    for (const layer of layerNames) {
         const count = layerCounts.get(layer) || 0;
-        if (count === 0)
-            continue;
-        const barLen = Math.round((count / maxCount) * 10);
-        const bar = "█".repeat(barLen) + "░".repeat(10 - barLen);
-        const pct = realNodes.length > 0
-            ? `(${Math.round((count / realNodes.length) * 100)}%)`
-            : "";
-        const label = (layer + "          ").slice(0, 14);
-        console.log(chalk.gray(`    ${label}${bar}  ${count} ${pct}`));
+        if (count > 0) {
+            layers[layer] = {
+                count,
+                percent: realNodes.length > 0 ? Math.round((count / realNodes.length) * 100) : 0,
+            };
+        }
     }
-    console.log();
-    // ── Health Indicators ──
-    console.log(chalk.bold("  Health Indicators:"));
-    // Connection density: edges / (n * (n-1) / 2) for undirected sense
+    // Health indicators
+    const health = [];
     const n = realNodes.length;
     const possibleConnections = n > 1 ? (n * (n - 1)) / 2 : 1;
     const density = totalConnections / possibleConnections;
-    const densityStr = density.toFixed(2);
-    if (density < 0.5) {
-        console.log(chalk.green(`    ✓ Connection density: ${densityStr} (healthy < 0.5)`));
-    }
-    else {
-        console.log(chalk.yellow(`    ⚠ Connection density: ${densityStr} (threshold: 0.5)`));
-    }
-    // Hub detection (threshold: 5 connections)
+    health.push({
+        rule: "connection-density",
+        status: density < 0.5 ? "pass" : "warn",
+        message: density < 0.5
+            ? `Connection density: ${density.toFixed(2)} (healthy < 0.5)`
+            : `Connection density: ${density.toFixed(2)} (threshold: 0.5)`,
+        details: { density: parseFloat(density.toFixed(4)), threshold: 0.5 },
+    });
+    // Hub detection
     const connectionCounts = new Map();
     for (const edge of arch.edges) {
         connectionCounts.set(edge.source, (connectionCounts.get(edge.source) || 0) + 1);
         connectionCounts.set(edge.target, (connectionCounts.get(edge.target) || 0) + 1);
     }
     const hubThreshold = getThreshold(config, "max-connections", 6);
-    let hubFound = false;
+    const hubs = [];
     for (const node of realNodes) {
         const count = connectionCounts.get(node.id) || 0;
         if (count >= hubThreshold) {
-            console.log(chalk.yellow(`    ⚠ Hub detected: "${node.label}" has ${count} connections (threshold: ${hubThreshold})`));
-            hubFound = true;
+            hubs.push({ label: node.label, connections: count });
         }
     }
-    if (!hubFound) {
-        console.log(chalk.green(`    ✓ No hubs detected (threshold: ${hubThreshold})`));
-    }
+    health.push({
+        rule: "max-connections",
+        status: hubs.length === 0 ? "pass" : "warn",
+        message: hubs.length === 0
+            ? `No hubs detected (threshold: ${hubThreshold})`
+            : `${hubs.length} hub(s) detected (threshold: ${hubThreshold})`,
+        details: { threshold: hubThreshold, hubs },
+    });
     // Orphan detection
     const connectedIds = new Set();
     for (const edge of arch.edges) {
         connectedIds.add(edge.source);
         connectedIds.add(edge.target);
     }
-    let orphanFound = false;
-    for (const node of realNodes) {
-        if (!connectedIds.has(node.id)) {
-            console.log(chalk.yellow(`    ⚠ Orphan found: "${node.label}" has 0 connections`));
-            orphanFound = true;
-        }
-    }
-    if (!orphanFound) {
-        console.log(chalk.green("    ✓ No orphans detected"));
-    }
-    // Layer violations (presentation → data, skipping application)
+    const orphans = realNodes.filter((node) => !connectedIds.has(node.id)).map((n) => n.label);
+    health.push({
+        rule: "no-orphans",
+        status: orphans.length === 0 ? "pass" : "warn",
+        message: orphans.length === 0
+            ? "No orphans detected"
+            : `${orphans.length} orphan(s) found`,
+        details: { orphans },
+    });
+    // Layer violations
     const layerOrder = {
-        presentation: 0,
-        application: 1,
-        data: 2,
-        external: 3,
-        deployment: 4,
+        presentation: 0, application: 1, data: 2, external: 3, deployment: 4,
     };
     const nodeMap = new Map();
-    for (const node of realNodes) {
+    for (const node of realNodes)
         nodeMap.set(node.id, node);
-    }
-    let violationFound = false;
+    const violations = [];
     for (const edge of arch.edges) {
         const src = nodeMap.get(edge.source);
         const tgt = nodeMap.get(edge.target);
@@ -149,14 +113,106 @@ export async function handleStats(options) {
         const tgtOrder = layerOrder[tgt.layer];
         if (srcOrder === undefined || tgtOrder === undefined)
             continue;
-        // Only check the core layers (presentation/application/data)
         if (srcOrder <= 1 && tgtOrder === 2 && tgtOrder - srcOrder > 1) {
-            console.log(chalk.yellow(`    ⚠ Layer violation: "${src.label}" (${src.layer}) → "${tgt.label}" (${tgt.layer})`));
-            violationFound = true;
+            violations.push({ from: src.label, to: tgt.label, fromLayer: src.layer, toLayer: tgt.layer });
+        }
+    }
+    health.push({
+        rule: "no-layer-bypass",
+        status: violations.length === 0 ? "pass" : "warn",
+        message: violations.length === 0
+            ? "No layer violations detected"
+            : `${violations.length} layer violation(s)`,
+        details: { violations },
+    });
+    return {
+        summary: {
+            components: components.length,
+            databases: databases.length,
+            externals: externals.length,
+            connections: totalConnections,
+            totalNodes: realNodes.length,
+        },
+        layers,
+        health,
+        ...(scanMeta.analyzedAt || scanMeta.durationMs ? { scan: scanMeta } : {}),
+    };
+}
+/**
+ * Print an architecture health dashboard to the terminal.
+ */
+export async function handleStats(options) {
+    const stats = computeStats(options);
+    if (isJsonMode()) {
+        outputSuccess(stats);
+        return;
+    }
+    const projectName = process.cwd().split("/").pop() || "project";
+    console.log();
+    console.log(chalk.bold.cyan(`⚡ ArchByte Stats: ${projectName}`));
+    console.log();
+    // ── Scan Info ──
+    if (stats.scan) {
+        const parts = [];
+        if (stats.scan.durationMs != null)
+            parts.push(`${(stats.scan.durationMs / 1000).toFixed(1)}s`);
+        if (stats.scan.filesScanned != null)
+            parts.push(`${stats.scan.filesScanned} files scanned`);
+        if (stats.scan.tokenUsage) {
+            const total = stats.scan.tokenUsage.input + stats.scan.tokenUsage.output;
+            parts.push(`${total.toLocaleString()} tokens`);
+        }
+        if (stats.scan.mode)
+            parts.push(stats.scan.mode === "pipeline" ? "static + model" : "static only");
+        if (stats.scan.analyzedAt) {
+            const d = new Date(stats.scan.analyzedAt);
+            parts.push(d.toLocaleDateString("en-GB", { day: "numeric", month: "short", year: "numeric" }));
+        }
+        if (parts.length > 0) {
+            console.log(chalk.gray(`  Last scan: ${parts.join("  |  ")}`));
+            console.log();
         }
     }
-    if (!violationFound) {
-        console.log(chalk.green("    ✓ No layer violations detected"));
+    // ── Summary ──
+    console.log(`  Components: ${chalk.bold(String(stats.summary.components))}          Connections: ${chalk.bold(String(stats.summary.connections))}`);
+    console.log(`  Databases:  ${chalk.bold(String(stats.summary.databases))}          Ext Services: ${chalk.bold(String(stats.summary.externals))}`);
+    console.log();
+    // ── By Layer ──
+    const maxCount = Math.max(...Object.values(stats.layers).map((l) => l.count), 1);
+    console.log(chalk.bold("  By Layer:"));
+    for (const [layer, data] of Object.entries(stats.layers)) {
+        const barLen = Math.round((data.count / maxCount) * 10);
+        const bar = "█".repeat(barLen) + "░".repeat(10 - barLen);
+        const label = (layer + "          ").slice(0, 14);
+        console.log(chalk.gray(`    ${label}${bar}  ${data.count} (${data.percent}%)`));
+    }
+    console.log();
+    // ── Health Indicators ──
+    console.log(chalk.bold("  Health Indicators:"));
+    for (const ind of stats.health) {
+        if (ind.status === "pass") {
+            console.log(chalk.green(`    ✓ ${ind.message}`));
+        }
+        else {
+            console.log(chalk.yellow(`    ⚠ ${ind.message}`));
+            // Print details for hubs, orphans, violations
+            const details = ind.details ?? {};
+            if (Array.isArray(details.hubs)) {
+                for (const h of details.hubs) {
+                    console.log(chalk.yellow(`      "${h.label}" has ${h.connections} connections`));
+                }
+            }
+            if (Array.isArray(details.orphans) && details.orphans.length > 0) {
+                for (const o of details.orphans) {
+                    console.log(chalk.yellow(`      "${o}" has 0 connections`));
+                }
+            }
+            if (Array.isArray(details.violations)) {
+                for (const v of details.violations) {
+                    console.log(chalk.yellow(`      "${v.from}" (${v.fromLayer}) → "${v.to}" (${v.toLayer})`));
+                }
+            }
+        }
     }
     console.log();
 }

package/dist/cli/ui.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { isJsonMode, isQuietMode } from "./output.js";
 const BRAILLE_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 // ─── Cursor Safety ───
 // Ensure the terminal cursor is always restored, even on unhandled crashes.
@@ -25,11 +26,15 @@ for (const event of ["exit", "SIGINT", "SIGTERM", "uncaughtException", "unhandle
  * Animated braille spinner. Falls back to static console.log when not a TTY.
  */
 export function spinner(label) {
-    if (!process.stdout.isTTY) {
-        console.log(`  ${label}...`);
+    if (isJsonMode() || isQuietMode() || !process.stdout.isTTY) {
+        if (!isJsonMode() && !isQuietMode()) {
+            console.log(`  ${label}...`);
+        }
         return {
             stop(result) {
-                console.log(`  ${label}... ${result}`);
+                if (!isJsonMode() && !isQuietMode()) {
+                    console.log(`  ${label}... ${result}`);
+                }
             },
         };
     }
@@ -55,10 +60,12 @@ export function spinner(label) {
  * Navigation: ↑/↓ arrows to move, Enter to confirm, Ctrl+C to exit.
  */
 export function select(prompt, options) {
-    if (!process.stdout.isTTY || options.length === 0) {
-        console.log(`  ${prompt}`);
-        if (options.length > 0)
-            console.log(`  → ${options[0]}`);
+    if (isJsonMode() || isQuietMode() || !process.stdout.isTTY || options.length === 0) {
+        if (!isJsonMode() && !isQuietMode()) {
+            console.log(`  ${prompt}`);
+            if (options.length > 0)
+                console.log(`  → ${options[0]}`);
+        }
         return Promise.resolve(0);
     }
     return new Promise((resolve) => {
@@ -138,16 +145,18 @@ export function progressBar(totalSteps) {
     function elapsed() {
         return ((Date.now() - startTime) / 1000).toFixed(1);
     }
-    if (!process.stdout.isTTY) {
+    if (isJsonMode() || isQuietMode() || !process.stdout.isTTY) {
         return {
             update(_step, label) {
-                if (label !== lastLabel) {
+                if (!isJsonMode() && !isQuietMode() && label !== lastLabel) {
                     console.log(`  [${elapsed()}s] ${label}`);
                     lastLabel = label;
                 }
             },
             done(label) {
-                console.log(`  [${elapsed()}s] ${label ?? "Done"}`);
+                if (!isJsonMode() && !isQuietMode()) {
+                    console.log(`  [${elapsed()}s] ${label ?? "Done"}`);
+                }
             },
         };
     }
@@ -179,8 +188,10 @@ export function progressBar(totalSteps) {
  * (arrow keys, etc.) to prevent accidental confirmation.
  */
 export function confirm(prompt) {
-    if (!process.stdout.isTTY) {
-        console.log(`  ${prompt} (Y/n): y`);
+    if (isJsonMode() || isQuietMode() || !process.stdout.isTTY) {
+        if (!isJsonMode() && !isQuietMode()) {
+            console.log(`  ${prompt} (Y/n): y`);
+        }
         return Promise.resolve(true);
     }
     return new Promise((resolve) => {
@@ -222,8 +233,10 @@ export function confirm(prompt) {
  * @param mask - If true, replaces each character with * (for passwords).
  */
 export function textInput(prompt, opts) {
-    if (!process.stdout.isTTY) {
-        console.log(`  ${prompt}: `);
+    if (isJsonMode() || isQuietMode() || !process.stdout.isTTY) {
+        if (!isJsonMode() && !isQuietMode()) {
+            console.log(`  ${prompt}: `);
+        }
         return Promise.resolve("");
     }
     return new Promise((resolve) => {

package/dist/mcp/server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ArchByte MCP Server
+ *
+ * Exposes architecture analysis tools and resources via the
+ * Model Context Protocol (stdio transport).
+ *
+ * Usage:
+ *   archbyte mcp
+ *
+ * Agent config:
+ *   { "mcpServers": { "archbyte": { "command": "npx", "args": ["archbyte", "mcp"] } } }
+ */
+export declare function startMcpServer(version: string): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,253 @@
+/**
+ * ArchByte MCP Server
+ *
+ * Exposes architecture analysis tools and resources via the
+ * Model Context Protocol (stdio transport).
+ *
+ * Usage:
+ *   archbyte mcp
+ *
+ * Agent config:
+ *   { "mcpServers": { "archbyte": { "command": "npx", "args": ["archbyte", "mcp"] } } }
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as path from "path";
+// ─── Server Setup ───
+export async function startMcpServer(version) {
+    const server = new McpServer({
+        name: "archbyte",
+        version,
+    });
+    // ─── Tools ───
+    server.tool("archbyte_analyze", "Run architecture analysis on a codebase. Returns component and connection counts, duration, and output path.", {
+        dir: z.string().optional().describe("Project root directory (default: cwd)"),
+        static: z.boolean().optional().describe("Static-only analysis (no model)"),
+        force: z.boolean().optional().describe("Force full re-scan"),
+    }, async (params) => {
+        try {
+            const { handleAnalyze } = await import("../cli/analyze.js");
+            const rootDir = params.dir ? path.resolve(params.dir) : process.cwd();
+            // Capture output by running analyze in quiet mode
+            const { setOutputMode } = await import("../cli/output.js");
+            setOutputMode({ json: true, quiet: true, command: "analyze", version });
+            // Run pipeline — it writes analysis.json and architecture.json
+            await handleAnalyze({
+                dir: rootDir,
+                static: params.static,
+                force: params.force,
+                skipServeHint: true,
+            });
+            // Read the results
+            const fs = await import("fs");
+            const analysisPath = path.join(rootDir, ".archbyte", "analysis.json");
+            if (fs.existsSync(analysisPath)) {
+                const analysis = JSON.parse(fs.readFileSync(analysisPath, "utf-8"));
+                const components = analysis.components?.length ?? 0;
+                const connections = analysis.connections?.length ?? 0;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                outputPath: ".archbyte/analysis.json",
+                                components,
+                                connections,
+                                mode: analysis.metadata?.mode ?? "unknown",
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            return { content: [{ type: "text", text: "Analysis complete. Output: .archbyte/analysis.json" }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Analysis failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("archbyte_status", "Check ArchByte account status, tier, and usage.", {}, async () => {
+        try {
+            const { getAccountStatus } = await import("../cli/auth.js");
+            const status = await getAccountStatus();
+            if (!status) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: "Not logged in. Run: archbyte login" }) }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Status check failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("archbyte_export", "Export architecture diagram to various formats (mermaid, json, markdown, plantuml, dot).", {
+        format: z.enum(["mermaid", "json", "markdown", "plantuml", "dot"]).optional().describe("Export format (default: mermaid)"),
+        diagram: z.string().optional().describe("Path to architecture.json"),
+        output: z.string().optional().describe("Write to file instead of returning content"),
+    }, async (params) => {
+        try {
+            const { generateExport } = await import("../cli/export.js");
+            const result = await generateExport({
+                format: params.format,
+                diagram: params.diagram,
+                output: params.output,
+            });
+            return {
+                content: [{ type: "text", text: result.content }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Export failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("archbyte_stats", "Get architecture health metrics: component counts, layer distribution, and health indicators.", {
+        diagram: z.string().optional().describe("Path to architecture.json"),
+        config: z.string().optional().describe("Path to archbyte.yaml config"),
+    }, async (params) => {
+        try {
+            const { computeStats } = await import("../cli/stats.js");
+            const stats = computeStats({
+                diagram: params.diagram,
+                config: params.config,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Stats failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("archbyte_validate", "Run architecture fitness rules (connection density, hubs, orphans, layer violations).", {
+        diagram: z.string().optional().describe("Path to architecture.json"),
+        config: z.string().optional().describe("Path to archbyte.yaml config"),
+    }, async (params) => {
+        try {
+            const { computeStats } = await import("../cli/stats.js");
+            const stats = computeStats({
+                diagram: params.diagram,
+                config: params.config,
+            });
+            const failures = stats.health.filter((h) => h.status === "warn");
+            const passed = failures.length === 0;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            valid: passed,
+                            rules: stats.health.length,
+                            passed: stats.health.filter((h) => h.status === "pass").length,
+                            warnings: failures.length,
+                            results: stats.health,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Validation failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── Resources ───
+    server.resource("Architecture", "archbyte://architecture", { description: "Full architecture state (nodes, edges, flows, environments)" }, async () => {
+        const data = await loadArchitectureData();
+        if (!data) {
+            return {
+                contents: [{
+                        uri: "archbyte://architecture",
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "No architecture.json found. Run: archbyte analyze" }),
+                    }],
+            };
+        }
+        return {
+            contents: [{
+                    uri: "archbyte://architecture",
+                    mimeType: "application/json",
+                    text: JSON.stringify(data, null, 2),
+                }],
+        };
+    });
+    server.resource("Components", "archbyte://components", { description: "Component list with types, layers, and tech stacks" }, async () => {
+        const data = await loadArchitectureData();
+        if (!data) {
+            return {
+                contents: [{
+                        uri: "archbyte://components",
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "No architecture.json found. Run: archbyte analyze" }),
+                    }],
+            };
+        }
+        const components = data.nodes.map((n) => ({
+            id: n.id,
+            label: n.label,
+            type: n.type,
+            layer: n.layer,
+            techStack: n.techStack ?? [],
+            description: n.description,
+        }));
+        return {
+            contents: [{
+                    uri: "archbyte://components",
+                    mimeType: "application/json",
+                    text: JSON.stringify(components, null, 2),
+                }],
+        };
+    });
+    server.resource("Connections", "archbyte://connections", { description: "Edge list with labels and environments" }, async () => {
+        const data = await loadArchitectureData();
+        if (!data) {
+            return {
+                contents: [{
+                        uri: "archbyte://connections",
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "No architecture.json found. Run: archbyte analyze" }),
+                    }],
+            };
+        }
+        const connections = data.edges.map((e) => ({
+            id: e.id,
+            source: e.source,
+            target: e.target,
+            label: e.label,
+            environments: e.environments ?? [],
+        }));
+        return {
+            contents: [{
+                    uri: "archbyte://connections",
+                    mimeType: "application/json",
+                    text: JSON.stringify(connections, null, 2),
+                }],
+        };
+    });
+    // ─── Start ───
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+// ─── Helpers ───
+async function loadArchitectureData() {
+    const { loadArchitectureFileSafe, resolveArchitecturePath } = await import("../cli/shared.js");
+    const archPath = resolveArchitecturePath({});
+    return loadArchitectureFileSafe(archPath);
+}