archbyte 0.4.2 → 0.5.1

package/dist/server/src/index.js

@@ -15,13 +15,35 @@ let config;
 let sseClients = new Set();
 let diagramWatcher = null;
 let isAnalyzing = false;
+// Source file watcher — detects changes to notify UI for manual re-analysis
+let sourceWatcher = null;
+const pendingSourceChanges = new Map();
+let changeDebounceTimer = null;
+const CHANGE_DEBOUNCE_MS = 2500;
+function pendingChangesPath() {
+    return path.join(config.workspaceRoot, ".archbyte", "pending-changes.json");
+}
+function savePendingChanges() {
+    const entries = Array.from(pendingSourceChanges.values());
+    writeFile(pendingChangesPath(), JSON.stringify(entries), "utf-8").catch(() => { });
+}
+function loadPendingChanges() {
+    try {
+        const raw = readFileSync(pendingChangesPath(), "utf-8");
+        const entries = JSON.parse(raw);
+        for (const entry of entries) {
+            pendingSourceChanges.set(entry.path, entry);
+        }
+    }
+    catch {
+        // No persisted changes — fresh start
+    }
+}
 const sessionChanges = [];
 const MAX_SESSION_CHANGES = 50;
 let currentArchitecture = null;
 // Process tracking for run-from-UI
 const runningWorkflows = new Map();
-let patrolProcess = null;
-let patrolRunning = false;
 let chatProcess = null;
 // Resolve archbyte CLI binary path
 function getArchbyteBin() {
@@ -30,7 +52,7 @@ function getArchbyteBin() {
     }
     catch {
         // Fallback: resolve relative to this package
-        return path.resolve(__dirname, "../../../cli/dist/index.js");
+        return path.resolve(__dirname, "../../../bin/archbyte.js");
     }
 }
 // Broadcast ops event to SSE clients
@@ -257,81 +279,76 @@ function createHttpServer() {
             }));
             return;
         }
-        // API: Impact analysis — blast radius BFS from a node
-        if (url.startsWith("/api/impact/") && req.method === "GET") {
+        // API: Deep Drill — focused static analysis of a single component
+        if (url.startsWith("/api/component/") && url.includes("/deep") && req.method === "GET") {
             const arch = currentArchitecture || (await loadArchitecture());
             if (!arch) {
                 res.writeHead(404, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ error: "No architecture loaded" }));
                 return;
             }
-            const urlParts = url.split("?");
-            const nodeId = decodeURIComponent(urlParts[0].replace("/api/impact/", ""));
-            const params = new URL(url, `http://localhost:${config.port}`).searchParams;
-            const depth = Math.min(Math.max(parseInt(params.get("depth") || "2", 10) || 2, 1), 5);
-            const direction = params.get("direction") || "both";
-            // Build adjacency lists
-            const forward = new Map();
-            const reverse = new Map();
-            for (const nd of arch.nodes) {
-                forward.set(nd.id, []);
-                reverse.set(nd.id, []);
+            // Extract component ID: /api/component/{id}/deep
+            const urlPath = url.split("?")[0];
+            const match = urlPath.match(/^\/api\/component\/(.+)\/deep$/);
+            if (!match) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid URL format" }));
+                return;
             }
-            for (const edge of arch.edges) {
-                forward.get(edge.source)?.push(edge.target);
-                reverse.get(edge.target)?.push(edge.source);
+            const componentId = decodeURIComponent(match[1]);
+            const node = arch.nodes.find((n) => n.id === componentId);
+            if (!node) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: `Component not found: ${componentId}` }));
+                return;
             }
