monarch-code-graph 0.3.4 → 0.3.5

package/dist/cli.js

@@ -1,100 +1,2636 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { analyzeCommand } from './commands/analyze.js';
-import { diffCommand } from './commands/diff.js';
-import { serveCommand } from './commands/serve.js';
-import { initCommand } from './commands/init.js';
-import { listCommand } from './commands/list.js';
-import { helpCommand } from './commands/help.js';
-import { runCommand } from './commands/run.js';
-import { graphCommand } from './commands/graph.js';
-const program = new Command();
-program
-    .name('monarch')
-    .description('Monarch - Static codebase flow mapping and visualization')
-    .version('0.1.0')
-    .addHelpCommand(false);
-// Initialize a new Monarch project
-program
-    .command('init')
-    .description('Initialize a new Monarch project in the current directory')
-    .option('-f, --force', 'Overwrite existing configuration', false)
-    .action(initCommand);
-// Analyze a codebase and generate flow artifact
-program
-    .command('analyze')
-    .alias('a')
-    .description('Analyze a codebase and generate flow artifact')
-    .argument('[path]', 'Path to the codebase', '.')
-    .option('-o, --output <path>', 'Output artifact path', 'monarch-graph.json')
-    .option('-e, --exporter <name>', 'Exporter to use (mock, codeql-ts)', 'mock')
-    .option('-w, --watch', 'Watch for changes and re-analyze', false)
-    .action(analyzeCommand);
-// Compare two artifacts
-program
-    .command('diff')
-    .alias('d')
-    .description('Compare two graph artifacts and show changes')
-    .argument('<baseline>', 'Path to baseline artifact')
-    .argument('<current>', 'Path to current artifact')
-    .option('-f, --format <type>', 'Output format (text, json, markdown)', 'text')
-    .option('--exit-on-changes', 'Exit with code 1 if changes detected', false)
-    .option('--only <type>', 'Show only specific changes (functions, modules, edges)')
-    .action(diffCommand);
-// Start visualization server
-program
-    .command('serve')
-    .alias('s')
-    .description('Start the visualization UI server')
-    .option('-p, --port <number>', 'Port to serve on', '3000')
-    .option('-a, --artifact <path>', 'Artifact file path', 'monarch-graph.json')
-    .option('--open', 'Open browser automatically', false)
-    .action(serveCommand);
-// List contents of an artifact
-program
-    .command('list')
-    .alias('ls')
-    .description('List contents of a graph artifact')
-    .argument('[artifact]', 'Path to artifact file', 'monarch-graph.json')
-    .option('-t, --type <type>', 'Filter by type (functions, modules, components, edges)')
-    .option('--json', 'Output as JSON', false)
-    .action(listCommand);
-// Run: analyze, detect changes, and start server (all-in-one)
-program
-    .command('run')
-    .alias('r')
-    .description('Analyze codebase, detect changes, and start visualization server')
-    .argument('[path]', 'Path to the codebase', '.')
-    .option('-o, --output <path>', 'Output artifact path', 'monarch-graph.json')
-    .option('-e, --exporter <name>', 'Exporter to use (mock, codeql-ts)', 'mock')
-    .option('-p, --port <number>', 'Port for visualization server', '3000')
-    .option('--open', 'Open browser automatically', false)
-    .option('-f, --force', 'Force regeneration even if no changes', false)
-    .action(runCommand);
-// Graph: render ASCII graph in terminal
-program
-    .command('graph')
-    .alias('g')
-    .description('Render ASCII graph visualization in terminal')
-    .argument('[artifact]', 'Path to artifact file', 'monarch-graph.json')
-    .option('-l, --level <level>', 'View level (components, modules, functions)', 'modules')
-    .option('-x, --expand <name>', 'Expand a specific component or module by name')
-    .option('--expand-type <type>', 'Type of item to expand (component, module)')
-    .option('--list', 'List expandable components and modules', false)
-    .option('--no-color', 'Disable colored output')
-    .option('-w, --width <cols>', 'Max output width in columns')
-    .action(graphCommand);
-// Comprehensive help command
-program
-    .command('help')
-    .description('Show detailed help for Monarch or a specific command')
-    .argument('[command]', 'Command to get help for')
-    .action(helpCommand);
-// Show custom help when no command is provided
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../shared/dist/schemas/artifact.js
+function isCodeFlowArtifact(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const artifact = obj;
+  return typeof artifact.metadata === "object" && typeof artifact.nodes === "object" && typeof artifact.edges === "object" && typeof artifact.layout === "object";
+}
+var init_artifact = __esm({
+  "../shared/dist/schemas/artifact.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/utils/hashing.js
+function generateStableId(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  const positiveHash = hash >>> 0;
+  return positiveHash.toString(16).padStart(8, "0");
+}
+function generateFunctionId(file, name, startLine) {
+  const input = `fn:${file}:${name}:${startLine}`;
+  return `fn-${generateStableId(input)}`;
+}
+function generateModuleId(path14) {
+  const input = `mod:${path14}`;
+  return `mod-${generateStableId(input)}`;
+}
+function generateComponentId(name) {
+  const input = `comp:${name}`;
+  return `comp-${generateStableId(input)}`;
+}
+var init_hashing = __esm({
+  "../shared/dist/utils/hashing.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/index.js
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    "use strict";
+    init_artifact();
+    init_hashing();
+  }
+});
+
+// ../analyzer/dist/exporters/mock-exporter.js
+import fs from "fs";
+import path from "path";
+var MockExporter;
+var init_mock_exporter = __esm({
+  "../analyzer/dist/exporters/mock-exporter.js"() {
+    "use strict";
+    init_dist();
+    MockExporter = class {
+      targetPath;
+      files = [];
+      functions = [];
+      modules = [];
+      components = [];
+      callEdges = [];
+      dataflowEdges = [];
+      constructor(targetPath) {
+        this.targetPath = targetPath;
+      }
+      async prepare() {
+        this.files = this.scanTsFiles(this.targetPath);
+        console.log(`Found ${this.files.length} TypeScript files`);
+      }
+      async analyze() {
+        for (const file of this.files) {
+          const relativePath = path.relative(this.targetPath, file);
+          this.processFile(relativePath);
+        }
+        this.generateCallEdges();
+        this.generateDataflowEdges();
+        this.generateComponents();
+      }
+      async export() {
+        return {
+          metadata: {
+            analyzerVersion: "0.1.0",
+            language: "typescript",
+            repoCommit: this.generateCommitHash(),
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            configHash: this.generateConfigHash()
+          },
+          nodes: {
+            functions: this.sortById(this.functions),
+            modules: this.sortById(this.modules),
+            components: this.sortById(this.components)
+          },
+          edges: {
+            calls: this.sortEdges(this.callEdges),
+            dataflow: this.sortEdges(this.dataflowEdges)
+          },
+          layout: {
+            positions: {}
+          }
+        };
+      }
+      async cleanup() {
+      }
+      scanTsFiles(dir) {
+        const results = [];
+        if (!fs.existsSync(dir)) {
+          return results;
+        }
+        const stat = fs.statSync(dir);
+        if (stat.isFile() && (dir.endsWith(".ts") || dir.endsWith(".tsx"))) {
+          if (!dir.includes(".test.") && !dir.includes(".spec.") && !dir.endsWith(".d.ts")) {
+            results.push(dir);
+          }
+          return results;
+        }
+        if (!stat.isDirectory()) {
+          return results;
+        }
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+          if (entry === "node_modules" || entry.startsWith(".") || entry === "dist") {
+            continue;
+          }
+          const fullPath = path.join(dir, entry);
+          results.push(...this.scanTsFiles(fullPath));
+        }
+        return results.sort();
+      }
+      processFile(relativePath) {
+        const moduleId = generateModuleId(relativePath);
+        const moduleNode = {
+          id: moduleId,
+          path: relativePath,
+          functionIds: []
+        };
+        const fnCount = 2 + this.hashString(relativePath) % 3;
+        const baseName = path.basename(relativePath, path.extname(relativePath));
+        for (let i = 0; i < fnCount; i++) {
+          const fnName = this.generateFunctionName(baseName, i);
+          const startLine = 10 + i * 20;
+          const fnId = generateFunctionId(relativePath, fnName, startLine);
+          const fn = {
+            id: fnId,
+            name: fnName,
+            fullyQualifiedName: `${relativePath}::${fnName}`,
+            file: relativePath,
+            startLine,
+            endLine: startLine + 15,
+            kind: i === 0 ? "function" : i === 1 ? "arrow" : "method"
+          };
+          this.functions.push(fn);
+          moduleNode.functionIds.push(fnId);
+        }
+        this.modules.push(moduleNode);
+      }
+      generateFunctionName(baseName, index) {
+        const prefixes = ["handle", "process", "get", "set", "create", "update", "delete"];
+        const prefix = prefixes[(this.hashString(baseName) + index) % prefixes.length];
+        const camelName = baseName.charAt(0).toUpperCase() + baseName.slice(1);
+        return `${prefix}${camelName}${index > 0 ? index : ""}`;
+      }
+      generateCallEdges() {
+        for (let i = 0; i < this.functions.length; i++) {
+          const caller = this.functions[i];
+          const callCount = this.hashString(caller.id) % 3;
+          for (let j = 0; j < callCount; j++) {
+            const targetIndex = (i + j + 1) % this.functions.length;
+            if (targetIndex === i)
+              continue;
+            const callee = this.functions[targetIndex];
+            if (this.callEdges.some((e) => e.from === caller.id && e.to === callee.id)) {
+              continue;
+            }
+            this.callEdges.push({
+              from: caller.id,
+              to: callee.id,
+              callsites: [
+                {
+                  file: caller.file,
+                  line: caller.startLine + 5
+                }
+              ]
+            });
+          }
+        }
+      }
+      generateDataflowEdges() {
+        if (this.functions.length < 2)
+          return;
+        const sources = this.functions.filter((fn) => fn.name.startsWith("handle") || fn.name.startsWith("get"));
+        const sinks = this.functions.filter((fn) => fn.name.startsWith("create") || fn.name.startsWith("update") || fn.name.startsWith("set"));
+        for (const source of sources.slice(0, 2)) {
+          for (const sink of sinks.slice(0, 2)) {
+            if (source.id === sink.id)
+              continue;
+            this.dataflowEdges.push({
+              from: source.id,
+              to: sink.id,
+              label: `data from ${source.name} to ${sink.name}`,
+              evidence: [`${source.name} data flows to ${sink.name}`]
+            });
+          }
+        }
+      }
+      generateComponents() {
+        const dirToModules = /* @__PURE__ */ new Map();
+        for (const mod of this.modules) {
+          const dir = path.dirname(mod.path) || "root";
+          if (!dirToModules.has(dir)) {
+            dirToModules.set(dir, []);
+          }
+          dirToModules.get(dir).push(mod);
+        }
+        for (const [dir, modules] of dirToModules) {
+          const compName = dir === "." || dir === "root" ? "main" : dir.replace(/\//g, "-");
+          const compId = generateComponentId(compName);
+          this.components.push({
+            id: compId,
+            name: compName,
+            moduleIds: modules.map((m) => m.id)
+          });
+        }
+      }
+      hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+          const char = str.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return Math.abs(hash);
+      }
+      generateCommitHash() {
+        const input = this.files.sort().join("");
+        return `mock-${this.hashString(input).toString(16).padStart(8, "0")}`;
+      }
+      generateConfigHash() {
+        return "mock-config-hash";
+      }
+      sortById(items) {
+        return [...items].sort((a, b) => a.id.localeCompare(b.id));
+      }
+      sortEdges(edges) {
+        return [...edges].sort((a, b) => {
+          const fromCmp = a.from.localeCompare(b.from);
+          return fromCmp !== 0 ? fromCmp : a.to.localeCompare(b.to);
+        });
+      }
+    };
+  }
+});
+
+// ../analyzer/dist/exporters/codeql/query-runner.js
+import { execSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+var QueryRunner;
+var init_query_runner = __esm({
+  "../analyzer/dist/exporters/codeql/query-runner.js"() {
+    "use strict";
+    QueryRunner = class {
+      dbPath;
+      queriesPath;
+      targetPath;
+      constructor(dbPath, queriesPath, targetPath) {
+        this.dbPath = dbPath;
+        this.queriesPath = queriesPath;
+        this.targetPath = targetPath;
+      }
+      async runQuery(queryFile) {
+        const queryPath = path2.join(this.queriesPath, queryFile);
+        const outputPath = path2.join(this.targetPath, `.codeql-results-${queryFile}.json`);
+        try {
+          execSync(`codeql query run --database="${this.dbPath}" --output="${outputPath}" --format=json "${queryPath}"`, {
+            stdio: "pipe",
+            cwd: this.targetPath
+          });
+          if (fs2.existsSync(outputPath)) {
+            const content = fs2.readFileSync(outputPath, "utf-8");
+            const data = JSON.parse(content);
+            fs2.unlinkSync(outputPath);
+            return this.parseCodeQLResults(data, queryFile);
+          }
+        } catch (error) {
+          console.warn(`    Warning: Query ${queryFile} failed: ${error}`);
+        }
+        return [];
+      }
+      parseCodeQLResults(data, queryFile) {
+        if (!data || typeof data !== "object")
+          return [];
+        const results = [];
+        if ("#select" in data && Array.isArray(data["#select"])) {
+          const tuples = data["#select"];
+          const columns = this.getColumnsForQuery(queryFile);
+          for (const tuple of tuples) {
+            const obj = {};
+            for (let i = 0; i < columns.length && i < tuple.length; i++) {
+              obj[columns[i]] = tuple[i];
+            }
+            results.push(obj);
+          }
+        }
+        return results;
+      }
+      getColumnsForQuery(queryFile) {
+        switch (queryFile) {
+          case "functions.ql":
+            return ["_element", "name", "file", "startLine", "endLine", "kind"];
+          case "calls.ql":
+            return [
+              "callerName",
+              "callerFile",
+              "callerStartLine",
+              "calleeName",
+              "calleeFile",
+              "calleeStartLine",
+              "callsiteLine",
+              "callsiteFile"
+            ];
+          case "dataflow.ql":
+            return [
+              "_element",
+              "_source",
+              "_sink",
+              "sourceFunction",
+              "sourceFile",
+              "sourceStartLine",
+              "sinkFunction",
+              "sinkFile",
+              "sinkStartLine"
+            ];
+          default:
+            return [];
+        }
+      }
+    };
+  }
+});
+
+// ../analyzer/dist/exporters/codeql/codeql-exporter.js
+import { execSync as execSync2 } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+var CodeQLExporter;
+var init_codeql_exporter = __esm({
+  "../analyzer/dist/exporters/codeql/codeql-exporter.js"() {
+    "use strict";
+    init_dist();
+    init_query_runner();
+    CodeQLExporter = class {
+      targetPath;
+      dbPath;
+      queriesPath;
+      queryRunner;
+      functions = [];
+      modules = [];
+      components = [];
+      callEdges = [];
+      dataflowEdges = [];
+      functionIdMap = /* @__PURE__ */ new Map();
+      constructor(targetPath) {
+        this.targetPath = path3.resolve(targetPath);
+        this.dbPath = path3.join(this.targetPath, ".codeql-db");
+        this.queriesPath = path3.join(__dirname, "queries");
+        this.queryRunner = new QueryRunner(this.dbPath, this.queriesPath, this.targetPath);
+      }
+      async prepare() {
+        try {
+          execSync2("codeql --version", { stdio: "pipe" });
+        } catch {
+          throw new Error("CodeQL CLI is not installed. Please install it from https://github.com/github/codeql-cli-binaries");
+        }
+        console.log("Creating CodeQL database...");
+        await this.createDatabase();
+      }
+      async createDatabase() {
+        if (fs3.existsSync(this.dbPath)) {
+          fs3.rmSync(this.dbPath, { recursive: true });
+        }
+        try {
+          execSync2(`codeql database create "${this.dbPath}" --language=javascript --source-root="${this.targetPath}" --overwrite`, {
+            stdio: "inherit",
+            cwd: this.targetPath
+          });
+        } catch (error) {
+          throw new Error(`Failed to create CodeQL database: ${error}`);
+        }
+      }
+      async analyze() {
+        console.log("Running CodeQL queries...");
+        await this.runFunctionsQuery();
+        await this.runCallsQuery();
+        await this.runDataflowQuery();
+        this.buildModulesAndComponents();
+      }
+      async runFunctionsQuery() {
+        console.log("  Extracting functions...");
+        const results = await this.queryRunner.runQuery("functions.ql");
+        for (const result of results) {
+          const fnId = generateFunctionId(result.file, result.name, result.startLine);
+          const key = `${result.file}:${result.name}:${result.startLine}`;
+          this.functionIdMap.set(key, fnId);
+          this.functions.push({
+            id: fnId,
+            name: result.name,
+            fullyQualifiedName: `${result.file}::${result.name}`,
+            file: result.file,
+            startLine: result.startLine,
+            endLine: result.endLine,
+            kind: this.normalizeKind(result.kind)
+          });
+        }
+        console.log(`    Found ${this.functions.length} functions`);
+      }
+      async runCallsQuery() {
+        console.log("  Extracting call edges...");
+        const results = await this.queryRunner.runQuery("calls.ql");
+        const edgeMap = /* @__PURE__ */ new Map();
+        for (const result of results) {
+          const callerId = this.getFunctionId(result.callerFile, result.callerName, result.callerStartLine);
+          const calleeId = this.getFunctionId(result.calleeFile, result.calleeName, result.calleeStartLine);
+          if (!callerId || !calleeId)
+            continue;
+          const edgeKey = `${callerId}->${calleeId}`;
+          if (edgeMap.has(edgeKey)) {
+            edgeMap.get(edgeKey).callsites.push({
+              file: result.callsiteFile,
+              line: result.callsiteLine
+            });
+          } else {
+            edgeMap.set(edgeKey, {
+              from: callerId,
+              to: calleeId,
+              callsites: [{ file: result.callsiteFile, line: result.callsiteLine }]
+            });
+          }
+        }
+        this.callEdges = Array.from(edgeMap.values());
+        console.log(`    Found ${this.callEdges.length} call edges`);
+      }
+      async runDataflowQuery() {
+        console.log("  Extracting dataflow edges...");
+        const results = await this.queryRunner.runQuery("dataflow.ql");
+        const edgeMap = /* @__PURE__ */ new Map();
+        for (const result of results) {
+          const sourceId = this.getFunctionId(result.sourceFile, result.sourceFunction, result.sourceStartLine);
+          const sinkId = this.getFunctionId(result.sinkFile, result.sinkFunction, result.sinkStartLine);
+          if (!sourceId || !sinkId || sourceId === sinkId)
+            continue;
+          const edgeKey = `${sourceId}->${sinkId}`;
+          if (!edgeMap.has(edgeKey)) {
+            edgeMap.set(edgeKey, {
+              from: sourceId,
+              to: sinkId,
+              label: `data from ${result.sourceFunction} to ${result.sinkFunction}`,
+              evidence: []
+            });
+          }
+          edgeMap.get(edgeKey).evidence.push(`Flow from ${result.sourceFile}:${result.sourceStartLine} to ${result.sinkFile}:${result.sinkStartLine}`);
+        }
+        this.dataflowEdges = Array.from(edgeMap.values());
+        console.log(`    Found ${this.dataflowEdges.length} dataflow edges`);
+      }
+      getFunctionId(file, name, startLine) {
+        return this.functionIdMap.get(`${file}:${name}:${startLine}`);
+      }
+      normalizeKind(kind) {
+        switch (kind.toLowerCase()) {
+          case "arrow":
+            return "arrow";
+          case "method":
+            return "method";
+          case "constructor":
+            return "constructor";
+          default:
+            return "function";
+        }
+      }
+      buildModulesAndComponents() {
+        const fileToFunctions = /* @__PURE__ */ new Map();
+        for (const fn of this.functions) {
+          if (!fileToFunctions.has(fn.file)) {
+            fileToFunctions.set(fn.file, []);
+          }
+          fileToFunctions.get(fn.file).push(fn);
+        }
+        for (const [file, fns] of fileToFunctions) {
+          this.modules.push({
+            id: generateModuleId(file),
+            path: file,
+            functionIds: fns.map((f) => f.id)
+          });
+        }
+        const dirToModules = /* @__PURE__ */ new Map();
+        for (const mod of this.modules) {
+          const dir = path3.dirname(mod.path) || "root";
+          if (!dirToModules.has(dir)) {
+            dirToModules.set(dir, []);
+          }
+          dirToModules.get(dir).push(mod);
+        }
+        for (const [dir, mods] of dirToModules) {
+          const compName = dir === "." || dir === "root" ? "main" : dir.replace(/[/\\]/g, "-");
+          this.components.push({
+            id: generateComponentId(compName),
+            name: compName,
+            moduleIds: mods.map((m) => m.id)
+          });
+        }
+      }
+      async export() {
+        let repoCommit = "unknown";
+        try {
+          repoCommit = execSync2("git rev-parse HEAD", { cwd: this.targetPath, stdio: "pipe" }).toString().trim().slice(0, 8);
+        } catch {
+          repoCommit = `local-${Date.now().toString(16)}`;
+        }
+        return {
+          metadata: {
+            analyzerVersion: "0.1.0",
+            language: "typescript",
+            repoCommit,
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            configHash: this.generateConfigHash()
+          },
+          nodes: {
+            functions: this.sortById(this.functions),
+            modules: this.sortById(this.modules),
+            components: this.sortById(this.components)
+          },
+          edges: {
+            calls: this.sortEdges(this.callEdges),
+            dataflow: this.sortEdges(this.dataflowEdges)
+          },
+          layout: { positions: {} }
+        };
+      }
+      async cleanup() {
+        if (fs3.existsSync(this.dbPath)) {
+          try {
+            fs3.rmSync(this.dbPath, { recursive: true });
+          } catch {
+            console.warn("Warning: Could not clean up CodeQL database");
+          }
+        }
+      }
+      generateConfigHash() {
+        const queryFiles = fs3.readdirSync(this.queriesPath).sort();
+        return `codeql-${this.hashString(queryFiles.join(",")).toString(16).padStart(8, "0")}`;
+      }
+      hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+          hash = (hash << 5) - hash + str.charCodeAt(i);
+          hash = hash & hash;
+        }
+        return Math.abs(hash);
+      }
+      sortById(items) {
+        return [...items].sort((a, b) => a.id.localeCompare(b.id));
+      }
+      sortEdges(edges) {
+        return [...edges].sort((a, b) => {
+          const cmp = a.from.localeCompare(b.from);
+          return cmp !== 0 ? cmp : a.to.localeCompare(b.to);
+        });
+      }
+    };
+  }
+});
+
+// ../analyzer/dist/exporters/codeql/index.js
+var init_codeql = __esm({
+  "../analyzer/dist/exporters/codeql/index.js"() {
+    "use strict";
+    init_codeql_exporter();
+  }
+});
+
+// ../analyzer/dist/layout/elk-layout.js
+import { createRequire as _createRequire } from "module";
+async function applyElkLayout(artifact) {
+  const elkGraph = buildElkGraph(artifact);
+  const layoutedGraph = await elk.layout(elkGraph);
+  const positions = extractPositions(layoutedGraph);
+  return {
+    ...artifact,
+    layout: {
+      ...artifact.layout,
+      positions
+    }
+  };
+}
+function buildElkGraph(artifact) {
+  const children = artifact.nodes.functions.map((fn) => ({
+    id: fn.id,
+    width: 120,
+    height: 40
+  }));
+  const edges = [
+    ...artifact.edges.calls.map((edge) => ({
+      id: `call-${edge.from}-${edge.to}`,
+      sources: [edge.from],
+      targets: [edge.to]
+    })),
+    ...artifact.edges.dataflow.map((edge) => ({
+      id: `df-${edge.from}-${edge.to}`,
+      sources: [edge.from],
+      targets: [edge.to]
+    }))
+  ];
+  return {
+    id: "root",
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": "RIGHT",
+      "elk.spacing.nodeNode": "50",
+      "elk.layered.spacing.nodeNodeBetweenLayers": "100",
+      "elk.layered.nodePlacement.strategy": "NETWORK_SIMPLEX"
+    },
+    children,
+    edges
+  };
+}
+function extractPositions(layoutedGraph) {
+  const positions = {};
+  if (layoutedGraph.children) {
+    for (const child of layoutedGraph.children) {
+      if (child.x !== void 0 && child.y !== void 0) {
+        positions[child.id] = {
+          x: child.x,
+          y: child.y
+        };
+      }
+    }
+  }
+  return positions;
+}
+var __require, ELKModule, ELKConstructor, elk;
+var init_elk_layout = __esm({
+  "../analyzer/dist/layout/elk-layout.js"() {
+    "use strict";
+    __require = _createRequire(import.meta.url);
+    ELKModule = __require("elkjs");
+    ELKConstructor = ELKModule.default;
+    elk = new ELKConstructor();
+  }
+});
+
+// ../analyzer/dist/commands/analyze.js
+import fs4 from "fs";
+import path4 from "path";
+async function analyzeCommand(targetPath, options) {
+  console.log(`Analyzing: ${path4.resolve(targetPath)}`);
+  console.log(`Exporter: ${options.exporter}`);
+  console.log(`Output: ${options.output}`);
+  console.log("");
+  const absolutePath = path4.resolve(targetPath);
+  if (!fs4.existsSync(absolutePath)) {
+    console.error(`Error: Path does not exist: ${absolutePath}`);
+    process.exit(1);
+  }
+  let artifact;
+  if (options.exporter === "mock") {
+    console.log("Using mock exporter...");
+    const exporter = new MockExporter(absolutePath);
+    await exporter.prepare();
+    await exporter.analyze();
+    artifact = await exporter.export();
+    await exporter.cleanup();
+  } else if (options.exporter === "codeql-ts") {
+    console.log("Using CodeQL exporter for TypeScript...");
+    const exporter = new CodeQLExporter(absolutePath);
+    await exporter.prepare();
+    await exporter.analyze();
+    artifact = await exporter.export();
+    await exporter.cleanup();
+  } else {
+    console.error(`Unknown exporter: ${options.exporter}`);
+    process.exit(1);
+  }
+  console.log("Applying ELK layout...");
+  artifact = await applyElkLayout(artifact);
+  const outputDir = path4.dirname(path4.resolve(options.output));
+  if (!fs4.existsSync(outputDir)) {
+    fs4.mkdirSync(outputDir, { recursive: true });
+  }
+  const outputPath = path4.resolve(options.output);
+  const jsonContent = JSON.stringify(artifact, null, 2);
+  fs4.writeFileSync(outputPath, jsonContent, "utf-8");
+  console.log("");
+  console.log(`Artifact written to: ${outputPath}`);
+  console.log(`  Functions: ${artifact.nodes.functions.length}`);
+  console.log(`  Modules: ${artifact.nodes.modules.length}`);
+  console.log(`  Call edges: ${artifact.edges.calls.length}`);
+  console.log(`  Dataflow edges: ${artifact.edges.dataflow.length}`);
+}
+var init_analyze = __esm({
+  "../analyzer/dist/commands/analyze.js"() {
+    "use strict";
+    init_mock_exporter();
+    init_codeql();
+    init_elk_layout();
+  }
+});
+
+// ../analyzer/dist/commands/serve.js
+import fs5 from "fs";
+import path5 from "path";
+import { spawn } from "child_process";
+async function serveCommand(options) {
+  const artifactPath = path5.resolve(options.artifact);
+  if (!fs5.existsSync(artifactPath)) {
+    console.error(`Error: Artifact not found: ${artifactPath}`);
+    console.error('Run "codeflow analyze" first to generate the artifact.');
+    process.exit(1);
+  }
+  console.log(`Starting CodeFlowMap UI...`);
+  console.log(`Artifact: ${artifactPath}`);
+  console.log(`Port: ${options.port}`);
+  console.log("");
+  const uiPackagePath = path5.resolve(__dirname, "../../ui");
+  if (!fs5.existsSync(uiPackagePath)) {
+    const monorepoUiPath = path5.resolve(__dirname, "../../../ui");
+    if (fs5.existsSync(monorepoUiPath)) {
+      startVite(monorepoUiPath, options.port);
+    } else {
+      console.error("UI package not found. Run from the monorepo root.");
+      process.exit(1);
+    }
+  } else {
+    startVite(uiPackagePath, options.port);
+  }
+}
+function startVite(uiPath, port) {
+  console.log(`Starting Vite dev server at ${uiPath}...`);
+  console.log(`Open http://localhost:${port} in your browser`);
+  console.log("");
+  const vite = spawn("npx", ["vite", "--port", port], {
+    cwd: uiPath,
+    stdio: "inherit",
+    shell: true
+  });
+  vite.on("error", (err) => {
+    console.error("Failed to start Vite:", err);
+    process.exit(1);
+  });
+  vite.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+var init_serve = __esm({
+  "../analyzer/dist/commands/serve.js"() {
+    "use strict";
+  }
+});
+
+// ../analyzer/dist/commands/diff.js
+import fs6 from "fs";
+import path6 from "path";
+async function diffCommand(baselinePath, currentPath, options) {
+  const baselineArtifact = loadArtifact(baselinePath, "Baseline");
+  if (!baselineArtifact) {
+    process.exit(1);
+  }
+  const currentArtifact = loadArtifact(currentPath, "Current");
+  if (!currentArtifact) {
+    process.exit(1);
+  }
+  const diff = calculateDiff(baselineArtifact, currentArtifact);
+  if (options.format === "json") {
+    console.log(JSON.stringify(diff, null, 2));
+  } else {
+    printTextDiff(diff, baselinePath, currentPath);
+  }
+  if (options.exitOnChanges && diff.hasChanges) {
+    process.exit(1);
+  }
+}
+function loadArtifact(filePath, label) {
+  const absolutePath = path6.resolve(filePath);
+  if (!fs6.existsSync(absolutePath)) {
+    console.error(`Error: ${label} artifact not found: ${absolutePath}`);
+    return null;
+  }
+  try {
+    const content = fs6.readFileSync(absolutePath, "utf-8");
+    const artifact = JSON.parse(content);
+    if (!isCodeFlowArtifact(artifact)) {
+      console.error(`Error: ${label} file is not a valid CodeFlow artifact`);
+      return null;
+    }
+    return artifact;
+  } catch (error) {
+    console.error(`Error: Failed to parse ${label} artifact: ${error}`);
+    return null;
+  }
+}
+function calculateDiff(baseline, current) {
+  const baselineFnIds = new Set(baseline.nodes.functions.map((fn) => fn.id));
+  const currentFnIds = new Set(current.nodes.functions.map((fn) => fn.id));
+  const addedFunctions = current.nodes.functions.filter((fn) => !baselineFnIds.has(fn.id)).map((fn) => `${fn.name} (${fn.file}:${fn.startLine})`);
+  const removedFunctions = baseline.nodes.functions.filter((fn) => !currentFnIds.has(fn.id)).map((fn) => `${fn.name} (${fn.file}:${fn.startLine})`);
+  const baselineModIds = new Set(baseline.nodes.modules.map((m) => m.id));
+  const currentModIds = new Set(current.nodes.modules.map((m) => m.id));
+  const addedModules = current.nodes.modules.filter((m) => !baselineModIds.has(m.id)).map((m) => m.path);
+  const removedModules = baseline.nodes.modules.filter((m) => !currentModIds.has(m.id)).map((m) => m.path);
+  const edgeKey = (e) => `${e.from}->${e.to}`;
+  const baselineCallEdges = new Set(baseline.edges.calls.map(edgeKey));
+  const currentCallEdges = new Set(current.edges.calls.map(edgeKey));
+  const addedCallEdges = current.edges.calls.filter((e) => !baselineCallEdges.has(edgeKey(e))).map((e) => formatEdge(e, current));
+  const removedCallEdges = baseline.edges.calls.filter((e) => !currentCallEdges.has(edgeKey(e))).map((e) => formatEdge(e, baseline));
+  const baselineDataflowEdges = new Set(baseline.edges.dataflow.map(edgeKey));
+  const currentDataflowEdges = new Set(current.edges.dataflow.map(edgeKey));
+  const addedDataflowEdges = current.edges.dataflow.filter((e) => !baselineDataflowEdges.has(edgeKey(e))).map((e) => formatEdge(e, current));
+  const removedDataflowEdges = baseline.edges.dataflow.filter((e) => !currentDataflowEdges.has(edgeKey(e))).map((e) => formatEdge(e, baseline));
+  const hasChanges = addedFunctions.length > 0 || removedFunctions.length > 0 || addedModules.length > 0 || removedModules.length > 0 || addedCallEdges.length > 0 || removedCallEdges.length > 0 || addedDataflowEdges.length > 0 || removedDataflowEdges.length > 0;
+  return {
+    hasChanges,
+    summary: {
+      functionsAdded: addedFunctions.length,
+      functionsRemoved: removedFunctions.length,
+      modulesAdded: addedModules.length,
+      modulesRemoved: removedModules.length,
+      callEdgesAdded: addedCallEdges.length,
+      callEdgesRemoved: removedCallEdges.length,
+      dataflowEdgesAdded: addedDataflowEdges.length,
+      dataflowEdgesRemoved: removedDataflowEdges.length
+    },
+    details: {
+      addedFunctions,
+      removedFunctions,
+      addedModules,
+      removedModules,
+      addedCallEdges,
+      removedCallEdges,
+      addedDataflowEdges,
+      removedDataflowEdges
+    }
+  };
+}
+function formatEdge(edge, artifact) {
+  const fromFn = artifact.nodes.functions.find((fn) => fn.id === edge.from);
+  const toFn = artifact.nodes.functions.find((fn) => fn.id === edge.to);
+  const fromName = fromFn ? fromFn.name : edge.from;
+  const toName = toFn ? toFn.name : edge.to;
+  return `${fromName} -> ${toName}`;
+}
+function printTextDiff(diff, baselinePath, currentPath) {
+  console.log("CodeFlow Artifact Diff");
+  console.log("======================");
+  console.log(`Baseline: ${baselinePath}`);
+  console.log(`Current:  ${currentPath}`);
+  console.log("");
+  if (!diff.hasChanges) {
+    console.log("No changes detected.");
+    return;
+  }
+  console.log("Summary:");
+  console.log(`  Functions:      +${diff.summary.functionsAdded} / -${diff.summary.functionsRemoved}`);
+  console.log(`  Modules:        +${diff.summary.modulesAdded} / -${diff.summary.modulesRemoved}`);
+  console.log(`  Call Edges:     +${diff.summary.callEdgesAdded} / -${diff.summary.callEdgesRemoved}`);
+  console.log(`  Dataflow Edges: +${diff.summary.dataflowEdgesAdded} / -${diff.summary.dataflowEdgesRemoved}`);
+  console.log("");
+  if (diff.details.addedFunctions.length > 0) {
+    console.log("Added Functions:");
+    for (const fn of diff.details.addedFunctions) {
+      console.log(`  + ${fn}`);
+    }
+    console.log("");
+  }
+  if (diff.details.removedFunctions.length > 0) {
+    console.log("Removed Functions:");
+    for (const fn of diff.details.removedFunctions) {
+      console.log(`  - ${fn}`);
+    }
+    console.log("");
+  }
+  if (diff.details.addedModules.length > 0) {
+    console.log("Added Modules:");
+    for (const mod of diff.details.addedModules) {
+      console.log(`  + ${mod}`);
+    }
+    console.log("");
+  }
+  if (diff.details.removedModules.length > 0) {
+    console.log("Removed Modules:");
+    for (const mod of diff.details.removedModules) {
+      console.log(`  - ${mod}`);
+    }
+    console.log("");
+  }
+  if (diff.details.addedCallEdges.length > 0) {
+    console.log("Added Call Edges:");
+    for (const edge of diff.details.addedCallEdges) {
+      console.log(`  + ${edge}`);
+    }
+    console.log("");
+  }
+  if (diff.details.removedCallEdges.length > 0) {
+    console.log("Removed Call Edges:");
+    for (const edge of diff.details.removedCallEdges) {
+      console.log(`  - ${edge}`);
+    }
+    console.log("");
+  }
+  if (diff.details.addedDataflowEdges.length > 0) {
+    console.log("Added Dataflow Edges:");
+    for (const edge of diff.details.addedDataflowEdges) {
+      console.log(`  + ${edge}`);
+    }
+    console.log("");
+  }
+  if (diff.details.removedDataflowEdges.length > 0) {
+    console.log("Removed Dataflow Edges:");
+    for (const edge of diff.details.removedDataflowEdges) {
+      console.log(`  - ${edge}`);
+    }
+    console.log("");
+  }
+}
+var init_diff = __esm({
+  "../analyzer/dist/commands/diff.js"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// ../analyzer/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  CodeQLExporter: () => CodeQLExporter,
+  MockExporter: () => MockExporter,
+  analyzeCommand: () => analyzeCommand,
+  applyElkLayout: () => applyElkLayout,
+  diffCommand: () => diffCommand,
+  serveCommand: () => serveCommand
+});
+var init_dist2 = __esm({
+  "../analyzer/dist/index.js"() {
+    "use strict";
+    init_analyze();
+    init_serve();
+    init_diff();
+    init_elk_layout();
+    init_mock_exporter();
+    init_codeql_exporter();
+  }
+});
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/analyze.ts
+init_dist2();
+import fs7 from "fs";
+import path7 from "path";
+import ora from "ora";
+
+// src/utils/output.ts
+import chalk from "chalk";
+var log = {
+  info: (message) => console.log(chalk.blue("\u2139"), message),
+  success: (message) => console.log(chalk.green("\u2713"), message),
+  warning: (message) => console.log(chalk.yellow("\u26A0"), message),
+  error: (message) => console.error(chalk.red("\u2717"), message),
+  title: (message) => console.log(chalk.bold.cyan(`
+${message}
+`)),
+  dim: (message) => console.log(chalk.dim(message))
+};
+function formatNumber(n) {
+  return n.toLocaleString();
+}
+function formatPath(p) {
+  return chalk.underline(p);
+}
+function formatDiff(added, removed) {
+  const parts = [];
+  if (added > 0) parts.push(chalk.green(`+${added}`));
+  if (removed > 0) parts.push(chalk.red(`-${removed}`));
+  return parts.join(" / ") || chalk.dim("no changes");
+}
+
+// src/commands/analyze.ts
+async function analyzeCommand2(targetPath, options) {
+  const absolutePath = path7.resolve(targetPath);
+  if (!fs7.existsSync(absolutePath)) {
+    log.error(`Path does not exist: ${formatPath(absolutePath)}`);
+    process.exit(1);
+  }
+  log.title("Monarch Analysis");
+  log.info(`Target: ${formatPath(absolutePath)}`);
+  log.info(`Exporter: ${options.exporter}`);
+  log.info(`Output: ${formatPath(options.output)}`);
+  const spinner = ora("Analyzing codebase...").start();
+  try {
+    let artifact;
+    if (options.exporter === "mock") {
+      const exporter = new MockExporter(absolutePath);
+      await exporter.prepare();
+      spinner.text = "Scanning files...";
+      await exporter.analyze();
+      spinner.text = "Generating artifact...";
+      artifact = await exporter.export();
+      await exporter.cleanup();
+    } else if (options.exporter === "codeql-ts") {
+      spinner.text = "Creating CodeQL database...";
+      const { CodeQLExporter: CodeQLExporter2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+      const exporter = new CodeQLExporter2(absolutePath);
+      await exporter.prepare();
+      spinner.text = "Running CodeQL queries...";
+      await exporter.analyze();
+      spinner.text = "Generating artifact...";
+      artifact = await exporter.export();
+      await exporter.cleanup();
+    } else {
+      spinner.fail(`Unknown exporter: ${options.exporter}`);
+      process.exit(1);
+    }
+    spinner.text = "Computing layout...";
+    artifact = await applyElkLayout(artifact);
+    const outputDir = path7.dirname(path7.resolve(options.output));
+    if (!fs7.existsSync(outputDir)) {
+      fs7.mkdirSync(outputDir, { recursive: true });
+    }
+    const outputPath = path7.resolve(options.output);
+    fs7.writeFileSync(outputPath, JSON.stringify(artifact, null, 2));
+    spinner.succeed("Analysis complete!");
+    console.log("");
+    log.success(`Graph saved to ${formatPath(outputPath)}`);
+    console.log("");
+    log.info(`Functions:  ${formatNumber(artifact.nodes.functions.length)}`);
+    log.info(`Modules:    ${formatNumber(artifact.nodes.modules.length)}`);
+    log.info(`Components: ${formatNumber(artifact.nodes.components.length)}`);
+    log.info(`Call edges: ${formatNumber(artifact.edges.calls.length)}`);
+    log.info(`Dataflow:   ${formatNumber(artifact.edges.dataflow.length)}`);
+    if (options.watch) {
+      log.info("\nWatching for changes... (press Ctrl+C to stop)");
+    }
+  } catch (error) {
+    spinner.fail("Analysis failed");
+    log.error(String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/diff.ts
+init_dist();
+import fs8 from "fs";
+import path8 from "path";
+import chalk2 from "chalk";
+async function diffCommand2(baselinePath, currentPath, options) {
+  const baseline = loadArtifact2(baselinePath, "Baseline");
+  const current = loadArtifact2(currentPath, "Current");
+  if (!baseline || !current) {
+    process.exit(1);
+  }
+  const diff = calculateDiff2(baseline, current);
+  switch (options.format) {
+    case "json":
+      console.log(JSON.stringify(diff, null, 2));
+      break;
+    case "markdown":
+      printMarkdownDiff(diff, baselinePath, currentPath, options.only);
+      break;
+    default:
+      printTextDiff2(diff, baselinePath, currentPath, options.only);
+  }
+  if (options.exitOnChanges && diff.hasChanges) {
+    process.exit(1);
+  }
+}
+function loadArtifact2(filePath, label) {
+  const absolutePath = path8.resolve(filePath);
+  if (!fs8.existsSync(absolutePath)) {
+    log.error(`${label} artifact not found: ${formatPath(absolutePath)}`);
+    return null;
+  }
+  try {
+    const content = fs8.readFileSync(absolutePath, "utf-8");
+    const artifact = JSON.parse(content);
+    if (!isCodeFlowArtifact(artifact)) {
+      log.error(`${label} file is not a valid Monarch artifact`);
+      return null;
+    }
+    return artifact;
+  } catch (error) {
+    log.error(`Failed to parse ${label} artifact: ${error}`);
+    return null;
+  }
+}
+function calculateDiff2(baseline, current) {
+  const baselineFnIds = new Set(baseline.nodes.functions.map((fn) => fn.id));
+  const currentFnIds = new Set(current.nodes.functions.map((fn) => fn.id));
+  const addedFunctions = current.nodes.functions.filter((fn) => !baselineFnIds.has(fn.id)).map((fn) => `${fn.name} (${fn.file}:${fn.startLine})`);
+  const removedFunctions = baseline.nodes.functions.filter((fn) => !currentFnIds.has(fn.id)).map((fn) => `${fn.name} (${fn.file}:${fn.startLine})`);
+  const baselineModIds = new Set(baseline.nodes.modules.map((m) => m.id));
+  const currentModIds = new Set(current.nodes.modules.map((m) => m.id));
+  const addedModules = current.nodes.modules.filter((m) => !baselineModIds.has(m.id)).map((m) => m.path);
+  const removedModules = baseline.nodes.modules.filter((m) => !currentModIds.has(m.id)).map((m) => m.path);
+  const edgeKey = (e) => `${e.from}->${e.to}`;
+  const baselineCallEdges = new Set(baseline.edges.calls.map(edgeKey));
+  const currentCallEdges = new Set(current.edges.calls.map(edgeKey));
+  const addedCallEdges = current.edges.calls.filter((e) => !baselineCallEdges.has(edgeKey(e))).map((e) => formatEdge2(e, current));
+  const removedCallEdges = baseline.edges.calls.filter((e) => !currentCallEdges.has(edgeKey(e))).map((e) => formatEdge2(e, baseline));
+  const baselineDataflowEdges = new Set(baseline.edges.dataflow.map(edgeKey));
+  const currentDataflowEdges = new Set(current.edges.dataflow.map(edgeKey));
+  const addedDataflowEdges = current.edges.dataflow.filter((e) => !baselineDataflowEdges.has(edgeKey(e))).map((e) => formatEdge2(e, current));
+  const removedDataflowEdges = baseline.edges.dataflow.filter((e) => !currentDataflowEdges.has(edgeKey(e))).map((e) => formatEdge2(e, baseline));
+  const hasChanges = addedFunctions.length > 0 || removedFunctions.length > 0 || addedModules.length > 0 || removedModules.length > 0 || addedCallEdges.length > 0 || removedCallEdges.length > 0 || addedDataflowEdges.length > 0 || removedDataflowEdges.length > 0;
+  return {
+    hasChanges,
+    summary: {
+      functionsAdded: addedFunctions.length,
+      functionsRemoved: removedFunctions.length,
+      modulesAdded: addedModules.length,
+      modulesRemoved: removedModules.length,
+      callEdgesAdded: addedCallEdges.length,
+      callEdgesRemoved: removedCallEdges.length,
+      dataflowEdgesAdded: addedDataflowEdges.length,
+      dataflowEdgesRemoved: removedDataflowEdges.length
+    },
+    details: {
+      addedFunctions,
+      removedFunctions,
+      addedModules,
+      removedModules,
+      addedCallEdges,
+      removedCallEdges,
+      addedDataflowEdges,
+      removedDataflowEdges
+    }
+  };
+}
+function formatEdge2(edge, artifact) {
+  const fromFn = artifact.nodes.functions.find((fn) => fn.id === edge.from);
+  const toFn = artifact.nodes.functions.find((fn) => fn.id === edge.to);
+  return `${fromFn?.name || edge.from} \u2192 ${toFn?.name || edge.to}`;
+}
+function printTextDiff2(diff, baselinePath, currentPath, only) {
+  log.title("Monarch Graph Diff");
+  console.log(chalk2.dim(`Baseline: ${baselinePath}`));
+  console.log(chalk2.dim(`Current:  ${currentPath}`));
+  console.log("");
+  if (!diff.hasChanges) {
+    log.success("No changes detected");
+    return;
+  }
+  console.log(chalk2.bold("Summary:"));
+  if (!only || only === "functions") {
+    console.log(`  Functions:      ${formatDiff(diff.summary.functionsAdded, diff.summary.functionsRemoved)}`);
+  }
+  if (!only || only === "modules") {
+    console.log(`  Modules:        ${formatDiff(diff.summary.modulesAdded, diff.summary.modulesRemoved)}`);
+  }
+  if (!only || only === "edges") {
+    console.log(`  Call Edges:     ${formatDiff(diff.summary.callEdgesAdded, diff.summary.callEdgesRemoved)}`);
+    console.log(`  Dataflow Edges: ${formatDiff(diff.summary.dataflowEdgesAdded, diff.summary.dataflowEdgesRemoved)}`);
+  }
+  console.log("");
+  if ((!only || only === "functions") && diff.details.addedFunctions.length > 0) {
+    console.log(chalk2.green.bold("Added Functions:"));
+    diff.details.addedFunctions.forEach((fn) => console.log(chalk2.green(`  + ${fn}`)));
+    console.log("");
+  }
+  if ((!only || only === "functions") && diff.details.removedFunctions.length > 0) {
+    console.log(chalk2.red.bold("Removed Functions:"));
+    diff.details.removedFunctions.forEach((fn) => console.log(chalk2.red(`  - ${fn}`)));
+    console.log("");
+  }
+  if ((!only || only === "modules") && diff.details.addedModules.length > 0) {
+    console.log(chalk2.green.bold("Added Modules:"));
+    diff.details.addedModules.forEach((m) => console.log(chalk2.green(`  + ${m}`)));
+    console.log("");
+  }
+  if ((!only || only === "modules") && diff.details.removedModules.length > 0) {
+    console.log(chalk2.red.bold("Removed Modules:"));
+    diff.details.removedModules.forEach((m) => console.log(chalk2.red(`  - ${m}`)));
+    console.log("");
+  }
+  if ((!only || only === "edges") && diff.details.addedCallEdges.length > 0) {
+    console.log(chalk2.green.bold("Added Call Edges:"));
+    diff.details.addedCallEdges.forEach((e) => console.log(chalk2.green(`  + ${e}`)));
+    console.log("");
+  }
+  if ((!only || only === "edges") && diff.details.removedCallEdges.length > 0) {
+    console.log(chalk2.red.bold("Removed Call Edges:"));
+    diff.details.removedCallEdges.forEach((e) => console.log(chalk2.red(`  - ${e}`)));
+    console.log("");
+  }
+}
+function printMarkdownDiff(diff, baselinePath, currentPath, only) {
+  console.log("# Monarch Graph Diff\n");
+  console.log(`- **Baseline:** \`${baselinePath}\``);
+  console.log(`- **Current:** \`${currentPath}\`
+`);
+  if (!diff.hasChanges) {
+    console.log("\u2705 No changes detected\n");
+    return;
+  }
+  console.log("## Summary\n");
+  console.log("| Category | Added | Removed |");
+  console.log("|----------|-------|---------|");
+  if (!only || only === "functions") {
+    console.log(`| Functions | ${diff.summary.functionsAdded} | ${diff.summary.functionsRemoved} |`);
+  }
+  if (!only || only === "modules") {
+    console.log(`| Modules | ${diff.summary.modulesAdded} | ${diff.summary.modulesRemoved} |`);
+  }
+  if (!only || only === "edges") {
+    console.log(`| Call Edges | ${diff.summary.callEdgesAdded} | ${diff.summary.callEdgesRemoved} |`);
+    console.log(`| Dataflow Edges | ${diff.summary.dataflowEdgesAdded} | ${diff.summary.dataflowEdgesRemoved} |`);
+  }
+  console.log("");
+  if ((!only || only === "functions") && diff.details.addedFunctions.length > 0) {
+    console.log("### Added Functions\n");
+    diff.details.addedFunctions.forEach((fn) => console.log(`- \`${fn}\``));
+    console.log("");
+  }
+  if ((!only || only === "functions") && diff.details.removedFunctions.length > 0) {
+    console.log("### Removed Functions\n");
+    diff.details.removedFunctions.forEach((fn) => console.log(`- \`${fn}\``));
+    console.log("");
+  }
+}
+
+// src/commands/serve.ts
+init_dist();
+import fs9 from "fs";
+import path9 from "path";
+import { createServer } from "http";
+async function serveCommand2(options) {
+  const artifactPath = path9.resolve(options.artifact);
+  const port = parseInt(options.port, 10);
+  if (!fs9.existsSync(artifactPath)) {
+    log.error(`Artifact not found: ${formatPath(artifactPath)}`);
+    log.info("Run `monarch analyze` first to generate a graph");
+    process.exit(1);
+  }
+  try {
+    const content = fs9.readFileSync(artifactPath, "utf-8");
+    const artifact = JSON.parse(content);
+    if (!isCodeFlowArtifact(artifact)) {
+      log.error("Invalid artifact file");
+      process.exit(1);
+    }
+  } catch (error) {
+    log.error(`Failed to read artifact: ${error}`);
+    process.exit(1);
+  }
+  const server = createServer((req, res) => {
+    const url = req.url || "/";
+    if (url === "/api/artifact") {
+      res.setHeader("Content-Type", "application/json");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      const content = fs9.readFileSync(artifactPath, "utf-8");
+      res.end(content);
+    } else if (url === "/") {
+      res.setHeader("Content-Type", "text/html");
+      res.end(getIndexHtml(port));
+    } else {
+      res.statusCode = 404;
+      res.end("Not Found");
+    }
+  });
+  server.listen(port, () => {
+    log.title("Monarch Visualization Server");
+    log.success(`Server running at http://localhost:${port}`);
+    log.info(`Serving artifact: ${formatPath(artifactPath)}`);
+    log.dim("\nPress Ctrl+C to stop");
+    if (options.open) {
+      const url = `http://localhost:${port}`;
+      import("child_process").then(({ exec: exec2 }) => {
+        const cmd = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+        exec2(`${cmd} ${url}`);
+      });
+    }
+  });
+  process.on("SIGINT", () => {
+    log.info("\nShutting down server...");
+    server.close(() => {
+      process.exit(0);
+    });
+  });
+}
+function getIndexHtml(port) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Monarch - Graph Visualization</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #16213e;
+      color: #fff;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    h1 {
+      font-size: 2.5rem;
+      margin-bottom: 1rem;
+      color: #4a90d9;
+    }
+    p {
+      color: #888;
+      margin-bottom: 2rem;
+    }
+    .info {
+      background: #1a1a2e;
+      padding: 1.5rem;
+      border-radius: 8px;
+      margin-bottom: 2rem;
+    }
+    .info code {
+      background: #2d2d44;
+      padding: 0.25rem 0.5rem;
+      border-radius: 4px;
+      font-family: monospace;
+    }
+    a {
+      color: #4a90d9;
+      text-decoration: none;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u{1F52E} Monarch</h1>
+    <p>Static Codebase Flow Mapping</p>
+    <div class="info">
+      <p>API Endpoint: <code>http://localhost:${port}/api/artifact</code></p>
+    </div>
+    <p>
+      To view the full visualization, run the UI package:<br>
+      <code>pnpm --filter @codeflow/ui dev</code>
+    </p>
+  </div>
+</body>
+</html>`;
+}
+
+// src/commands/init.ts
+import fs10 from "fs";
+import path10 from "path";
+var DEFAULT_CONFIG = {
+  version: "1.0",
+  exporter: "mock",
+  output: "monarch-graph.json",
+  include: ["src/**/*.ts", "src/**/*.tsx"],
+  exclude: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"]
+};
+async function initCommand(options) {
+  const configPath = path10.resolve("monarch.json");
+  if (fs10.existsSync(configPath) && !options.force) {
+    log.error(`Configuration file already exists: ${formatPath(configPath)}`);
+    log.info("Use --force to overwrite");
+    process.exit(1);
+  }
+  fs10.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+  log.success(`Created configuration file: ${formatPath(configPath)}`);
+  const gitignorePath = path10.resolve(".gitignore");
+  const gitignoreEntry = "\n# Monarch\nmonarch-graph.json\n.monarch/\n";
+  if (fs10.existsSync(gitignorePath)) {
+    const content = fs10.readFileSync(gitignorePath, "utf-8");
+    if (!content.includes("monarch-graph.json")) {
+      log.info(`Consider adding to ${formatPath(".gitignore")}:`);
+      log.dim(gitignoreEntry.trim());
+    }
+  }
+  log.title("Monarch initialized successfully!");
+  log.info("Next steps:");
+  log.dim("  1. Run `monarch analyze` to generate your first graph");
+  log.dim("  2. Run `monarch serve` to visualize the graph");
+  log.dim("  3. Run `monarch diff <old> <new>` to compare graphs");
+}
+
+// src/commands/list.ts
+init_dist();
+import fs11 from "fs";
+import path11 from "path";
+import chalk3 from "chalk";
+async function listCommand(artifactPath, options) {
+  const absolutePath = path11.resolve(artifactPath);
+  if (!fs11.existsSync(absolutePath)) {
+    log.error(`Artifact not found: ${formatPath(absolutePath)}`);
+    log.info("Run `monarch analyze` first to generate a graph");
+    process.exit(1);
+  }
+  let artifact;
+  try {
+    const content = fs11.readFileSync(absolutePath, "utf-8");
+    artifact = JSON.parse(content);
+    if (!isCodeFlowArtifact(artifact)) {
+      log.error("Invalid artifact file");
+      process.exit(1);
+    }
+  } catch (error) {
+    log.error(`Failed to read artifact: ${error}`);
+    process.exit(1);
+  }
+  if (options.json) {
+    printJsonOutput(artifact, options.type);
+  } else {
+    printTextOutput(artifact, options.type);
+  }
+}
+function printJsonOutput(artifact, type) {
+  let output;
+  switch (type) {
+    case "functions":
+      output = artifact.nodes.functions;
+      break;
+    case "modules":
+      output = artifact.nodes.modules;
+      break;
+    case "components":
+      output = artifact.nodes.components;
+      break;
+    case "edges":
+      output = {
+        calls: artifact.edges.calls,
+        dataflow: artifact.edges.dataflow
+      };
+      break;
+    default:
+      output = {
+        metadata: artifact.metadata,
+        summary: {
+          functions: artifact.nodes.functions.length,
+          modules: artifact.nodes.modules.length,
+          components: artifact.nodes.components.length,
+          callEdges: artifact.edges.calls.length,
+          dataflowEdges: artifact.edges.dataflow.length
+        }
+      };
+  }
+  console.log(JSON.stringify(output, null, 2));
+}
+function printTextOutput(artifact, type) {
+  log.title("Monarch Graph Contents");
+  console.log(chalk3.bold("Metadata:"));
+  console.log(`  Version:    ${artifact.metadata.analyzerVersion}`);
+  console.log(`  Language:   ${artifact.metadata.language}`);
+  console.log(`  Commit:     ${artifact.metadata.repoCommit}`);
+  console.log(`  Generated:  ${artifact.metadata.generatedAt}`);
+  console.log("");
+  console.log(chalk3.bold("Summary:"));
+  console.log(`  Functions:      ${formatNumber(artifact.nodes.functions.length)}`);
+  console.log(`  Modules:        ${formatNumber(artifact.nodes.modules.length)}`);
+  console.log(`  Components:     ${formatNumber(artifact.nodes.components.length)}`);
+  console.log(`  Call Edges:     ${formatNumber(artifact.edges.calls.length)}`);
+  console.log(`  Dataflow Edges: ${formatNumber(artifact.edges.dataflow.length)}`);
+  console.log("");
+  if (!type || type === "functions") {
+    console.log(chalk3.bold("Functions:"));
+    const grouped = groupByFile(artifact.nodes.functions);
+    for (const [file, fns] of Object.entries(grouped)) {
+      console.log(chalk3.cyan(`  ${file}`));
+      for (const fn of fns) {
+        console.log(`    ${fn.name} ${chalk3.dim(`(${fn.startLine}-${fn.endLine})`)}`);
+      }
+    }
+    console.log("");
+  }
+  if (!type || type === "modules") {
+    console.log(chalk3.bold("Modules:"));
+    for (const mod of artifact.nodes.modules) {
+      const fnCount = mod.functionIds?.length || 0;
+      console.log(`  ${mod.path} ${chalk3.dim(`(${fnCount} functions)`)}`);
+    }
+    console.log("");
+  }
+  if (!type || type === "components") {
+    console.log(chalk3.bold("Components:"));
+    for (const comp of artifact.nodes.components) {
+      const modCount = comp.moduleIds?.length || 0;
+      console.log(`  ${comp.name} ${chalk3.dim(`(${modCount} modules)`)}`);
+    }
+    console.log("");
+  }
+  if (!type || type === "edges") {
+    if (artifact.edges.calls.length > 0) {
+      console.log(chalk3.bold("Call Edges:"));
+      for (const edge of artifact.edges.calls.slice(0, 10)) {
+        const from = artifact.nodes.functions.find((f) => f.id === edge.from);
+        const to = artifact.nodes.functions.find((f) => f.id === edge.to);
+        console.log(`  ${from?.name || edge.from} ${chalk3.dim("\u2192")} ${to?.name || edge.to}`);
+      }
+      if (artifact.edges.calls.length > 10) {
+        console.log(chalk3.dim(`  ... and ${artifact.edges.calls.length - 10} more`));
+      }
+      console.log("");
+    }
+    if (artifact.edges.dataflow.length > 0) {
+      console.log(chalk3.bold("Dataflow Edges:"));
+      for (const edge of artifact.edges.dataflow.slice(0, 10)) {
+        const from = artifact.nodes.functions.find((f) => f.id === edge.from);
+        const to = artifact.nodes.functions.find((f) => f.id === edge.to);
+        console.log(`  ${from?.name || edge.from} ${chalk3.yellow("\u27FF")} ${to?.name || edge.to}`);
+        if (edge.label) {
+          console.log(chalk3.dim(`    ${edge.label}`));
+        }
+      }
+      if (artifact.edges.dataflow.length > 10) {
+        console.log(chalk3.dim(`  ... and ${artifact.edges.dataflow.length - 10} more`));
+      }
+      console.log("");
+    }
+  }
+}
+function groupByFile(items) {
+  return items.reduce((acc, item) => {
+    if (!acc[item.file]) {
+      acc[item.file] = [];
+    }
+    acc[item.file].push(item);
+    return acc;
+  }, {});
+}
+
+// src/commands/help.ts
+import chalk4 from "chalk";
+var commands = {
+  init: {
+    name: "init",
+    description: "Initialize a new Monarch project in the current directory",
+    usage: "monarch init [options]",
+    options: [
+      { flag: "-f, --force", description: "Overwrite existing configuration", default: "false" }
+    ],
+    examples: [
+      "monarch init",
+      "monarch init --force"
+    ]
+  },
+  analyze: {
+    name: "analyze",
+    alias: "a",
+    description: "Analyze a codebase and generate a flow artifact containing functions, modules, call edges, and dataflow relationships",
+    usage: "monarch analyze [path] [options]",
+    options: [
+      { flag: "-o, --output <path>", description: "Output artifact file path", default: "monarch-graph.json" },
+      { flag: "-e, --exporter <name>", description: "Exporter to use (mock, codeql-ts)", default: "mock" },
+      { flag: "-w, --watch", description: "Watch for changes and re-analyze", default: "false" }
+    ],
+    examples: [
+      "monarch analyze",
+      "monarch analyze ./src",
+      "monarch analyze ./src -o graph.json",
+      "monarch analyze ./src --exporter codeql-ts",
+      "monarch a ./src -o graph.json"
+    ]
+  },
+  diff: {
+    name: "diff",
+    alias: "d",
+    description: "Compare two graph artifacts and show changes in functions, modules, and edges. Useful for tracking code structure changes between versions",
+    usage: "monarch diff <baseline> <current> [options]",
+    options: [
+      { flag: "-f, --format <type>", description: "Output format (text, json, markdown)", default: "text" },
+      { flag: "--exit-on-changes", description: "Exit with code 1 if changes detected (for CI)", default: "false" },
+      { flag: "--only <type>", description: "Show only specific changes (functions, modules, edges)" }
+    ],
+    examples: [
+      "monarch diff baseline.json current.json",
+      "monarch diff baseline.json current.json --format json",
+      "monarch diff baseline.json current.json --format markdown",
+      "monarch diff baseline.json current.json --exit-on-changes",
+      "monarch d old.json new.json --only functions"
+    ]
+  },
+  serve: {
+    name: "serve",
+    alias: "s",
+    description: "Start an HTTP server to serve the artifact and visualization UI",
+    usage: "monarch serve [options]",
+    options: [
+      { flag: "-p, --port <number>", description: "Port to serve on", default: "3000" },
+      { flag: "-a, --artifact <path>", description: "Artifact file path", default: "monarch-graph.json" },
+      { flag: "--open", description: "Open browser automatically", default: "false" }
+    ],
+    examples: [
+      "monarch serve",
+      "monarch serve --port 8080",
+      "monarch serve --artifact my-graph.json --open",
+      "monarch s -p 4000"
+    ]
+  },
+  list: {
+    name: "list",
+    alias: "ls",
+    description: "List and inspect contents of a graph artifact including metadata, functions, modules, components, and edges",
+    usage: "monarch list [artifact] [options]",
+    options: [
+      { flag: "-t, --type <type>", description: "Filter by type (functions, modules, components, edges)" },
+      { flag: "--json", description: "Output as JSON", default: "false" }
+    ],
+    examples: [
+      "monarch list",
+      "monarch list my-graph.json",
+      "monarch list --type functions",
+      "monarch list --json",
+      "monarch ls -t modules --json"
+    ]
+  },
+  run: {
+    name: "run",
+    alias: "r",
+    description: "All-in-one command that analyzes the codebase, detects changes from the previous graph, updates the artifact if needed, and starts the visualization server. Perfect for development workflow.",
+    usage: "monarch run [path] [options]",
+    options: [
+      { flag: "-o, --output <path>", description: "Output artifact file path", default: "monarch-graph.json" },
+      { flag: "-e, --exporter <name>", description: "Exporter to use (mock, codeql-ts)", default: "mock" },
+      { flag: "-p, --port <number>", description: "Port for visualization server", default: "3000" },
+      { flag: "--open", description: "Open browser automatically", default: "false" },
+      { flag: "-f, --force", description: "Force regeneration even if no changes detected", default: "false" }
+    ],
+    examples: [
+      "monarch run",
+      "monarch run ./src",
+      "monarch run ./src --open",
+      "monarch run ./src -p 8080 --open",
+      "monarch r ./src -o my-graph.json --force"
+    ]
+  },
+  graph: {
+    name: "graph",
+    alias: "g",
+    description: "Render an ASCII graph visualization directly in the terminal. Supports different view levels (components, modules, functions) and can expand specific containers to show their internal structure.",
+    usage: "monarch graph [artifact] [options]",
+    options: [
+      { flag: "-l, --level <level>", description: "View level (components, modules, functions)", default: "modules" },
+      { flag: "-x, --expand <name>", description: "Expand a specific component or module by name" },
+      { flag: "--expand-type <type>", description: "Type of item to expand (component, module)" },
+      { flag: "--list", description: "List expandable components and modules", default: "false" },
+      { flag: "--no-color", description: "Disable colored output" },
+      { flag: "-w, --width <cols>", description: "Max output width in columns" }
+    ],
+    examples: [
+      "monarch graph",
+      "monarch graph --level components",
+      "monarch graph --level functions",
+      "monarch graph --list",
+      "monarch graph --expand src-utils",
+      "monarch graph -x auth.ts --expand-type module",
+      "monarch g -l components"
+    ]
+  }
+};
+function helpCommand(command) {
+  if (command && commands[command]) {
+    printCommandHelp(commands[command]);
+  } else if (command) {
+    console.error(chalk4.red(`Unknown command: ${command}`));
+    console.log(`
+Run ${chalk4.cyan("monarch help")} to see all available commands.`);
+    process.exit(1);
+  } else {
+    printGeneralHelp();
+  }
+}
+function printGeneralHelp() {
+  console.log(chalk4.bold.cyan(`
+ __  __                            _
+|  \\/  | ___  _ __   __ _ _ __ ___| |__
+| |\\/| |/ _ \\| '_ \\ / _\` | '__/ __| '_ \\
+| |  | | (_) | | | | (_| | | | (__| | | |
+|_|  |_|\\___/|_| |_|\\__,_|_|  \\___|_| |_|
+`));
+  console.log(chalk4.bold("Monarch") + " - Static codebase flow mapping and visualization\n");
+  console.log(chalk4.dim("Analyze TypeScript/JavaScript codebases to extract function call graphs"));
+  console.log(chalk4.dim("and dataflow relationships for visualization and change tracking.\n"));
+  console.log(chalk4.bold.underline("USAGE"));
+  console.log(`  ${chalk4.cyan("monarch")} ${chalk4.yellow("<command>")} ${chalk4.dim("[options]")}
+`);
+  console.log(chalk4.bold.underline("COMMANDS"));
+  console.log();
+  const commandList = [
+    { cmd: "run", alias: "r", desc: "Analyze, detect changes, and start server (recommended)" },
+    { cmd: "init", alias: "", desc: "Initialize a new Monarch project" },
+    { cmd: "analyze", alias: "a", desc: "Analyze codebase and generate artifact" },
+    { cmd: "graph", alias: "g", desc: "Render ASCII graph in terminal" },
+    { cmd: "diff", alias: "d", desc: "Compare two artifacts for changes" },
+    { cmd: "serve", alias: "s", desc: "Start visualization server" },
+    { cmd: "list", alias: "ls", desc: "List artifact contents" },
+    { cmd: "help", alias: "", desc: "Show help for a command" }
+  ];
+  for (const { cmd, alias, desc } of commandList) {
+    const aliasStr = alias ? chalk4.dim(` (${alias})`) : "";
+    console.log(`  ${chalk4.cyan(cmd.padEnd(10))}${aliasStr.padEnd(8)} ${desc}`);
+  }
+  console.log();
+  console.log(chalk4.bold.underline("QUICK START"));
+  console.log();
+  console.log(chalk4.dim("  # Fastest way: analyze and visualize in one command"));
+  console.log(`  ${chalk4.green("$")} monarch run ./src --open`);
+  console.log();
+  console.log(chalk4.dim("  # Or step by step:"));
+  console.log(`  ${chalk4.green("$")} monarch init`);
+  console.log(`  ${chalk4.green("$")} monarch analyze ./src`);
+  console.log(`  ${chalk4.green("$")} monarch serve --open`);
+  console.log();
+  console.log(chalk4.dim("  # Compare changes between versions"));
+  console.log(`  ${chalk4.green("$")} monarch diff baseline.json current.json`);
+  console.log();
+  console.log(chalk4.bold.underline("EXPORTERS"));
+  console.log();
+  console.log(`  ${chalk4.cyan("mock")}       Fast regex-based analysis (default, no dependencies)`);
+  console.log(`  ${chalk4.cyan("codeql-ts")}  Production-grade CodeQL analysis (requires CodeQL CLI)`);
+  console.log();
+  console.log(chalk4.bold.underline("EXAMPLES"));
+  console.log();
+  console.log(chalk4.dim("  # Analyze with custom output"));
+  console.log(`  ${chalk4.green("$")} monarch analyze ./src -o my-graph.json`);
+  console.log();
+  console.log(chalk4.dim("  # Use CodeQL for production analysis"));
+  console.log(`  ${chalk4.green("$")} monarch analyze ./src --exporter codeql-ts`);
+  console.log();
+  console.log(chalk4.dim("  # CI pipeline with diff check"));
+  console.log(`  ${chalk4.green("$")} monarch diff baseline.json current.json --exit-on-changes`);
+  console.log();
+  console.log(chalk4.bold.underline("MORE INFORMATION"));
+  console.log();
+  console.log(`  Run ${chalk4.cyan("monarch help <command>")} for detailed help on a specific command.`);
+  console.log(`  Documentation: ${chalk4.underline("https://github.com/your-username/monarch")}`);
+  console.log();
+}
+function printCommandHelp(cmd) {
+  const aliasStr = cmd.alias ? ` ${chalk4.dim(`(alias: ${cmd.alias})`)}` : "";
+  console.log();
+  console.log(chalk4.bold.cyan(`monarch ${cmd.name}`) + aliasStr);
+  console.log();
+  console.log(cmd.description);
+  console.log();
+  console.log(chalk4.bold.underline("USAGE"));
+  console.log(`  ${chalk4.cyan(cmd.usage)}`);
+  console.log();
+  if (cmd.options.length > 0) {
+    console.log(chalk4.bold.underline("OPTIONS"));
+    console.log();
+    const maxFlagLen = Math.max(...cmd.options.map((o) => o.flag.length));
+    for (const opt of cmd.options) {
+      const defaultStr = opt.default !== void 0 ? chalk4.dim(` [default: ${opt.default}]`) : "";
+      console.log(`  ${chalk4.yellow(opt.flag.padEnd(maxFlagLen + 2))} ${opt.description}${defaultStr}`);
+    }
+    console.log();
+  }
+  console.log(chalk4.bold.underline("EXAMPLES"));
+  console.log();
+  for (const example of cmd.examples) {
+    console.log(`  ${chalk4.green("$")} ${example}`);
+  }
+  console.log();
+}
+
+// src/commands/run.ts
+init_dist();
+init_dist2();
+import fs12 from "fs";
+import path12 from "path";
+import { createServer as createServer2 } from "http";
+import { exec } from "child_process";
+import ora2 from "ora";
+import chalk5 from "chalk";
+async function runCommand(targetPath, options) {
+  const absolutePath = path12.resolve(targetPath);
+  const artifactPath = path12.resolve(options.output);
+  const port = parseInt(options.port, 10);
+  if (!fs12.existsSync(absolutePath)) {
+    log.error(`Path does not exist: ${formatPath(absolutePath)}`);
+    process.exit(1);
+  }
+  log.title("Monarch Run");
+  log.info(`Target: ${formatPath(absolutePath)}`);
+  log.info(`Artifact: ${formatPath(artifactPath)}`);
+  const existingArtifact = loadExistingArtifact(artifactPath);
+  let artifact;
+  let diffSummary = null;
+  if (existingArtifact && !options.force) {
+    log.info("");
+    log.info("Existing graph found, checking for changes...");
+    const newArtifact = await analyzeCodebase(absolutePath, options.exporter);
+    if (!newArtifact) {
+      process.exit(1);
+    }
+    diffSummary = calculateDiffSummary(existingArtifact, newArtifact);
+    if (!diffSummary.hasChanges) {
+      log.success("No changes detected, using existing graph");
+      artifact = existingArtifact;
+    } else {
+      log.warning("Changes detected:");
+      printDiffSummary(diffSummary);
+      artifact = await applyElkLayout(newArtifact);
+      saveArtifact(artifact, artifactPath);
+      log.success(`Updated graph saved to ${formatPath(artifactPath)}`);
+    }
+  } else {
+    if (options.force) {
+      log.info("Force flag set, regenerating graph...");
+    } else {
+      log.info("No existing graph found, generating...");
+    }
+    const newArtifact = await analyzeCodebase(absolutePath, options.exporter);
+    if (!newArtifact) {
+      process.exit(1);
+    }
+    artifact = await applyElkLayout(newArtifact);
+    saveArtifact(artifact, artifactPath);
+    log.success(`Graph saved to ${formatPath(artifactPath)}`);
+  }
+  console.log("");
+  log.info(chalk5.bold("Graph Summary:"));
+  log.info(`  Functions:  ${formatNumber(artifact.nodes.functions.length)}`);
+  log.info(`  Modules:    ${formatNumber(artifact.nodes.modules.length)}`);
+  log.info(`  Components: ${formatNumber(artifact.nodes.components.length)}`);
+  log.info(`  Call edges: ${formatNumber(artifact.edges.calls.length)}`);
+  log.info(`  Dataflow:   ${formatNumber(artifact.edges.dataflow.length)}`);
+  console.log("");
+  await startServer(artifactPath, port, options.open);
+}
+function loadExistingArtifact(artifactPath) {
+  if (!fs12.existsSync(artifactPath)) {
+    return null;
+  }
+  try {
+    const content = fs12.readFileSync(artifactPath, "utf-8");
+    const artifact = JSON.parse(content);
+    if (!isCodeFlowArtifact(artifact)) {
+      return null;
+    }
+    return artifact;
+  } catch {
+    return null;
+  }
+}
+async function analyzeCodebase(targetPath, exporterName) {
+  const spinner = ora2("Analyzing codebase...").start();
+  try {
+    let artifact;
+    if (exporterName === "mock") {
+      const exporter = new MockExporter(targetPath);
+      await exporter.prepare();
+      spinner.text = "Scanning files...";
+      await exporter.analyze();
+      spinner.text = "Generating artifact...";
+      artifact = await exporter.export();
+      await exporter.cleanup();
+    } else if (exporterName === "codeql-ts") {
+      spinner.text = "Creating CodeQL database...";
+      const { CodeQLExporter: CodeQLExporter2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+      const exporter = new CodeQLExporter2(targetPath);
+      await exporter.prepare();
+      spinner.text = "Running CodeQL queries...";
+      await exporter.analyze();
+      spinner.text = "Generating artifact...";
+      artifact = await exporter.export();
+      await exporter.cleanup();
+    } else {
+      spinner.fail(`Unknown exporter: ${exporterName}`);
+      return null;
+    }
+    spinner.succeed("Analysis complete");
+    return artifact;
+  } catch (error) {
+    spinner.fail("Analysis failed");
+    log.error(String(error));
+    return null;
+  }
+}
+function calculateDiffSummary(baseline, current) {
+  const baselineFnIds = new Set(baseline.nodes.functions.map((fn) => fn.id));
+  const currentFnIds = new Set(current.nodes.functions.map((fn) => fn.id));
+  const functionsAdded = current.nodes.functions.filter(
+    (fn) => !baselineFnIds.has(fn.id)
+  ).length;
+  const functionsRemoved = baseline.nodes.functions.filter(
+    (fn) => !currentFnIds.has(fn.id)
+  ).length;
+  const baselineModIds = new Set(baseline.nodes.modules.map((m) => m.id));
+  const currentModIds = new Set(current.nodes.modules.map((m) => m.id));
+  const modulesAdded = current.nodes.modules.filter(
+    (m) => !baselineModIds.has(m.id)
+  ).length;
+  const modulesRemoved = baseline.nodes.modules.filter(
+    (m) => !currentModIds.has(m.id)
+  ).length;
+  const edgeKey = (e) => `${e.from}->${e.to}`;
+  const baselineCallEdges = new Set(baseline.edges.calls.map(edgeKey));
+  const currentCallEdges = new Set(current.edges.calls.map(edgeKey));
+  const callEdgesAdded = current.edges.calls.filter(
+    (e) => !baselineCallEdges.has(edgeKey(e))
+  ).length;
+  const callEdgesRemoved = baseline.edges.calls.filter(
+    (e) => !currentCallEdges.has(edgeKey(e))
+  ).length;
+  const hasChanges = functionsAdded > 0 || functionsRemoved > 0 || modulesAdded > 0 || modulesRemoved > 0 || callEdgesAdded > 0 || callEdgesRemoved > 0;
+  return {
+    hasChanges,
+    functionsAdded,
+    functionsRemoved,
+    modulesAdded,
+    modulesRemoved,
+    callEdgesAdded,
+    callEdgesRemoved
+  };
+}
+function printDiffSummary(diff) {
+  console.log(`    Functions:  ${formatDiff(diff.functionsAdded, diff.functionsRemoved)}`);
+  console.log(`    Modules:    ${formatDiff(diff.modulesAdded, diff.modulesRemoved)}`);
+  console.log(`    Call edges: ${formatDiff(diff.callEdgesAdded, diff.callEdgesRemoved)}`);
+}
+function saveArtifact(artifact, outputPath) {
+  const outputDir = path12.dirname(outputPath);
+  if (!fs12.existsSync(outputDir)) {
+    fs12.mkdirSync(outputDir, { recursive: true });
+  }
+  fs12.writeFileSync(outputPath, JSON.stringify(artifact, null, 2));
+}
+async function startServer(artifactPath, port, openBrowser) {
+  const isPortInUse = await checkPort(port);
+  if (isPortInUse) {
+    log.info(`Server already running on port ${port}`);
+    log.success(`View graph at ${chalk5.underline(`http://localhost:${port}`)}`);
+    if (openBrowser) {
+      openInBrowser(`http://localhost:${port}`);
+    }
+    return;
+  }
+  log.info("Starting visualization server...");
+  const server = createServer2((req, res) => {
+    const url = req.url || "/";
+    if (url === "/api/artifact") {
+      res.setHeader("Content-Type", "application/json");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      const content = fs12.readFileSync(artifactPath, "utf-8");
+      res.end(content);
+    } else if (url === "/api/reload") {
+      res.setHeader("Content-Type", "application/json");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.end(JSON.stringify({ status: "ok" }));
+    } else if (url === "/") {
+      res.setHeader("Content-Type", "text/html");
+      res.end(getIndexHtml2(port, artifactPath));
+    } else {
+      res.statusCode = 404;
+      res.end("Not Found");
+    }
+  });
+  return new Promise((resolve) => {
+    server.listen(port, () => {
+      log.success(`Server running at ${chalk5.underline(`http://localhost:${port}`)}`);
+      log.info(`Serving: ${formatPath(artifactPath)}`);
+      log.dim("\nPress Ctrl+C to stop");
+      if (openBrowser) {
+        openInBrowser(`http://localhost:${port}`);
+      }
+      process.on("SIGINT", () => {
+        log.info("\nShutting down server...");
+        server.close(() => {
+          process.exit(0);
+        });
+      });
+      resolve();
+    });
+  });
+}
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const server = createServer2();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve(false);
+    });
+    server.listen(port);
+  });
+}
+function openInBrowser(url) {
+  const cmd = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+  exec(`${cmd} ${url}`);
+}
+function getIndexHtml2(port, artifactPath) {
+  const fileName = path12.basename(artifactPath);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Monarch - Graph Visualization</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+      color: #fff;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      max-width: 600px;
+    }
+    .logo {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      font-size: 2.5rem;
+      margin-bottom: 0.5rem;
+      background: linear-gradient(135deg, #4a90d9, #67b26f);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+    }
+    .tagline {
+      color: #888;
+      margin-bottom: 2rem;
+      font-size: 1.1rem;
+    }
+    .card {
+      background: rgba(255, 255, 255, 0.05);
+      border: 1px solid rgba(255, 255, 255, 0.1);
+      padding: 1.5rem;
+      border-radius: 12px;
+      margin-bottom: 1.5rem;
+    }
+    .card h2 {
+      font-size: 1rem;
+      color: #4a90d9;
+      margin-bottom: 0.75rem;
+      text-transform: uppercase;
+      letter-spacing: 1px;
+    }
+    .endpoint {
+      background: rgba(0, 0, 0, 0.3);
+      padding: 0.75rem 1rem;
+      border-radius: 6px;
+      font-family: 'SF Mono', Monaco, monospace;
+      font-size: 0.9rem;
+      color: #67b26f;
+      word-break: break-all;
+    }
+    .file-name {
+      color: #ffd93d;
+      font-family: 'SF Mono', Monaco, monospace;
+    }
+    .instructions {
+      color: #888;
+      font-size: 0.9rem;
+      line-height: 1.6;
+    }
+    .instructions code {
+      background: rgba(255, 255, 255, 0.1);
+      padding: 0.2rem 0.5rem;
+      border-radius: 4px;
+      font-family: 'SF Mono', Monaco, monospace;
+      color: #4a90d9;
+    }
+    .status {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      background: rgba(103, 178, 111, 0.2);
+      color: #67b26f;
+      padding: 0.5rem 1rem;
+      border-radius: 20px;
+      font-size: 0.85rem;
+      margin-top: 1rem;
+    }
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      background: #67b26f;
+      border-radius: 50%;
+      animation: pulse 2s infinite;
+    }
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="logo">\u{1F52E}</div>
+    <h1>Monarch</h1>
+    <p class="tagline">Static Codebase Flow Mapping</p>
+
+    <div class="card">
+      <h2>Current Graph</h2>
+      <p class="file-name">${fileName}</p>
+    </div>
+
+    <div class="card">
+      <h2>API Endpoint</h2>
+      <p class="endpoint">http://localhost:${port}/api/artifact</p>
+    </div>
+
+    <div class="card">
+      <h2>View Full Visualization</h2>
+      <p class="instructions">
+        Run the UI development server:<br><br>
+        <code>pnpm --filter @codeflow/ui dev</code>
+      </p>
+    </div>
+
+    <div class="status">
+      <span class="status-dot"></span>
+      Server running on port ${port}
+    </div>
+  </div>
+</body>
+</html>`;
+}
+
+// src/commands/graph.ts
+init_dist();
+import fs13 from "fs";
+import path13 from "path";
+
+// src/utils/ascii-graph.ts
+import chalk6 from "chalk";
+var BOX_CHARS = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  arrow: "\u2192",
+  arrowDown: "\u2193",
+  junction: "\u251C",
+  junctionRight: "\u2524"
+};
+function renderAsciiGraph(artifact, level, options = {}) {
+  const { maxWidth = 80, showEdgeCounts = true, colorize = true } = options;
+  const { nodes, edges } = extractGraphData(artifact, level);
+  if (nodes.length === 0) {
+    return chalk6.yellow("No nodes found at this level.");
+  }
+  const lines = [];
+  lines.push(formatHeader(level, nodes.length, edges.length, colorize));
+  lines.push("");
+  const { roots, connected, isolated } = categorizeNodes(nodes, edges);
+  if (roots.length > 0 || connected.length > 0) {
+    lines.push(formatSectionHeader("Connected Graph", colorize));
+    lines.push(...renderConnectedGraph(nodes, edges, maxWidth, showEdgeCounts, colorize));
+    lines.push("");
+  }
+  if (isolated.length > 0) {
+    lines.push(formatSectionHeader(`Isolated Nodes (${isolated.length})`, colorize));
+    lines.push(...renderIsolatedNodes(isolated, nodes, maxWidth, colorize));
+  }
+  return lines.join("\n");
+}
+function renderExpandedView(artifact, targetName, targetType, options = {}) {
+  const { maxWidth = 80, showEdgeCounts = true, colorize = true } = options;
+  const lines = [];
+  if (targetType === "component") {
+    const component = artifact.nodes.components.find(
+      (c) => c.name === targetName || c.id === targetName
+    );
+    if (!component) {
+      return chalk6.red(`Component not found: ${targetName}`);
+    }
+    lines.push(formatHeader(`Component: ${component.name}`, 0, 0, colorize));
+    lines.push("");
+    const moduleIds = new Set(component.moduleIds || []);
+    const modules = artifact.nodes.modules.filter((m) => moduleIds.has(m.id));
+    if (modules.length === 0) {
+      lines.push(chalk6.yellow("  No modules in this component."));
+      return lines.join("\n");
+    }
+    const moduleFunctionIds = /* @__PURE__ */ new Map();
+    for (const mod of modules) {
+      moduleFunctionIds.set(mod.id, new Set(mod.functionIds || []));
+    }
+    const edges = aggregateEdgesBetweenContainers(
+      artifact,
+      modules.map((m) => m.id),
+      moduleFunctionIds
+    );
+    const nodes = modules.map((m) => ({
+      id: m.id,
+      label: formatModulePath(m.path),
+      type: "module",
+      children: m.functionIds?.length || 0
+    }));
+    lines.push(formatSectionHeader(`Modules (${modules.length})`, colorize));
+    if (edges.length > 0) {
+      lines.push(...renderConnectedGraph(nodes, edges, maxWidth, showEdgeCounts, colorize));
+    } else {
+      for (const node of nodes) {
+        lines.push(formatNode(node, colorize));
+      }
+    }
+  } else {
+    const module = artifact.nodes.modules.find(
+      (m) => m.path === targetName || m.id === targetName || m.path.endsWith(targetName)
+    );
+    if (!module) {
+      return chalk6.red(`Module not found: ${targetName}`);
+    }
+    lines.push(formatHeader(`Module: ${module.path}`, 0, 0, colorize));
+    lines.push("");
+    const functionIds = new Set(module.functionIds || []);
+    const functions = artifact.nodes.functions.filter((f) => functionIds.has(f.id));
+    if (functions.length === 0) {
+      lines.push(chalk6.yellow("  No functions in this module."));
+      return lines.join("\n");
+    }
+    const edges = getEdgesBetweenFunctions(artifact, functionIds);
+    const nodes = functions.map((f) => ({
+      id: f.id,
+      label: formatFunctionName(f),
+      type: "function"
+    }));
+    lines.push(formatSectionHeader(`Functions (${functions.length})`, colorize));
+    if (edges.length > 0) {
+      lines.push(...renderConnectedGraph(nodes, edges, maxWidth, showEdgeCounts, colorize));
+    } else {
+      for (const node of nodes) {
+        lines.push(formatNode(node, colorize));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function listExpandableItems(artifact) {
+  const lines = [];
+  lines.push(chalk6.bold.cyan("\nExpandable Items\n"));
+  lines.push(chalk6.bold("Components:"));
+  if (artifact.nodes.components.length === 0) {
+    lines.push(chalk6.dim("  (none)"));
+  } else {
+    for (const comp of artifact.nodes.components) {
+      const modCount = comp.moduleIds?.length || 0;
+      lines.push(`  ${chalk6.cyan(comp.name)} ${chalk6.dim(`(${modCount} modules)`)}`);
+    }
+  }
+  lines.push("");
+  lines.push(chalk6.bold("Modules:"));
+  if (artifact.nodes.modules.length === 0) {
+    lines.push(chalk6.dim("  (none)"));
+  } else {
+    for (const mod of artifact.nodes.modules) {
+      const fnCount = mod.functionIds?.length || 0;
+      lines.push(`  ${chalk6.cyan(formatModulePath(mod.path))} ${chalk6.dim(`(${fnCount} functions)`)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function extractGraphData(artifact, level) {
+  switch (level) {
+    case "components":
+      return extractComponentGraph(artifact);
+    case "modules":
+      return extractModuleGraph(artifact);
+    case "functions":
+      return extractFunctionGraph(artifact);
+  }
+}
+function extractComponentGraph(artifact) {
+  const nodes = artifact.nodes.components.map((c) => ({
+    id: c.id,
+    label: c.name,
+    type: "component",
+    children: c.moduleIds?.length || 0
+  }));
+  const functionToComponent = /* @__PURE__ */ new Map();
+  for (const comp of artifact.nodes.components) {
+    for (const modId of comp.moduleIds || []) {
+      const mod = artifact.nodes.modules.find((m) => m.id === modId);
+      if (mod) {
+        for (const fnId of mod.functionIds || []) {
+          functionToComponent.set(fnId, comp.id);
+        }
+      }
+    }
+  }
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const edge of artifact.edges.calls) {
+    const fromComp = functionToComponent.get(edge.from);
+    const toComp = functionToComponent.get(edge.to);
+    if (fromComp && toComp && fromComp !== toComp) {
+      const key = `${fromComp}->${toComp}`;
+      edgeMap.set(key, (edgeMap.get(key) || 0) + 1);
+    }
+  }
+  const edges = Array.from(edgeMap.entries()).map(([key, count]) => {
+    const [from, to] = key.split("->");
+    return { from, to, count };
+  });
+  return { nodes, edges };
+}
+function extractModuleGraph(artifact) {
+  const nodes = artifact.nodes.modules.map((m) => ({
+    id: m.id,
+    label: formatModulePath(m.path),
+    type: "module",
+    children: m.functionIds?.length || 0
+  }));
+  const functionToModule = /* @__PURE__ */ new Map();
+  for (const mod of artifact.nodes.modules) {
+    for (const fnId of mod.functionIds || []) {
+      functionToModule.set(fnId, mod.id);
+    }
+  }
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const edge of artifact.edges.calls) {
+    const fromMod = functionToModule.get(edge.from);
+    const toMod = functionToModule.get(edge.to);
+    if (fromMod && toMod && fromMod !== toMod) {
+      const key = `${fromMod}->${toMod}`;
+      edgeMap.set(key, (edgeMap.get(key) || 0) + 1);
+    }
+  }
+  const edges = Array.from(edgeMap.entries()).map(([key, count]) => {
+    const [from, to] = key.split("->");
+    return { from, to, count };
+  });
+  return { nodes, edges };
+}
+function extractFunctionGraph(artifact) {
+  const nodes = artifact.nodes.functions.map((f) => ({
+    id: f.id,
+    label: formatFunctionName(f),
+    type: "function"
+  }));
+  const edges = artifact.edges.calls.map((e) => ({
+    from: e.from,
+    to: e.to,
+    count: e.callsites.length
+  }));
+  return { nodes, edges };
+}
+function aggregateEdgesBetweenContainers(artifact, containerIds, containerFunctions) {
+  const containerSet = new Set(containerIds);
+  const functionToContainer = /* @__PURE__ */ new Map();
+  for (const [containerId, fnIds] of containerFunctions) {
+    for (const fnId of fnIds) {
+      functionToContainer.set(fnId, containerId);
+    }
+  }
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const edge of artifact.edges.calls) {
+    const fromContainer = functionToContainer.get(edge.from);
+    const toContainer = functionToContainer.get(edge.to);
+    if (fromContainer && toContainer && containerSet.has(fromContainer) && containerSet.has(toContainer) && fromContainer !== toContainer) {
+      const key = `${fromContainer}->${toContainer}`;
+      edgeMap.set(key, (edgeMap.get(key) || 0) + 1);
+    }
+  }
+  return Array.from(edgeMap.entries()).map(([key, count]) => {
+    const [from, to] = key.split("->");
+    return { from, to, count };
+  });
+}
+function getEdgesBetweenFunctions(artifact, functionIds) {
+  return artifact.edges.calls.filter((e) => functionIds.has(e.from) && functionIds.has(e.to)).map((e) => ({
+    from: e.from,
+    to: e.to,
+    count: e.callsites.length
+  }));
+}
+function categorizeNodes(nodes, edges) {
+  const hasIncoming = /* @__PURE__ */ new Set();
+  const hasOutgoing = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    hasOutgoing.add(edge.from);
+    hasIncoming.add(edge.to);
+  }
+  const roots = [];
+  const connected = [];
+  const isolated = [];
+  for (const node of nodes) {
+    const incoming = hasIncoming.has(node.id);
+    const outgoing = hasOutgoing.has(node.id);
+    if (!incoming && !outgoing) {
+      isolated.push(node.id);
+    } else if (!incoming && outgoing) {
+      roots.push(node.id);
+    } else {
+      connected.push(node.id);
+    }
+  }
+  return { roots, connected, isolated };
+}
+function renderConnectedGraph(nodes, edges, _maxWidth, showEdgeCounts, colorize) {
+  const lines = [];
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!outgoing.has(edge.from)) outgoing.set(edge.from, []);
+    if (!incoming.has(edge.to)) incoming.set(edge.to, []);
+    outgoing.get(edge.from).push(edge);
+    incoming.get(edge.to).push(edge);
+  }
+  const roots = nodes.filter((n) => !incoming.has(n.id) && outgoing.has(n.id));
+  const visited = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    lines.push(...renderNodeTree(root, nodeMap, outgoing, visited, 0, showEdgeCounts, colorize));
+  }
+  for (const node of nodes) {
+    if (!visited.has(node.id) && (outgoing.has(node.id) || incoming.has(node.id))) {
+      lines.push(...renderNodeTree(node, nodeMap, outgoing, visited, 0, showEdgeCounts, colorize));
+    }
+  }
+  return lines;
+}
+function renderNodeTree(node, nodeMap, outgoing, visited, depth, showEdgeCounts, colorize) {
+  if (visited.has(node.id)) {
+    return [`${"  ".repeat(depth)}${BOX_CHARS.arrow} ${chalk6.dim(`(${node.label} - cycle)`)}`];
+  }
+  visited.add(node.id);
+  const lines = [];
+  const indent = "  ".repeat(depth);
+  const nodeStr = formatNode(node, colorize);
+  lines.push(`${indent}${nodeStr}`);
+  const children = outgoing.get(node.id) || [];
+  for (let i = 0; i < children.length; i++) {
+    const edge = children[i];
+    const targetNode = nodeMap.get(edge.to);
+    const isLast = i === children.length - 1;
+    const prefix = isLast ? BOX_CHARS.bottomLeft : BOX_CHARS.junction;
+    const countStr = showEdgeCounts && edge.count > 1 ? chalk6.dim(` (${edge.count}x)`) : "";
+    if (targetNode) {
+      if (visited.has(targetNode.id)) {
+        lines.push(
+          `${indent}  ${prefix}${BOX_CHARS.horizontal}${BOX_CHARS.arrow} ${chalk6.dim(`${targetNode.label} (cycle)`)}${countStr}`
+        );
+      } else {
+        lines.push(`${indent}  ${prefix}${BOX_CHARS.horizontal}${BOX_CHARS.arrow}${countStr}`);
+        lines.push(
+          ...renderNodeTree(targetNode, nodeMap, outgoing, visited, depth + 2, showEdgeCounts, colorize)
+        );
+      }
+    }
+  }
+  return lines;
+}
+function renderIsolatedNodes(isolatedIds, nodes, maxWidth, colorize) {
+  const lines = [];
+  const isolatedNodes = nodes.filter((n) => isolatedIds.includes(n.id));
+  const colWidth = 30;
+  const cols = Math.max(1, Math.floor(maxWidth / colWidth));
+  for (let i = 0; i < isolatedNodes.length; i += cols) {
+    const row = isolatedNodes.slice(i, i + cols);
+    const rowStr = row.map((n) => formatNode(n, colorize).padEnd(colWidth)).join("");
+    lines.push(`  ${rowStr}`);
+  }
+  return lines;
+}
+function formatNode(node, colorize) {
+  const icon = getNodeIcon(node.type);
+  const label = node.label;
+  const childInfo = node.children !== void 0 ? chalk6.dim(` (${node.children})`) : "";
+  if (colorize) {
+    const color = getNodeColor(node.type);
+    return `${icon} ${color(label)}${childInfo}`;
+  }
+  return `${icon} ${label}${childInfo}`;
+}
+function getNodeIcon(type) {
+  switch (type) {
+    case "component":
+      return "\u{1F4E6}";
+    case "module":
+      return "\u{1F4C4}";
+    case "function":
+      return "\u26A1";
+  }
+}
+function getNodeColor(type) {
+  switch (type) {
+    case "component":
+      return chalk6.cyan;
+    case "module":
+      return chalk6.yellow;
+    case "function":
+      return chalk6.green;
+  }
+}
+function formatHeader(title, nodeCount, edgeCount, colorize) {
+  const levelTitles = {
+    components: "Component Graph",
+    modules: "Module Graph",
+    functions: "Function Graph"
+  };
+  const displayTitle = levelTitles[title] || title;
+  if (nodeCount === 0 && edgeCount === 0) {
+    return colorize ? chalk6.bold.cyan(`
+${displayTitle}
+`) : `
+${displayTitle}
+`;
+  }
+  const stats = `${nodeCount} nodes, ${edgeCount} edges`;
+  const header = `${displayTitle} (${stats})`;
+  return colorize ? chalk6.bold.cyan(`
+${header}
+`) : `
+${header}
+`;
+}
+function formatSectionHeader(title, colorize) {
+  return colorize ? chalk6.bold.underline(title) : title;
+}
+function formatModulePath(path14) {
+  const parts = path14.split(/[/\\]/);
+  if (parts.length > 3) {
+    return `.../${parts.slice(-2).join("/")}`;
+  }
+  return path14;
+}
+function formatFunctionName(fn) {
+  const kindIcon = fn.kind === "method" ? "." : fn.kind === "arrow" ? "=>" : "";
+  return `${kindIcon}${fn.name}`;
+}
+
+// src/commands/graph.ts
+async function graphCommand(artifactPath, options) {
+  const absolutePath = path13.resolve(artifactPath);
+  if (!fs13.existsSync(absolutePath)) {
+    log.error(`Artifact not found: ${formatPath(absolutePath)}`);
+    log.info("Run `monarch analyze` or `monarch run` first to generate a graph");
+    process.exit(1);
+  }
+  let artifact;
+  try {
+    const content = fs13.readFileSync(absolutePath, "utf-8");
+    artifact = JSON.parse(content);
+    if (!isCodeFlowArtifact(artifact)) {
+      log.error("Invalid artifact file");
+      process.exit(1);
+    }
+  } catch (error) {
+    log.error(`Failed to read artifact: ${error}`);
+    process.exit(1);
+  }
+  const maxWidth = options.width ? parseInt(options.width, 10) : process.stdout.columns || 80;
+  const colorize = !options.noColor;
+  if (options.list) {
+    console.log(listExpandableItems(artifact));
+    return;
+  }
+  if (options.expand) {
+    const expandType = options.expandType || detectExpandType(artifact, options.expand);
+    if (!expandType) {
+      log.error(`Could not find "${options.expand}" as a component or module.`);
+      log.info("Use --list to see available components and modules.");
+      process.exit(1);
+    }
+    const output2 = renderExpandedView(artifact, options.expand, expandType, {
+      maxWidth,
+      colorize,
+      showEdgeCounts: true
+    });
+    console.log(output2);
+    return;
+  }
+  const output = renderAsciiGraph(artifact, options.level, {
+    maxWidth,
+    colorize,
+    showEdgeCounts: true
+  });
+  console.log(output);
+}
+function detectExpandType(artifact, name) {
+  const component = artifact.nodes.components.find(
+    (c) => c.name === name || c.id === name
+  );
+  if (component) return "component";
+  const module = artifact.nodes.modules.find(
+    (m) => m.path === name || m.id === name || m.path.endsWith(name)
+  );
+  if (module) return "module";
+  return null;
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("monarch").description("Monarch - Static codebase flow mapping and visualization").version("0.1.0").addHelpCommand(false);
+program.command("init").description("Initialize a new Monarch project in the current directory").option("-f, --force", "Overwrite existing configuration", false).action(initCommand);
+program.command("analyze").alias("a").description("Analyze a codebase and generate flow artifact").argument("[path]", "Path to the codebase", ".").option("-o, --output <path>", "Output artifact path", "monarch-graph.json").option("-e, --exporter <name>", "Exporter to use (mock, codeql-ts)", "mock").option("-w, --watch", "Watch for changes and re-analyze", false).action(analyzeCommand2);
+program.command("diff").alias("d").description("Compare two graph artifacts and show changes").argument("<baseline>", "Path to baseline artifact").argument("<current>", "Path to current artifact").option("-f, --format <type>", "Output format (text, json, markdown)", "text").option("--exit-on-changes", "Exit with code 1 if changes detected", false).option("--only <type>", "Show only specific changes (functions, modules, edges)").action(diffCommand2);
+program.command("serve").alias("s").description("Start the visualization UI server").option("-p, --port <number>", "Port to serve on", "3000").option("-a, --artifact <path>", "Artifact file path", "monarch-graph.json").option("--open", "Open browser automatically", false).action(serveCommand2);
+program.command("list").alias("ls").description("List contents of a graph artifact").argument("[artifact]", "Path to artifact file", "monarch-graph.json").option("-t, --type <type>", "Filter by type (functions, modules, components, edges)").option("--json", "Output as JSON", false).action(listCommand);
+program.command("run").alias("r").description("Analyze codebase, detect changes, and start visualization server").argument("[path]", "Path to the codebase", ".").option("-o, --output <path>", "Output artifact path", "monarch-graph.json").option("-e, --exporter <name>", "Exporter to use (mock, codeql-ts)", "mock").option("-p, --port <number>", "Port for visualization server", "3000").option("--open", "Open browser automatically", false).option("-f, --force", "Force regeneration even if no changes", false).action(runCommand);
+program.command("graph").alias("g").description("Render ASCII graph visualization in terminal").argument("[artifact]", "Path to artifact file", "monarch-graph.json").option("-l, --level <level>", "View level (components, modules, functions)", "modules").option("-x, --expand <name>", "Expand a specific component or module by name").option("--expand-type <type>", "Type of item to expand (component, module)").option("--list", "List expandable components and modules", false).option("--no-color", "Disable colored output").option("-w, --width <cols>", "Max output width in columns").action(graphCommand);
+program.command("help").description("Show detailed help for Monarch or a specific command").argument("[command]", "Command to get help for").action(helpCommand);
 if (process.argv.length === 2) {
-    helpCommand();
-    process.exit(0);
+  helpCommand();
+  process.exit(0);
 }
-// Parse and execute
 program.parse();
-//# sourceMappingURL=cli.js.map