monarch-code-graph 0.3.4 → 0.3.5

package/dist/index.js

@@ -1,7 +1,1552 @@
-// Re-export for programmatic usage
-export * from './commands/analyze.js';
-export * from './commands/diff.js';
-export * from './commands/serve.js';
-export * from './commands/init.js';
-export * from './commands/list.js';
-//# sourceMappingURL=index.js.map
+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(path12) {
+  const input = `mod:${path12}`;
+  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/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 }) => {
+        const cmd = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+        exec(`${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;
+  }, {});
+}
+export {
+  analyzeCommand2 as analyzeCommand,
+  diffCommand2 as diffCommand,
+  initCommand,
+  listCommand,
+  serveCommand2 as serveCommand
+};