-            const nodeMap = new Map();
-            for (const nd of arch.nodes)
-                nodeMap.set(nd.id, nd);
-            // BFS helper
-            function bfs(startId, adj, maxDepth) {
-                const visited = new Map();
-                visited.set(startId, 0);
-                const queue = [{ id: startId, d: 0 }];
-                const result = [];
-                while (queue.length > 0) {
-                    const { id, d } = queue.shift();
-                    if (d >= maxDepth)
-                        continue;
-                    for (const neighbor of adj.get(id) || []) {
-                        if (!visited.has(neighbor)) {
-                            const nd = d + 1;
-                            visited.set(neighbor, nd);
-                            result.push({ id: neighbor, label: nodeMap.get(neighbor)?.label.split("\n")[0] || neighbor, depth: nd });
-                            queue.push({ id: neighbor, d: nd });
-                        }
+            const nodePath = node.path;
+            if (!nodePath) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: `Component "${node.label}" has no path` }));
+                return;
+            }
+            try {
+                const { runDeepDrill } = await import("../../agents/static/deep-drill.js");
+                const result = await runDeepDrill(config.workspaceRoot, componentId, node.label.split("\n")[0], nodePath);
+                // Enrich with connection data from architecture edges
+                const outgoing = [];
+                const incoming = [];
+                const nodeMap = new Map();
+                for (const n of arch.nodes)
+                    nodeMap.set(n.id, n);
+                for (const edge of arch.edges) {
+                    if (edge.source === componentId) {
+                        const target = nodeMap.get(edge.target);
+                        outgoing.push({
+                            targetId: edge.target,
+                            targetName: target?.label.split("\n")[0] || edge.target,
+                            type: edge.label || "depends-on",
+                            description: edge.label || "",
+                        });
+                    }
+                    if (edge.target === componentId) {
+                        const source = nodeMap.get(edge.source);
+                        incoming.push({
+                            sourceId: edge.source,
+                            sourceName: source?.label.split("\n")[0] || edge.source,
+                            type: edge.label || "depends-on",
+                            description: edge.label || "",
+                        });
                     }
                 }
-                return result;
-            }
-            const upstream = (direction === "downstream") ? [] : bfs(nodeId, reverse, depth);
-            const downstream = (direction === "upstream") ? [] : bfs(nodeId, forward, depth);
-            // Collect all affected node IDs (including origin)
-            const affectedSet = new Set([nodeId]);
-            for (const n of upstream)
-                affectedSet.add(n.id);
-            for (const n of downstream)
-                affectedSet.add(n.id);
-            // Affected edges: edges between any two nodes in the affected set
-            const affectedEdges = [];
-            for (const edge of arch.edges) {
-                if (affectedSet.has(edge.source) && affectedSet.has(edge.target)) {
-                    affectedEdges.push(edge.id);
-                }
+                result.connections = { outgoing, incoming };
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(result));
+            }
+            catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: String(error) }));
             }
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                nodeId,
-                upstream,
-                downstream,
-                affectedEdges,
-                totalAffected: affectedSet.size - 1,
-            }));
             return;
         }
         // API: Audit — unified validation + health endpoint
