archbyte 0.1.0

package/dist/server/src/generator/index.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Architecture diagram generator - converts analysis JSON to Architecture format
+ */
+export type LayerType = 'presentation' | 'application' | 'data' | 'external' | 'deployment';
+export type NodeType = 'component' | 'service' | 'database' | 'external';
+export interface ArchNode {
+    id: string;
+    type: NodeType;
+    label: string;
+    layer: LayerType;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    strokeColor?: string;
+    environments?: string[];
+    path?: string;
+    techStack?: string[];
+    description?: string;
+}
+export interface ArchEdge {
+    id: string;
+    source: string;
+    target: string;
+    label?: string;
+    color: string;
+    environments?: string[];
+    animated?: boolean;
+    style?: "solid" | "dashed";
+}
+export interface FlowStep {
+    edge: string;
+    label: string;
+}
+export interface Flow {
+    id: string;
+    name: string;
+    description: string;
+    color: string;
+    steps: FlowStep[];
+}
+export interface EnvironmentMetadata {
+    label: string;
+    color?: string;
+    source?: string;
+}
+export interface Architecture {
+    nodes: ArchNode[];
+    edges: ArchEdge[];
+    flows: Flow[];
+    lastUpdated: string;
+    version: number;
+    environments?: Record<string, EnvironmentMetadata>;
+}
+export interface ParsedComponent {
+    id: string;
+    name: string;
+    type: "frontend" | "backend" | "worker" | "gateway" | "cli" | "library";
+    path: string;
+    techStack: string[];
+    entryPoints: string[];
+    dependencies: string[];
+    devDependencies: string[];
+    ports?: number[];
+    environments?: string[];
+    description?: string;
+}
+export interface ParsedDatabase {
+    id: string;
+    name: string;
+    type: "postgresql" | "mysql" | "mongodb" | "redis" | "sqlite" | "other";
+}
+export interface ParsedExternalService {
+    id: string;
+    name: string;
+    type: "api" | "auth" | "storage" | "messaging" | "analytics" | "other";
+    provider?: string;
+    envVars: string[];
+    environments?: string[];
+    color?: string;
+    strokeColor?: string;
+}
+export interface ParsedConnection {
+    from: string;
+    to: string;
+    type: "http" | "grpc" | "websocket" | "database" | "queue" | "file" | "event" | "pubsub" | "cloudevents" | "import" | "other";
+    label?: string;
+    description?: string;
+    environments?: string[];
+    color?: string;
+    eventType?: string;
+    async?: boolean;
+}
+export interface ParsedProject {
+    name: string;
+    description?: string;
+    components: ParsedComponent[];
+    services: Array<{
+        name: string;
+        componentId?: string;
+    }>;
+    databases: ParsedDatabase[];
+    externalServices: ParsedExternalService[];
+    connections: ParsedConnection[];
+    metadata: {
+        isMonorepo: boolean;
+        workspaces: string[];
+        hasDocker: boolean;
+        hasCi: boolean;
+        primaryLanguage?: string;
+        frameworks: string[];
+    };
+}
+/**
+ * Generate Architecture diagram from parsed project.
+ * Layout uses topological sort on connections so nodes flow left-to-right
+ * following actual sequence/data flow.  Source nodes (gateways, entry-points)
+ * appear on the left; downstream nodes cascade rightward.
+ * Within each column, nodes are sorted by layer priority so that the vertical
+ * order remains visually consistent.
+ */
+export declare function generateArchitecture(project: ParsedProject): Architecture;

package/dist/server/src/generator/index.js