-        if ((url === "/api/audit" || url === "/api/validate") && req.method === "GET") {
+        if (url === "/api/audit" && req.method === "GET") {
             const arch = currentArchitecture || (await loadArchitecture());
             if (!arch) {
                 res.writeHead(404, { "Content-Type": "application/json" });
@@ -937,51 +954,13 @@ function createHttpServer() {
             res.end(content);
             return;
         }
-        // API: Patrol history
-        if (url === "/api/patrol/latest" && req.method === "GET") {
-            const latestPath = path.join(config.workspaceRoot, ".archbyte/patrols/latest.json");
-            if (!existsSync(latestPath)) {
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify(null));
-                return;
-            }
-            try {
-                const content = readFileSync(latestPath, "utf-8");
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(content);
-            }
-            catch {
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify(null));
-            }
-            return;
-        }
-        if (url === "/api/patrol/history" && req.method === "GET") {
-            const historyPath = path.join(config.workspaceRoot, ".archbyte/patrols/history.jsonl");
-            if (!existsSync(historyPath)) {
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify([]));
-                return;
-            }
-            try {
-                const content = readFileSync(historyPath, "utf-8");
-                const records = content.trim().split("\n").filter(Boolean).slice(-50).map((line) => JSON.parse(line));
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify(records));
-            }
-            catch {
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify([]));
-            }
-            return;
-        }
         // API: Workflow list and status
         if (url === "/api/workflow/list" && req.method === "GET") {
             const workflows = [];
             // Built-in workflows
             const builtins = [
-                { id: "full-analysis", name: "Full Analysis Pipeline", description: "Complete architecture pipeline", steps: ["generate", "validate", "stats", "export"] },
-                { id: "ci-check", name: "CI Architecture Check", description: "Lightweight CI pipeline", steps: ["validate"] },
+                { id: "full-analysis", name: "Full Analysis Pipeline", description: "Complete architecture pipeline", steps: ["generate", "stats", "export"] },
+                { id: "ci-check", name: "CI Architecture Check", description: "Lightweight CI pipeline", steps: ["stats"] },
                 { id: "drift-check", name: "Architecture Drift Check", description: "Check for architecture drift", steps: ["snapshot", "generate", "diff"] },
             ];
             for (const b of builtins) {
@@ -1168,6 +1147,18 @@ function createHttpServer() {
             res.end(JSON.stringify({ running: runningWorkflows.has("__generate__") }));
             return;
         }
+        // API: Reload — re-read architecture, reconcile pending changes
+        if (url === "/api/reload" && req.method === "POST") {
+            currentArchitecture = await loadArchitecture();
+            reconcilePendingWithGit();
+            broadcastUpdate();
+            if (pendingSourceChanges.size > 0) {
+                broadcastPendingChanges();
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
         // API: Run analyze (static or LLM) + generate
         if (url === "/api/analyze" && req.method === "POST") {
             if (isAnalyzing) {
@@ -1197,6 +1188,21 @@ function createHttpServer() {
             res.end(JSON.stringify(sessionChanges));
             return;
         }
+        // API: Pending source file changes — hydrates UI on reconnect
+        if (url === "/api/changes/pending" && req.method === "GET") {
+            const changes = Array.from(pendingSourceChanges.values()).map((c) => ({ event: c.event, path: c.path }));
+            const count = changes.length;
+            const { componentChanges, unmapped } = mapFilesToComponents(changes, currentArchitecture);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                count,
+                files: changes.slice(0, 20).map((c) => ({ event: c.event, path: c.path })),
+                componentChanges,
+                unmapped,
+                truncated: count > 20,
+            }));
+            return;
+        }
         // API: Run workflow
         if (url.startsWith("/api/workflow/run/") && req.method === "POST") {
             const id = url.split("/").pop();
@@ -1269,56 +1275,6 @@ function createHttpServer() {
             });
             return;
         }
-        // API: Start patrol
-        if (url === "/api/patrol/start" && req.method === "POST") {
-            if (patrolRunning) {
-                res.writeHead(409, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: "Patrol already running" }));
-                return;
-            }
-            let body = "";
-            req.on("data", (chunk) => { body += chunk.toString(); });
-            req.on("end", () => {
-                const { interval } = JSON.parse(body || "{}");
-                const bin = getArchbyteBin();
-                const args = [bin, "patrol"];
-                if (interval)
-                    args.push("--interval", String(interval));
-                patrolProcess = spawn(process.execPath, args, {
-                    cwd: config.workspaceRoot,
-                    stdio: ["ignore", "inherit", "inherit"],
-                    env: { ...process.env, FORCE_COLOR: "1" },
-                });
-                patrolRunning = true;
-                broadcastOpsEvent({ type: "patrol:started" });
-                patrolProcess.on("close", () => {
-                    patrolProcess = null;
-                    patrolRunning = false;
-                    broadcastOpsEvent({ type: "patrol:stopped" });
-                });
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ ok: true }));
-            });
-            return;
-        }
-        // API: Stop patrol
-        if (url === "/api/patrol/stop" && req.method === "POST") {
-            if (patrolProcess) {
-                patrolProcess.kill("SIGTERM");
-                patrolProcess = null;
-                patrolRunning = false;
-                broadcastOpsEvent({ type: "patrol:stopped" });
-            }
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: true }));
-            return;
-        }
-        // API: Patrol running status
-        if (url === "/api/patrol/running" && req.method === "GET") {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ running: patrolRunning }));
-            return;
-        }
         // API: Config — read project config (including provider settings)
         if (url === "/api/config" && req.method === "GET") {
             const configPath = path.join(config.workspaceRoot, ".archbyte/config.json");
@@ -1732,12 +1688,23 @@ function diffArchitectures(prev, curr) {
         .map((e) => ({ source: e.source, target: e.target, label: e.label }));
     return { addedNodes, removedNodes, modifiedNodes, addedEdges, removedEdges };
 }
-// Run analyze → generate pipeline (used by /api/analyze and patrol)
+// Run analyze → generate pipeline (used by /api/analyze)
 function runAnalyzePipeline(mode = "static", fileChanges) {
     if (isAnalyzing)
         return;
     isAnalyzing = true;
     const pipelineStart = Date.now();
+    // Capture and clear pending source changes
+    if (!fileChanges) {
+        fileChanges = Array.from(pendingSourceChanges.values()).map((c) => ({ event: c.event, path: c.path }));
+    }
+    pendingSourceChanges.clear();
+    savePendingChanges();
+    if (changeDebounceTimer) {
+        clearTimeout(changeDebounceTimer);
+        changeDebounceTimer = null;
+    }
+    broadcastOpsEvent({ type: "changes:cleared" });
     // Snapshot current architecture for diffing after pipeline completes
     const prevArchitecture = currentArchitecture
         ? { ...currentArchitecture, nodes: [...currentArchitecture.nodes], edges: [...currentArchitecture.edges] }
@@ -1752,10 +1719,14 @@ function runAnalyzePipeline(mode = "static", fileChanges) {
         stdio: ["ignore", "pipe", "pipe"],
         env: { ...process.env, FORCE_COLOR: "0" },
     });
+    let analyzeStderr = "";
+    analyzeChild.stdout?.on("data", (d) => process.stderr.write(`[analyze] ${d}`));
+    analyzeChild.stderr?.on("data", (d) => { analyzeStderr += d; process.stderr.write(`[analyze] ${d}`); });
     analyzeChild.on("close", (analyzeCode) => {
         if (analyzeCode !== 0) {
             isAnalyzing = false;
-            broadcastOpsEvent({ type: "analyzing:finished", code: analyzeCode, success: false });
+            const errMsg = analyzeStderr.trim().split("\n").pop() || `Analyze failed (exit ${analyzeCode})`;
+            broadcastOpsEvent({ type: "analyzing:finished", code: analyzeCode, success: false, error: errMsg });
             return;
         }
         // Chain: generate after successful analyze
@@ -1764,6 +1735,8 @@ function runAnalyzePipeline(mode = "static", fileChanges) {
             stdio: ["ignore", "pipe", "pipe"],
             env: { ...process.env, FORCE_COLOR: "0" },
         });
+        genChild.stdout?.on("data", (d) => process.stderr.write(`[generate] ${d}`));
+        genChild.stderr?.on("data", (d) => process.stderr.write(`[generate] ${d}`));
         genChild.on("close", async (genCode) => {
             isAnalyzing = false;
             const durationMs = Date.now() - pipelineStart;
@@ -1828,6 +1801,144 @@ function setupWatcher() {
         broadcastUpdate();
     });
 }
+// Map changed file paths to architecture components using longest-prefix matching
+function mapFilesToComponents(changes, arch) {
+    if (!arch || arch.nodes.length === 0) {
+        return { componentChanges: [], unmapped: changes.map((c) => ({ path: c.path, event: c.event })) };
+    }
+    // Build sorted list of component paths (longest first for greedy matching)
+    const componentPaths = arch.nodes
+        .filter((n) => n.path)
+        .map((n) => ({ id: n.id, name: n.label.split("\n")[0], path: n.path }))
+        .sort((a, b) => b.path.length - a.path.length);
+    const groups = new Map();
+    const unmapped = [];
+    for (const change of changes) {
+        let matched = false;
+        for (const comp of componentPaths) {
+            const prefix = comp.path.endsWith("/") ? comp.path : `${comp.path}/`;
+            if (change.path.startsWith(prefix) || change.path === comp.path) {
+                if (!groups.has(comp.id)) {
+                    groups.set(comp.id, { componentId: comp.id, componentName: comp.name, files: [] });
+                }
+                groups.get(comp.id).files.push({ path: change.path, event: change.event });
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            unmapped.push({ path: change.path, event: change.event });
+        }
+    }
+    return {
+        componentChanges: Array.from(groups.values()),
+        unmapped,
+    };
+}
+// Broadcast pending source changes to SSE clients
+function broadcastPendingChanges() {
+    const changes = Array.from(pendingSourceChanges.values()).map((c) => ({ event: c.event, path: c.path }));
+    const count = changes.length;
+    const truncated = count > 20;
+    const { componentChanges, unmapped } = mapFilesToComponents(changes, currentArchitecture);
+    broadcastOpsEvent({
+        type: "changes:detected",
+        count,
+        files: changes.slice(0, 20).map((c) => c.path),
+        componentChanges,
+        unmapped,
+        truncated,
+    });
+}
+// Setup source file watcher — watches workspace for code changes
+function setupSourceWatcher() {
+    sourceWatcher = watch(config.workspaceRoot, {
+        ignoreInitial: true,
+        ignored: [
+            /(^|[/\\])\../, // dotfiles/dirs
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/out/**",
+            "**/.archbyte/**",
+            "**/coverage/**",
+            "**/*.lock",
+            "**/package-lock.json",
+            "**/__pycache__/**",
+            "**/target/**",
+            "**/vendor/**",
+        ],
+        depth: 10,
+    });
+    sourceWatcher.on("all", (event, filePath) => {
+        if (event !== "change" && event !== "add" && event !== "unlink")
+            return;
+        const relativePath = path.relative(config.workspaceRoot, filePath);
+        pendingSourceChanges.set(relativePath, {
+            event,
+            path: relativePath,
+            timestamp: Date.now(),
+        });
+        // Debounce: reset timer on each change, broadcast after settling
+        if (changeDebounceTimer)
+            clearTimeout(changeDebounceTimer);
+        changeDebounceTimer = setTimeout(() => {
+            changeDebounceTimer = null;
+            broadcastPendingChanges();
+            savePendingChanges();
+        }, CHANGE_DEBOUNCE_MS);
+    });
+}
+// Watch for git commits — reconcile pending changes against actual dirty files
+let gitWatcher = null;
+let gitDebounceTimer = null;
+function setupGitWatcher() {
+    const gitIndex = path.join(config.workspaceRoot, ".git", "index");
+    if (!existsSync(gitIndex))
+        return;
+    gitWatcher = watch(gitIndex, { ignoreInitial: true, depth: 0 });
+    gitWatcher.on("change", () => {
+        // Debounce — git writes the index multiple times during a commit
+        if (gitDebounceTimer)
+            clearTimeout(gitDebounceTimer);
+        gitDebounceTimer = setTimeout(() => {
+            gitDebounceTimer = null;
+            reconcilePendingWithGit();
+        }, 1000);
+    });
+}
+function reconcilePendingWithGit() {
+    if (pendingSourceChanges.size === 0)
+        return;
+    try {
+        // Get files that are still dirty (modified, untracked, staged)
+        const output = execSync("git status --porcelain", {
+            cwd: config.workspaceRoot,
+            encoding: "utf-8",
+            timeout: 5000,
+        });
+        const dirtyFiles = new Set(output.trim().split("\n").filter(Boolean).map((line) => line.slice(3).trim()));
+        let changed = false;
+        for (const [filePath] of pendingSourceChanges) {
+            if (!dirtyFiles.has(filePath)) {
+                pendingSourceChanges.delete(filePath);
+                changed = true;
+            }
+        }
+        if (changed) {
+            savePendingChanges();
+            if (pendingSourceChanges.size === 0) {
+                broadcastOpsEvent({ type: "changes:cleared" });
+            }
+            else {
+                broadcastPendingChanges();
+            }
+        }
+    }
+    catch {
+        // Not a git repo or git not available — ignore
+    }
+}
 // Graceful shutdown
 function setupShutdown() {
     const shutdown = async () => {
@@ -1840,14 +1951,6 @@ function setupShutdown() {
             catch { }
         }
         runningWorkflows.clear();
-        if (patrolProcess) {
-            try {
-                patrolProcess.kill("SIGTERM");
-            }
-            catch { }
-            patrolProcess = null;
-            patrolRunning = false;
-        }
         if (chatProcess) {
             try {
                 chatProcess.kill("SIGTERM");
@@ -1862,7 +1965,9 @@ function setupShutdown() {
             catch { }
         }
         sseClients.clear();
+        await sourceWatcher?.close();
         await diagramWatcher?.close();
+        await gitWatcher?.close();
         httpServer?.close();
         process.exit(0);
     };
@@ -1878,8 +1983,7 @@ function loadLicenseInfo() {
         tier: "free",
         features: {
             analyze: true,
-            validate: false,
-            patrol: false,
+            audit: false,
             workflows: false,
             chat: false,
             premiumAgents: false,
@@ -1931,8 +2035,7 @@ function loadLicenseInfo() {
             tier: isPremium ? "premium" : "free",
             features: {
                 analyze: true,
-                validate: isPremium,
-                patrol: isPremium,
+                audit: isPremium,
                 workflows: isPremium,
                 chat: isPremium,
                 premiumAgents: isPremium,
@@ -1955,7 +2058,12 @@ export async function startServer(cfg) {
         console.error("[archbyte] Failed to start HTTP server:", err);
         process.exit(1);
     }
+    currentArchitecture = await loadArchitecture();
     setupWatcher();
+    loadPendingChanges();
+    reconcilePendingWithGit();
+    setupSourceWatcher();
+    setupGitWatcher();
     console.error(`[archbyte] Serving ${config.name}`);
     console.error(`[archbyte] Diagram: ${config.diagramPath}`);
     // Listen for 'q' keypress to quit gracefully

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archbyte",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "ArchByte - See what agents build. As they build it.",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
-    "@google/genai": "^1.41.0",
+    "@google/genai": "^1.42.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "chalk": "^5.3.0",
     "chokidar": "^3.5.3",

package/templates/archbyte.yaml

@@ -102,10 +102,31 @@ rules:
   #     to: { type: external }
   #     level: warn
 
-# ── Patrol ──
-# Configure the continuous monitoring daemon (archbyte patrol).
-# patrol:
-#   ignore:
-#     - "docs/"
-#     - "*.md"
-#     - "scripts/"
+# ── Workflows ──
+# Composable multi-step architecture pipelines.
+# Run built-in workflows:
+#   archbyte workflow --list           # see available workflows
+#   archbyte workflow --run full-analysis
+#   archbyte workflow --run ci-check
+#   archbyte workflow --run drift-check
+#
+# Create custom workflows in .archbyte/workflows/:
+#   archbyte workflow --create "My Pipeline"
+#
+# Custom workflow format (.archbyte/workflows/my-pipeline.yaml):
+# id: my-pipeline
+# name: "My Pipeline"
+# description: "Custom architecture pipeline"
+# steps:
+#   - id: generate
+#     name: "Generate Diagram"
+#     command: "archbyte generate"
+#     needs: []
+#   - id: validate
+#     name: "Validate"
+#     command: "archbyte validate"
+#     needs: [generate]
+#   - id: export
+#     name: "Export"
+#     command: "archbyte export --format mermaid"
+#     needs: [validate]