@@ -0,0 +1,254 @@
+/**
+ * Architecture diagram generator - converts analysis JSON to Architecture format
+ */
+// Layer colors
+const LAYER_STYLES = {
+    presentation: { stroke: "#1971c2", bg: "#d0ebff" },
+    application: { stroke: "#e67700", bg: "#ffe8cc" },
+    data: { stroke: "#2f9e44", bg: "#b2f2bb" },
+    external: { stroke: "#9c36b5", bg: "#eebefa" },
+    deployment: { stroke: "#c92a2a", bg: "#ffe3e3" },
+};
+function getLayerForComponentType(type) {
+    switch (type) {
+        case "frontend":
+            return "presentation";
+        case "backend":
+        case "worker":
+        case "gateway":
+        case "cli":
+        case "library":
+            return "application";
+        default:
+            return "application";
+    }
+}
+function getNodeTypeForComponentType(type) {
+    switch (type) {
+        case "frontend":
+        case "backend":
+        case "worker":
+        case "gateway":
+        case "cli":
+        case "library":
+            return "component";
+        default:
+            return "component";
+    }
+}
+/**
+ * Generate Architecture diagram from parsed project.
+ * Layout uses topological sort on connections so nodes flow left-to-right
+ * following actual sequence/data flow.  Source nodes (gateways, entry-points)
+ * appear on the left; downstream nodes cascade rightward.
+ * Within each column, nodes are sorted by layer priority so that the vertical
+ * order remains visually consistent.
+ */
+export function generateArchitecture(project) {
+    const nodes = [];
+    const edges = [];
+    const nodePositions = new Map();
+    // Grid settings - all positions snap to this grid
+    const GRID_SIZE = 20;
+    const snapToGrid = (value) => Math.round(value / GRID_SIZE) * GRID_SIZE;
+    // Layout settings
+    const SPACING_X = 320; // Horizontal gap between columns
+    const SPACING_Y = 180; // Vertical gap between rows within a column
+    const NODE_WIDTH = 220;
+    const NODE_HEIGHT = 100;
+    const START_X = 120;
+    const START_Y = 120;
+    const allNodes = new Map();
+    for (const comp of project.components) {
+        const layer = getLayerForComponentType(comp.type);
+        const style = LAYER_STYLES[layer];
+        allNodes.set(comp.id, {
+            id: comp.id,
+            layer,
+            nodeType: getNodeTypeForComponentType(comp.type),
+            data: {
+                label: comp.name,
+                color: style.bg,
+                strokeColor: style.stroke,
+                path: comp.path,
+                techStack: comp.techStack,
+                ...(comp.environments && { environments: comp.environments }),
+                ...(comp.description && { description: comp.description }),
+            },
+        });
+    }
+    for (const db of project.databases) {
+        const layer = "data";
+        const style = LAYER_STYLES[layer];
+        allNodes.set(db.id, {
+            id: db.id,
+            layer,
+            nodeType: "database",
+            data: { label: db.name, color: style.bg, strokeColor: style.stroke },
+        });
+    }
+    for (const ext of project.externalServices) {
+        const layer = "external";
+        const style = LAYER_STYLES[layer];
+        allNodes.set(ext.id, {
+            id: ext.id,
+            layer,
+            nodeType: "external",
+            data: {
+                label: ext.name,
+                color: ext.color || style.bg,
+                strokeColor: ext.strokeColor || style.stroke,
+                ...(ext.environments && { environments: ext.environments }),
+            },
+        });
+    }
+    // ── 2. Build directed adjacency & in-degree for topological sort ──
+    const inDegree = new Map();
+    const adjacency = new Map();
+    for (const id of allNodes.keys()) {
+        inDegree.set(id, 0);
+        adjacency.set(id, []);
+    }
+    for (const conn of project.connections) {
+        if (!allNodes.has(conn.from) || !allNodes.has(conn.to))
+            continue;
+        adjacency.get(conn.from).push(conn.to);
+        inDegree.set(conn.to, (inDegree.get(conn.to) || 0) + 1);
+    }
+    // ── 3. BFS (Kahn's algorithm) — assign depth (column) to every node ──
+    const depth = new Map();
+    const queue = [];
+    inDegree.forEach((deg, id) => {
+        if (deg === 0) {
+            queue.push(id);
+            depth.set(id, 0);
+        }
+    });
+    // Clone in-degree so we can decrement during traversal
+    const remaining = new Map(inDegree);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const currentDepth = depth.get(current);
+        for (const neighbor of adjacency.get(current) || []) {
+            const newDepth = currentDepth + 1;
+            if (!depth.has(neighbor) || depth.get(neighbor) < newDepth) {
+                depth.set(neighbor, newDepth);
+            }
+            remaining.set(neighbor, remaining.get(neighbor) - 1);
+            if (remaining.get(neighbor) === 0)
+                queue.push(neighbor);
+        }
+    }
+    // Any nodes not reached (cycles, disconnected) get depth 0
+    for (const id of allNodes.keys()) {
+        if (!depth.has(id))
+            depth.set(id, 0);
+    }
+    // ── 4. Group nodes into columns by depth ──
+    const columns = new Map();
+    for (const [id, entry] of allNodes) {
+        const col = depth.get(id);
+        if (!columns.has(col))
+            columns.set(col, []);
+        columns.get(col).push(entry);
+    }
+    // Layer priority for vertical sort within a column
+    const LAYER_ORDER = {
+        presentation: 0,
+        application: 1,
+        data: 2,
+        external: 3,
+        deployment: 4,
+    };
+    // ── 5. Position nodes left-to-right by column, sorted vertically by layer ──
+    const sortedCols = [...columns.keys()].sort((a, b) => a - b);
+    sortedCols.forEach((col, colIndex) => {
+        const colNodes = columns.get(col);
+        // Sort within column: by layer priority, then alphabetical by label
+        colNodes.sort((a, b) => {
+            const la = LAYER_ORDER[a.layer] ?? 99;
+            const lb = LAYER_ORDER[b.layer] ?? 99;
+            if (la !== lb)
+                return la - lb;
+            return a.data.label.localeCompare(b.data.label);
+        });
+        colNodes.forEach((entry, rowIndex) => {
+            const nodeX = snapToGrid(START_X + colIndex * SPACING_X);
+            const nodeY = snapToGrid(START_Y + rowIndex * SPACING_Y);
+            nodes.push({
+                id: entry.id,
+                type: entry.nodeType,
+                label: entry.data.label,
+                layer: entry.layer,
+                x: nodeX,
+                y: nodeY,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+                color: entry.data.color,
+                strokeColor: entry.data.strokeColor,
+                ...(entry.data.path && { path: entry.data.path }),
+                ...(entry.data.techStack && { techStack: entry.data.techStack }),
+                ...(entry.data.environments && { environments: entry.data.environments }),
+                ...(entry.data.description && { description: entry.data.description }),
+            });
+            nodePositions.set(entry.id, { x: nodeX, y: nodeY, width: NODE_WIDTH, height: NODE_HEIGHT });
+        });
+    });
+    // Add connections as edges, merging all connections between the same pair
+    // of nodes (including bidirectional and multiple eventTypes) into a single edge
+    const edgeMap = new Map();
+    for (const conn of project.connections) {
+        const from = nodePositions.get(conn.from);
+        const to = nodePositions.get(conn.to);
+        if (!from || !to)
+            continue;
+        const forwardKey = `${conn.from}::${conn.to}`;
+        const reverseKey = `${conn.to}::${conn.from}`;
+        if (edgeMap.has(reverseKey)) {
+            edgeMap.get(reverseKey).push(conn);
+        }
+        else if (edgeMap.has(forwardKey)) {
+            edgeMap.get(forwardKey).push(conn);
+        }
+        else {
+            edgeMap.set(forwardKey, [conn]);
+        }
+    }
+    // EDA connection types that should be styled as async/dashed
+    const EDA_TYPES = new Set(["event", "pubsub", "cloudevents", "queue"]);
+    for (const [key, conns] of edgeMap) {
+        const [source, target] = key.split("::");
+        // Collect unique labels: prefer explicit labels, fall back to description
+        const labels = [...new Set(conns.map(c => c.label || c.description).filter(Boolean))];
+        const label = labels.join(" / ") || undefined;
+        // Merge environments from all connections
+        const envSet = new Set();
+        for (const c of conns) {
+            if (c.environments)
+                c.environments.forEach(e => envSet.add(e));
+        }
+        const environments = envSet.size > 0 ? [...envSet] : undefined;
+        // Determine if any connection is event-driven
+        const isEDA = conns.some(c => EDA_TYPES.has(c.type) || c.async);
+        const edaColor = "#06b6d4"; // cyan for event-driven
+        // Pick first explicit color
+        const color = conns.find(c => c.color)?.color || (isEDA ? edaColor : "#868e96");
+        const edgeId = `edge-${source}-${target}`;
+        edges.push({
+            id: edgeId,
+            source,
+            target,
+            label,
+            color,
+            ...(environments?.length && { environments }),
+            ...(isEDA && { style: "dashed", animated: true }),
+        });
+    }
+    return {
+        nodes,
+        edges,
+        flows: [],
+        lastUpdated: new Date().toISOString(),
+        version: 1,
+    };
+}

package/dist/server/src/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export interface ServerConfig {
+    name: string;
+    diagramPath: string;
+    workspaceRoot: string;
+    port: number;
+}
+export declare function startServer(cfg: ServerConfig): Promise<void>;