@clarity-tools/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2610 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command2 } from "commander";
+
+// ../core/src/graph/schema.ts
+import { z } from "zod";
+var PortMappingSchema = z.object({
+  internal: z.number(),
+  external: z.number().optional()
+});
+var VolumeMountSchema = z.object({
+  source: z.string(),
+  target: z.string(),
+  type: z.enum(["volume", "bind", "tmpfs"]).optional()
+});
+var SourceInfoSchema = z.object({
+  file: z.string(),
+  format: z.enum(["docker-compose", "helm", "terraform", "ansible"]),
+  line: z.number().optional()
+});
+var ServiceNodeSchema = z.object({
+  id: z.string().min(1),
+  name: z.string(),
+  type: z.enum([
+    "container",
+    "database",
+    "cache",
+    "queue",
+    "storage",
+    "proxy",
+    "ui"
+  ]),
+  source: SourceInfoSchema,
+  image: z.string().optional(),
+  ports: z.array(PortMappingSchema).optional(),
+  volumes: z.array(VolumeMountSchema).optional(),
+  // Environment values can be strings, numbers, booleans, or null (pass-through from host)
+  environment: z.record(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional(),
+  replicas: z.number().optional(),
+  resourceRequests: z.object({
+    cpu: z.string().optional(),
+    memory: z.string().optional()
+  }).optional(),
+  storageSize: z.string().optional(),
+  external: z.boolean().optional(),
+  description: z.string().optional(),
+  group: z.string().optional(),
+  queueRole: z.enum(["producer", "consumer", "both"]).optional()
+});
+var DependencyEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  type: z.enum([
+    "depends_on",
+    "network",
+    "volume",
+    "link",
+    "inferred",
+    "subchart"
+  ]),
+  port: z.number().optional(),
+  protocol: z.string().optional()
+});
+var GraphMetadataSchema = z.object({
+  project: z.string(),
+  parsedAt: z.string().datetime(),
+  sourceFiles: z.array(z.string()),
+  parserVersion: z.string()
+});
+var InfraGraphSchema = z.object({
+  nodes: z.array(ServiceNodeSchema),
+  edges: z.array(DependencyEdgeSchema),
+  metadata: GraphMetadataSchema
+}).refine(
+  (graph) => {
+    const nodeIds = new Set(graph.nodes.map((n) => n.id));
+    return graph.edges.every((e) => nodeIds.has(e.from) && nodeIds.has(e.to));
+  },
+  { message: "Edge references non-existent node" }
+).refine(
+  (graph) => {
+    const ids = graph.nodes.map((n) => n.id);
+    return new Set(ids).size === ids.length;
+  },
+  { message: "Duplicate node IDs detected" }
+);
+
+// ../core/src/graph/builder.ts
+var GraphBuilder = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  sourceFiles = [];
+  project;
+  constructor(project) {
+    this.project = project;
+  }
+  addSourceFile(file) {
+    if (!this.sourceFiles.includes(file)) {
+      this.sourceFiles.push(file);
+    }
+    return this;
+  }
+  addNode(id, name, type, source, options) {
+    this.nodes.set(id, {
+      id,
+      name,
+      type,
+      source,
+      ...options
+    });
+    return this;
+  }
+  addEdge(from, to, type, options) {
+    if (this.nodes.has(from) && this.nodes.has(to)) {
+      const existingEdge = this.edges.find(
+        (e) => e.from === from && e.to === to
+      );
+      if (type === "inferred" && existingEdge) {
+        return this;
+      }
+      const duplicateExists = this.edges.some(
+        (e) => e.from === from && e.to === to && e.type === type
+      );
+      if (duplicateExists) {
+        return this;
+      }
+      this.edges.push({
+        from,
+        to,
+        type,
+        ...options
+      });
+    }
+    return this;
+  }
+  hasNode(id) {
+    return this.nodes.has(id);
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  build() {
+    return {
+      nodes: Array.from(this.nodes.values()),
+      edges: this.edges,
+      metadata: {
+        project: this.project,
+        parsedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceFiles: this.sourceFiles,
+        parserVersion: "0.1.0"
+      }
+    };
+  }
+};
+
+// ../core/src/parsers/docker-compose.ts
+import { parse as parseYaml } from "yaml";
+
+// ../core/src/parsers/utils.ts
+function inferServiceType(serviceName, image) {
+  const name = (image ?? serviceName).toLowerCase();
+  if (name.includes("postgres") || name.includes("mysql") || name.includes("mariadb") || name.includes("mongo") || name.includes("clickhouse") || name.includes("cassandra") || name.includes("cockroach") || name.includes("schema")) {
+    return "database";
+  }
+  if (name.includes("redis") || name.includes("memcache") || name.includes("keydb") || name.includes("elasticsearch") || name.includes("opensearch")) {
+    return "cache";
+  }
+  if (name.includes("kafka") || name.includes("rabbitmq") || name.includes("nats") || name.includes("pulsar") || name.includes("zookeeper")) {
+    return "queue";
+  }
+  if (name.includes("minio") || name.includes("seaweedfs") || name.includes("seaweed") || name.includes("objectstorage") || name.includes("s3") || name.includes("gcs") || name.includes("ceph")) {
+    return "storage";
+  }
+  if (name.includes("nginx") || name.includes("traefik") || name.includes("haproxy") || name.includes("envoy") || name.includes("caddy")) {
+    return "proxy";
+  }
+  if ((name.includes("web") || name.includes("frontend") || name.includes("ui") || name.includes("console") || name.includes("dashboard") || name.includes("portal")) && !name.includes("grafana") && !name.includes("kibana")) {
+    return "ui";
+  }
+  return "container";
+}
+
+// ../core/src/parsers/docker-compose.ts
+var yamlParseOptions = {
+  // Allow unlimited aliases for complex docker-compose files like Sentry
+  maxAliasCount: -1,
+  // Enable YAML merge key (<<) support for docker-compose anchor inheritance
+  merge: true
+};
+function parsePort(port) {
+  if (typeof port === "object") {
+    if (port.target) {
+      return {
+        internal: port.target,
+        external: port.published
+      };
+    }
+    return null;
+  }
+  const str = String(port);
+  const parts = str.split(":").map((p) => p.split("/")[0]);
+  if (parts.length === 1) {
+    const num = Number.parseInt(parts[0] ?? "", 10);
+    return Number.isNaN(num) ? null : { internal: num };
+  }
+  if (parts.length === 2) {
+    const ext = Number.parseInt(parts[0] ?? "", 10);
+    const int = Number.parseInt(parts[1] ?? "", 10);
+    return Number.isNaN(ext) || Number.isNaN(int) ? null : { internal: int, external: ext };
+  }
+  if (parts.length === 3) {
+    const ext = Number.parseInt(parts[1] ?? "", 10);
+    const int = Number.parseInt(parts[2] ?? "", 10);
+    return Number.isNaN(ext) || Number.isNaN(int) ? null : { internal: int, external: ext };
+  }
+  return null;
+}
+function parseVolume(vol) {
+  if (typeof vol === "object") {
+    if (vol.source && vol.target) {
+      return {
+        source: vol.source,
+        target: vol.target,
+        type: vol.type
+      };
+    }
+    return null;
+  }
+  const str = String(vol);
+  const parts = str.split(":");
+  if (parts.length >= 2) {
+    const source = parts[0];
+    const target = parts[1];
+    if (source && target) {
+      const type = source.startsWith("/") || source.startsWith(".") ? "bind" : "volume";
+      return { source, target, type };
+    }
+  }
+  return null;
+}
+function parseEnvironment(env) {
+  if (!env) return void 0;
+  if (Array.isArray(env)) {
+    const record = {};
+    for (const item of env) {
+      const idx = item.indexOf("=");
+      if (idx > 0) {
+        const key = item.slice(0, idx);
+        const value = item.slice(idx + 1);
+        record[key] = value;
+      }
+    }
+    return Object.keys(record).length > 0 ? record : void 0;
+  }
+  return Object.keys(env).length > 0 ? env : void 0;
+}
+function parseDockerCompose(content, filename, project) {
+  const compose = parseYaml(content, yamlParseOptions);
+  if (!compose?.services) {
+    return {
+      nodes: [],
+      edges: [],
+      metadata: {
+        project,
+        parsedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceFiles: [filename],
+        parserVersion: "0.1.0"
+      }
+    };
+  }
+  const builder = new GraphBuilder(project);
+  builder.addSourceFile(filename);
+  for (const [serviceName, service] of Object.entries(compose.services)) {
+    const image = service.image ?? (typeof service.build === "string" ? `build:${service.build}` : void 0);
+    const type = inferServiceType(serviceName, image);
+    const ports = service.ports?.map(parsePort).filter((p) => p !== null);
+    const volumes = service.volumes?.map(parseVolume).filter((v) => v !== null);
+    const environment = parseEnvironment(service.environment);
+    builder.addNode(
+      serviceName,
+      serviceName,
+      type,
+      { file: filename, format: "docker-compose" },
+      {
+        image,
+        ports: ports?.length ? ports : void 0,
+        volumes: volumes?.length ? volumes : void 0,
+        environment,
+        replicas: service.deploy?.replicas
+      }
+    );
+  }
+  for (const [serviceName, service] of Object.entries(compose.services)) {
+    if (service.depends_on) {
+      const deps = Array.isArray(service.depends_on) ? service.depends_on : Object.keys(service.depends_on);
+      for (const dep of deps) {
+        builder.addEdge(serviceName, dep, "depends_on");
+      }
+    }
+    if (service.links) {
+      for (const link of service.links) {
+        const target = link.split(":")[0];
+        if (target) {
+          builder.addEdge(serviceName, target, "link");
+        }
+      }
+    }
+    if (service.environment) {
+      const envVars = Array.isArray(service.environment) ? service.environment : Object.entries(service.environment).map(([k, v]) => `${k}=${v}`);
+      for (const envVar of envVars) {
+        for (const otherService of Object.keys(compose.services)) {
+          if (otherService === serviceName) continue;
+          const envLower = envVar.toLowerCase();
+          const servicePattern = otherService.toLowerCase().replace(/-/g, "_");
+          if (envLower.includes(`${servicePattern}_host`) || envLower.includes(`${servicePattern}_url`) || envLower.includes(`${servicePattern}:`) || envVar.includes(`://${otherService}:`) || envVar.includes(`://${otherService}/`)) {
+            builder.addEdge(serviceName, otherService, "inferred");
+          }
+        }
+      }
+    }
+  }
+  return builder.build();
+}
+
+// ../core/src/parsers/helm/index.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, relative } from "path";
+
+// ../core/src/parsers/helm/chart.ts
+import { parse as parseYaml2 } from "yaml";
+var yamlParseOptions2 = {
+  maxAliasCount: -1,
+  merge: true
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseDependencies(value) {
+  if (!Array.isArray(value)) return [];
+  const deps = [];
+  for (const item of value) {
+    if (!isRecord(item)) continue;
+    const name = typeof item.name === "string" ? item.name : void 0;
+    if (!name) continue;
+    const tags = Array.isArray(item.tags) && item.tags.every((t) => typeof t === "string") ? item.tags : void 0;
+    deps.push({
+      name,
+      version: typeof item.version === "string" ? item.version : void 0,
+      repository: typeof item.repository === "string" ? item.repository : void 0,
+      condition: typeof item.condition === "string" ? item.condition : void 0,
+      tags
+    });
+  }
+  return deps;
+}
+function parseChartYaml(content) {
+  const chart = parseYaml2(content, yamlParseOptions2);
+  if (!isRecord(chart)) return null;
+  const name = typeof chart.name === "string" ? chart.name : void 0;
+  if (!name) return null;
+  return {
+    name,
+    version: typeof chart.version === "string" ? chart.version : void 0,
+    appVersion: typeof chart.appVersion === "string" ? chart.appVersion : void 0,
+    description: typeof chart.description === "string" ? chart.description : void 0,
+    dependencies: parseDependencies(chart.dependencies)
+  };
+}
+
+// ../core/src/parsers/helm/values.ts
+import { parse as parseYaml3 } from "yaml";
+var yamlParseOptions3 = {
+  maxAliasCount: -1,
+  merge: true
+};
+function parseValuesYaml(content) {
+  const values = parseYaml3(content, yamlParseOptions3);
+  if (!isRecord2(values)) return {};
+  return values;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getValueAtPath(values, path) {
+  const parts = path.split(".").filter(Boolean);
+  let current = values;
+  for (const part of parts) {
+    if (!isRecord2(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function getString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function getNumber(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function getBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    if (value.toLowerCase() === "true") return true;
+    if (value.toLowerCase() === "false") return false;
+  }
+  return void 0;
+}
+function normalizeRegistry(repository, registry) {
+  if (!registry) return repository;
+  if (repository.includes("/")) return repository;
+  return `${registry}/${repository}`;
+}
+function extractImage(values) {
+  const image = values.image;
+  if (typeof image === "string") {
+    return image;
+  }
+  if (isRecord2(image)) {
+    const repository = getString(image.repository) ?? getString(image.name);
+    if (!repository) return void 0;
+    const registry = getString(image.registry) ?? getString(getValueAtPath(values, "global.imageRegistry"));
+    const normalizedRepo = normalizeRegistry(repository, registry);
+    const tag = getString(image.tag);
+    if (tag && !normalizedRepo.includes(":")) {
+      return `${normalizedRepo}:${tag}`;
+    }
+    return normalizedRepo;
+  }
+  return void 0;
+}
+function parsePortValue(value) {
+  const mappings = [];
+  if (typeof value === "number") {
+    mappings.push({ internal: value });
+    return mappings;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isNaN(parsed)) {
+      mappings.push({ internal: parsed });
+    }
+    return mappings;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      mappings.push(...parsePortValue(entry));
+    }
+    return mappings;
+  }
+  if (isRecord2(value)) {
+    const port = getNumber(value.port);
+    const targetPort = getNumber(value.targetPort) ?? getNumber(value.containerPort) ?? getNumber(value.containerPorts);
+    if (port && targetPort) {
+      mappings.push({ internal: targetPort, external: port });
+      return mappings;
+    }
+    if (targetPort) {
+      mappings.push({ internal: targetPort });
+      return mappings;
+    }
+    if (port) {
+      mappings.push({ internal: port });
+      return mappings;
+    }
+    for (const entry of Object.values(value)) {
+      mappings.push(...parsePortValue(entry));
+    }
+  }
+  return mappings;
+}
+function extractPorts(values) {
+  const ports = [];
+  const service = isRecord2(values.service) ? values.service : void 0;
+  if (service) {
+    if ("ports" in service) {
+      ports.push(...parsePortValue(service.ports));
+    }
+    if ("port" in service) {
+      ports.push(...parsePortValue(service.port));
+    }
+  }
+  if ("containerPorts" in values) {
+    ports.push(...parsePortValue(values.containerPorts));
+  }
+  if ("containerPort" in values) {
+    ports.push(...parsePortValue(values.containerPort));
+  }
+  if ("ports" in values) {
+    ports.push(...parsePortValue(values.ports));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const mapping of ports) {
+    const key = `${mapping.external ?? "internal"}-${mapping.internal}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(mapping);
+  }
+  return deduped.length ? deduped : void 0;
+}
+function extractReplicas(values) {
+  const replicaCount = getNumber(values.replicaCount) ?? getNumber(values.replicas);
+  return replicaCount !== void 0 ? Math.round(replicaCount) : void 0;
+}
+function extractResourceRequests(values) {
+  const resources = isRecord2(values.resources) ? values.resources : void 0;
+  const requests = resources && isRecord2(resources.requests) ? resources.requests : void 0;
+  const cpu = getString(requests?.cpu);
+  const memory = getString(requests?.memory);
+  if (!cpu && !memory) return void 0;
+  return {
+    cpu: cpu || void 0,
+    memory: memory || void 0
+  };
+}
+function extractStorageSize(values) {
+  const persistence = isRecord2(values.persistence) ? values.persistence : void 0;
+  if (!persistence) return void 0;
+  return getString(persistence.size) ?? getString(persistence.storageSize) ?? getString(persistence.storage);
+}
+function extractServiceConfig(values) {
+  return {
+    image: extractImage(values),
+    ports: extractPorts(values),
+    replicas: extractReplicas(values),
+    resourceRequests: extractResourceRequests(values),
+    storageSize: extractStorageSize(values)
+  };
+}
+
+// ../core/src/parsers/helm/components.ts
+var SKIP_KEYS = /* @__PURE__ */ new Set([
+  "global",
+  "image",
+  "init",
+  "service",
+  "resources",
+  "persistence",
+  "ingress",
+  "rbac",
+  "serviceAccount",
+  "nodeSelector",
+  "tolerations",
+  "affinity",
+  "autoscaling",
+  "metrics",
+  "networkPolicy",
+  "securityContext",
+  "podSecurityContext",
+  "volumePermissions",
+  "extraEnvVars",
+  "extraVolumeMounts",
+  "extraVolumes",
+  "fullnameOverride",
+  "nameOverride"
+]);
+function hasComponentMarkers(values) {
+  return "replicaCount" in values || "replicas" in values || "containerPorts" in values || "containerPort" in values || "service" in values && isRecord2(values.service) || "image" in values || "resources" in values;
+}
+function detectComponents(values, options) {
+  const components = [];
+  const dependencyNames = new Set(
+    options?.dependencyNames?.map((name) => name.toLowerCase()) ?? []
+  );
+  for (const [key, value] of Object.entries(values)) {
+    if (!isRecord2(value)) continue;
+    if (SKIP_KEYS.has(key)) continue;
+    if (dependencyNames.has(key.toLowerCase())) continue;
+    if (key.startsWith("external")) continue;
+    const enabled = getBoolean(value.enabled);
+    if (enabled === false) continue;
+    if (!hasComponentMarkers(value)) continue;
+    components.push({ name: key, values: value });
+  }
+  return components;
+}
+
+// ../core/src/parsers/helm/rendered.ts
+import { execFileSync } from "child_process";
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { parseAllDocuments } from "yaml";
+var yamlParseOptions4 = {
+  maxAliasCount: -1,
+  merge: true
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeName(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function renderHelmTemplate(chartDir, releaseName, valuesFiles = [], showOnly) {
+  try {
+    const args = ["template", releaseName, chartDir, "--namespace", "default"];
+    for (const file of valuesFiles) {
+      args.push("--values", file);
+    }
+    if (showOnly) {
+      args.push("--show-only", showOnly);
+    }
+    return execFileSync("helm", args, {
+      encoding: "utf-8",
+      maxBuffer: 20 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch {
+    return null;
+  }
+}
+function listTemplateFiles(chartDir) {
+  const templatesDir = join(chartDir, "templates");
+  try {
+    const files = [];
+    const queue = [
+      { dir: templatesDir, relativeDir: "templates" }
+    ];
+    while (queue.length) {
+      const current = queue.pop();
+      if (!current) continue;
+      const dirEntries = readdirSync(current.dir, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        if (entry.name.startsWith("_")) continue;
+        if (entry.name === "NOTES.txt") continue;
+        const fullPath = join(current.dir, entry.name);
+        const relPath = join(current.relativeDir, entry.name);
+        if (entry.isDirectory()) {
+          queue.push({ dir: fullPath, relativeDir: relPath });
+          continue;
+        }
+        if (entry.isFile() && (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml"))) {
+          files.push(relPath);
+        }
+      }
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+function normalizeTemplateText(text, releaseName) {
+  let normalized = text;
+  normalized = normalized.replace(
+    /{{\s*include\s+"[^"]+\.fullname"[^}]*}}/g,
+    releaseName
+  );
+  normalized = normalized.replace(
+    /{{\s*include\s+"[^"]+\.componentname"\s*\(list\s+\$\s+"([^"]+)"\s*\)\s*}}/g,
+    `${releaseName}-$1`
+  );
+  return normalized;
+}
+function resolveSourceFromTemplatePath(templatePath, componentMap, aliasMap) {
+  const base = templatePath.split("/").pop() ?? templatePath;
+  const normalized = normalizeName(base.replace(/\.ya?ml$/, ""));
+  const aliasEntries = Array.from(aliasMap.entries()).sort(
+    (a, b) => b[0].length - a[0].length
+  );
+  for (const [alias, nodeId] of aliasEntries) {
+    if (normalized.includes(alias)) {
+      return nodeId;
+    }
+  }
+  const componentEntries = Array.from(componentMap.entries()).sort(
+    (a, b) => b[0].length - a[0].length
+  );
+  for (const [component, nodeId] of componentEntries) {
+    if (normalized.includes(component)) {
+      return nodeId;
+    }
+  }
+  return void 0;
+}
+function buildServiceTargets(releaseName, componentMap, aliasMap) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const [component, nodeId] of componentMap) {
+    targets.set(`${releaseName}-${component}`, nodeId);
+  }
+  for (const [alias, nodeId] of aliasMap) {
+    targets.set(`${releaseName}-${alias}`, nodeId);
+  }
+  return targets;
+}
+function inferEdgesFromTemplates(options) {
+  const templates = listTemplateFiles(options.chartDir);
+  if (templates.length === 0) {
+    return {
+      edges: [],
+      externalServices: [],
+      renderedComponents: [],
+      workloadComponents: [],
+      jobComponents: []
+    };
+  }
+  const serviceTargets = buildServiceTargets(
+    options.releaseName,
+    options.componentMap,
+    options.aliasMap
+  );
+  const edges = [];
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const externalServices = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const sourceNode = resolveSourceFromTemplatePath(
+      template,
+      options.componentMap,
+      options.aliasMap
+    );
+    if (!sourceNode) continue;
+    let contents = "";
+    try {
+      contents = readFileSync(join(options.chartDir, template), "utf-8");
+    } catch {
+      continue;
+    }
+    const normalized = normalizeTemplateText(contents, options.releaseName);
+    const lines = normalized.split("\n");
+    for (const line of lines) {
+      for (const [serviceName, targetNode] of serviceTargets) {
+        if (sourceNode === targetNode) continue;
+        if (!valueIncludesService(line, serviceName)) continue;
+        const key = `${sourceNode}->${targetNode}`;
+        if (edgeKeys.has(key)) continue;
+        edgeKeys.add(key);
+        edges.push({ from: sourceNode, to: targetNode, type: "inferred" });
+      }
+      const matches = line.matchAll(/([a-zA-Z0-9.-]+):(\d{2,5})/g);
+      for (const match of matches) {
+        const host = match[1];
+        const port = Number.parseInt(match[2] ?? "", 10);
+        if (!host || Number.isNaN(port)) continue;
+        const normalizedHost = host.toLowerCase();
+        const hostBase = normalizedHost.split(".")[0] ?? normalizedHost;
+        if (!hostBase) continue;
+        if (normalizedHost === "localhost" || /^\d{1,3}(\.\d{1,3}){3}$/.test(normalizedHost) || /^\d+$/.test(hostBase)) {
+          continue;
+        }
+        if (serviceTargets.has(hostBase) || serviceTargets.has(normalizedHost)) {
+          const targetNode = serviceTargets.get(hostBase) ?? serviceTargets.get(normalizedHost);
+          if (!targetNode || sourceNode === targetNode) continue;
+          const key2 = `${sourceNode}->${targetNode}`;
+          if (edgeKeys.has(key2)) continue;
+          edgeKeys.add(key2);
+          edges.push({ from: sourceNode, to: targetNode, type: "inferred" });
+          continue;
+        }
+        const externalId = `external-${hostBase}`;
+        if (!externalServices.has(externalId)) {
+          externalServices.set(externalId, {
+            id: externalId,
+            name: hostBase,
+            port
+          });
+        }
+        const key = `${sourceNode}->${externalId}`;
+        if (edgeKeys.has(key)) continue;
+        edgeKeys.add(key);
+        edges.push({ from: sourceNode, to: externalId, type: "inferred" });
+      }
+    }
+  }
+  return {
+    edges,
+    externalServices: Array.from(externalServices.values()),
+    renderedComponents: [],
+    workloadComponents: [],
+    jobComponents: []
+  };
+}
+function parseRenderedResources(content) {
+  const documents = parseAllDocuments(content, yamlParseOptions4);
+  const resources = [];
+  for (const doc of documents) {
+    const data = doc.toJSON();
+    if (!isRecord3(data)) continue;
+    resources.push(data);
+  }
+  return resources;
+}
+function getLabels(resource) {
+  const metadataLabels = resource.metadata?.labels && isRecord3(resource.metadata.labels) ? resource.metadata.labels : {};
+  const templateLabels = (() => {
+    const spec = resource.spec;
+    if (!spec || !isRecord3(spec)) return {};
+    const template = spec.template;
+    if (!isRecord3(template)) return {};
+    const metadata = template.metadata;
+    if (!isRecord3(metadata)) return {};
+    const labels = metadata.labels;
+    if (!isRecord3(labels)) return {};
+    return labels;
+  })();
+  return { ...metadataLabels, ...templateLabels };
+}
+function getPodSpec(resource) {
+  const spec = resource.spec;
+  if (!spec || !isRecord3(spec)) return null;
+  switch (resource.kind) {
+    case "Deployment":
+    case "StatefulSet":
+    case "DaemonSet":
+    case "ReplicaSet":
+      if (isRecord3(spec.template) && isRecord3(spec.template.spec) && spec.template.spec) {
+        return spec.template.spec;
+      }
+      return null;
+    case "Job":
+      if (isRecord3(spec.template) && isRecord3(spec.template.spec) && spec.template.spec) {
+        return spec.template.spec;
+      }
+      return null;
+    case "CronJob": {
+      const jobTemplate = spec.jobTemplate;
+      if (isRecord3(jobTemplate) && isRecord3(jobTemplate.spec) && isRecord3(jobTemplate.spec.template) && isRecord3(jobTemplate.spec.template.spec)) {
+        return jobTemplate.spec.template.spec;
+      }
+      return null;
+    }
+    case "Pod":
+      if (isRecord3(spec)) {
+        return spec;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function collectConfigMapNames(podSpec) {
+  const names = [];
+  for (const volume of podSpec.volumes ?? []) {
+    const name = volume.configMap?.name;
+    if (name) names.push(name);
+  }
+  const containers = [
+    ...podSpec.containers ?? [],
+    ...podSpec.initContainers ?? []
+  ];
+  for (const container of containers) {
+    for (const envFrom of container.envFrom ?? []) {
+      const name = envFrom.configMapRef?.name;
+      if (name) names.push(name);
+    }
+  }
+  return names;
+}
+function collectStringsFromPodSpec(podSpec, configMaps) {
+  const values = [];
+  const containers = [
+    ...podSpec.containers ?? [],
+    ...podSpec.initContainers ?? []
+  ];
+  for (const container of containers) {
+    for (const env of container.env ?? []) {
+      if (typeof env.value === "string") {
+        values.push(env.value);
+      }
+    }
+    if (Array.isArray(container.args)) {
+      values.push(
+        ...container.args.filter((value) => typeof value === "string")
+      );
+    }
+    if (Array.isArray(container.command)) {
+      values.push(
+        ...container.command.filter((value) => typeof value === "string")
+      );
+    }
+  }
+  for (const name of collectConfigMapNames(podSpec)) {
+    const data = configMaps.get(name);
+    if (data) {
+      values.push(...data);
+    }
+  }
+  return values;
+}
+function valueIncludesService(value, serviceName) {
+  const normalizedValue = value.toLowerCase();
+  const normalizedService = serviceName.toLowerCase();
+  const pattern = new RegExp(
+    `(^|[\\s:/"'=\\(])${normalizedService.replace(/[-/\\^$*+?.()|[\\]{}]/g, "\\$&")}(?=$|[\\s:/"'=.\\)])`,
+    "i"
+  );
+  return normalizedValue.includes(normalizedService) && pattern.test(normalizedValue);
+}
+function resolveNodeIdFromComponent(component, componentMap, aliasMap) {
+  if (!component) return void 0;
+  const normalized = normalizeName(component);
+  return componentMap.get(normalized) ?? aliasMap.get(normalized);
+}
+function resolveNodeIdFromName(resourceName, componentMap, aliasMap) {
+  if (!resourceName) return void 0;
+  const normalized = normalizeName(resourceName);
+  for (const [component, nodeId] of componentMap) {
+    if (normalized === component || normalized.endsWith(`-${component}`)) {
+      return nodeId;
+    }
+  }
+  for (const [alias, nodeId] of aliasMap) {
+    if (normalized === alias || normalized.endsWith(`-${alias}`)) {
+      return nodeId;
+    }
+  }
+  return void 0;
+}
+function inferEdgesFromRenderedManifests(options) {
+  const manifest = renderHelmTemplate(
+    options.chartDir,
+    options.releaseName,
+    options.valuesFiles ?? []
+  );
+  if (!manifest) {
+    console.warn(
+      "Helm render failed; falling back to static template scanning. Some dependencies may be missing."
+    );
+    return inferEdgesFromTemplates(options);
+  }
+  const resources = parseRenderedResources(manifest);
+  const serviceTargets = /* @__PURE__ */ new Map();
+  const configMaps = /* @__PURE__ */ new Map();
+  const externalServices = /* @__PURE__ */ new Map();
+  const renderedComponents = /* @__PURE__ */ new Set();
+  const workloadComponents = /* @__PURE__ */ new Set();
+  const jobComponents = /* @__PURE__ */ new Set();
+  const longRunningKinds = /* @__PURE__ */ new Set([
+    "Deployment",
+    "StatefulSet",
+    "DaemonSet",
+    "ReplicaSet",
+    "Pod"
+  ]);
+  for (const resource of resources) {
+    if (resource.kind === "ConfigMap" && resource.metadata?.name) {
+      const rawData = resource.data;
+      if (isRecord3(rawData)) {
+        const strings = Object.values(rawData).filter(
+          (value) => typeof value === "string"
+        );
+        if (strings.length > 0) {
+          configMaps.set(resource.metadata.name, strings);
+        }
+      }
+    }
+    const labels = getLabels(resource);
+    const componentLabel = labels["app.kubernetes.io/component"] ?? labels.app;
+    const resolvedNode = resolveNodeIdFromComponent(
+      componentLabel,
+      options.componentMap,
+      options.aliasMap
+    ) ?? resolveNodeIdFromName(
+      resource.metadata?.name,
+      options.componentMap,
+      options.aliasMap
+    );
+    if (!resolvedNode) continue;
+    renderedComponents.add(resolvedNode);
+    if (resource.kind === "Service" && resource.metadata?.name) {
+      serviceTargets.set(resource.metadata.name, resolvedNode);
+      workloadComponents.add(resolvedNode);
+    }
+    if (resource.kind && longRunningKinds.has(resource.kind)) {
+      workloadComponents.add(resolvedNode);
+    }
+    if (resource.kind === "Job" || resource.kind === "CronJob") {
+      jobComponents.add(resolvedNode);
+    }
+  }
+  const edges = [];
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const serviceNames = /* @__PURE__ */ new Set();
+  for (const [serviceName] of serviceTargets) {
+    serviceNames.add(serviceName.toLowerCase());
+  }
+  for (const resource of resources) {
+    if (![
+      "Deployment",
+      "StatefulSet",
+      "DaemonSet",
+      "ReplicaSet",
+      "Job",
+      "CronJob",
+      "Pod"
+    ].includes(resource.kind ?? "")) {
+      continue;
+    }
+    const labels = getLabels(resource);
+    const componentLabel = labels["app.kubernetes.io/component"] ?? labels.app;
+    const sourceNode = resolveNodeIdFromComponent(
+      componentLabel,
+      options.componentMap,
+      options.aliasMap
+    ) ?? resolveNodeIdFromName(
+      resource.metadata?.name,
+      options.componentMap,
+      options.aliasMap
+    );
+    if (!sourceNode) continue;
+    const podSpec = getPodSpec(resource);
+    if (!podSpec) continue;
+    const strings = collectStringsFromPodSpec(podSpec, configMaps);
+    if (strings.length === 0) continue;
+    for (const [serviceName, targetNode] of serviceTargets) {
+      if (sourceNode === targetNode) continue;
+      for (const value of strings) {
+        if (!valueIncludesService(value, serviceName)) continue;
+        const key = `${sourceNode}->${targetNode}`;
+        if (edgeKeys.has(key)) continue;
+        edgeKeys.add(key);
+        edges.push({ from: sourceNode, to: targetNode, type: "inferred" });
+      }
+    }
+    for (const value of strings) {
+      const matches = value.matchAll(/([a-zA-Z0-9.-]+):(\d{2,5})/g);
+      for (const match of matches) {
+        const host = match[1];
+        const port = Number.parseInt(match[2] ?? "", 10);
+        if (!host || Number.isNaN(port)) continue;
+        const normalizedHost = host.toLowerCase();
+        const hostBase = normalizedHost.split(".")[0] ?? normalizedHost;
+        if (!hostBase) continue;
+        if (normalizedHost === "localhost" || /^\d{1,3}(\.\d{1,3}){3}$/.test(normalizedHost) || /^\d+$/.test(hostBase)) {
+          continue;
+        }
+        if (serviceNames.has(hostBase) || serviceNames.has(normalizedHost)) {
+          const targetNode = serviceTargets.get(hostBase) ?? serviceTargets.get(normalizedHost);
+          if (!targetNode || sourceNode === targetNode) continue;
+          const key2 = `${sourceNode}->${targetNode}`;
+          if (edgeKeys.has(key2)) continue;
+          edgeKeys.add(key2);
+          edges.push({ from: sourceNode, to: targetNode, type: "inferred" });
+          continue;
+        }
+        const externalId = `external-${hostBase}`;
+        if (!externalServices.has(externalId)) {
+          externalServices.set(externalId, {
+            id: externalId,
+            name: hostBase,
+            port
+          });
+        }
+        const key = `${sourceNode}->${externalId}`;
+        if (edgeKeys.has(key)) continue;
+        edgeKeys.add(key);
+        edges.push({ from: sourceNode, to: externalId, type: "inferred" });
+      }
+    }
+  }
+  return {
+    edges,
+    externalServices: Array.from(externalServices.values()),
+    renderedComponents: Array.from(renderedComponents),
+    workloadComponents: Array.from(workloadComponents),
+    jobComponents: Array.from(jobComponents)
+  };
+}
+
+// ../core/src/parsers/helm/index.ts
+function buildEmptyGraph(project, sourceFiles = []) {
+  return {
+    nodes: [],
+    edges: [],
+    metadata: {
+      project,
+      parsedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceFiles,
+      parserVersion: "0.1.0"
+    }
+  };
+}
+function resolveChartPath(chartDir) {
+  const yamlPath = join2(chartDir, "Chart.yaml");
+  if (existsSync(yamlPath)) return yamlPath;
+  const ymlPath = join2(chartDir, "Chart.yml");
+  if (existsSync(ymlPath)) return ymlPath;
+  return null;
+}
+function resolveSourcePath(sourceRoot, filepath) {
+  if (!sourceRoot) return filepath;
+  const rel = relative(sourceRoot, filepath);
+  return rel || filepath;
+}
+function normalizeName2(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function buildComponentMap(chartName, components) {
+  const map = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    map.set(normalizeName2(component.name), `${chartName}-${component.name}`);
+  }
+  return map;
+}
+function hasComponentMarkers2(values) {
+  return "replicaCount" in values || "replicas" in values || "containerPorts" in values || "containerPort" in values || "service" in values && isRecord2(values.service) || "image" in values || "resources" in values;
+}
+function buildAliasMap(values, componentMap) {
+  const aliases = /* @__PURE__ */ new Map();
+  const serverNode = componentMap.get("server");
+  if (serverNode && isRecord2(values.server)) {
+    for (const [key, value] of Object.entries(values.server)) {
+      if (!isRecord2(value)) continue;
+      if (!hasComponentMarkers2(value)) continue;
+      aliases.set(normalizeName2(key), serverNode);
+    }
+  }
+  return aliases;
+}
+function parseConditionPaths(condition) {
+  if (!condition) return [];
+  return condition.split(",").map((part) => part.trim()).filter(Boolean);
+}
+function evaluateConditions(values, condition) {
+  const paths = parseConditionPaths(condition);
+  if (paths.length === 0) return void 0;
+  const results = paths.map((path) => getBoolean(getValueAtPath(values, path))).filter((val) => val !== void 0);
+  if (results.length === 0) return void 0;
+  if (results.some((val) => val)) return true;
+  return false;
+}
+function evaluateTags(values, tags) {
+  if (!tags || tags.length === 0) return void 0;
+  const results = tags.map((tag) => getBoolean(getValueAtPath(values, `tags.${tag}`))).filter((val) => val !== void 0);
+  if (results.length === 0) return void 0;
+  if (results.some((val) => val === false)) return false;
+  if (results.some((val) => val === true)) return true;
+  return void 0;
+}
+function isDependencyEnabled(dependency, values) {
+  const conditionResult = evaluateConditions(values, dependency.condition);
+  if (conditionResult !== void 0) return conditionResult;
+  const tagResult = evaluateTags(values, dependency.tags);
+  if (tagResult !== void 0) return tagResult;
+  const explicitEnabled = getBoolean(
+    getValueAtPath(values, `${dependency.name}.enabled`)
+  );
+  return explicitEnabled ?? true;
+}
+function extractExternalServiceConfig(values, dependencyName) {
+  const nameLower = dependencyName.toLowerCase();
+  const candidates = [];
+  if (nameLower.includes("postgres") || nameLower.includes("postgresql")) {
+    candidates.push(
+      "externalDatabase",
+      "externalPostgresql",
+      "externalPostgres"
+    );
+  } else if (nameLower.includes("redis")) {
+    candidates.push("externalRedis");
+  } else if (nameLower.includes("mysql")) {
+    candidates.push("externalDatabase", "externalMysql");
+  } else if (nameLower.includes("mariadb")) {
+    candidates.push("externalDatabase", "externalMariadb");
+  } else if (nameLower.includes("mongo")) {
+    candidates.push("externalMongo");
+  } else if (nameLower.includes("elasticsearch")) {
+    candidates.push("externalElasticsearch");
+  } else if (nameLower.includes("opensearch")) {
+    candidates.push("externalOpensearch");
+  } else if (nameLower.includes("rabbitmq")) {
+    candidates.push("externalRabbitmq");
+  } else if (nameLower.includes("kafka")) {
+    candidates.push("externalKafka");
+  } else {
+    candidates.push(`external${dependencyName}`);
+  }
+  const externalRoot = isRecord2(values.external) ? values.external : void 0;
+  for (const key of candidates) {
+    const config = getValueAtPath(values, key);
+    if (!isRecord2(config)) continue;
+    const host = getString(config.host) ?? getString(config.hostname);
+    if (!host) continue;
+    const port = getNumber(config.port) ?? getNumber(config.servicePort) ?? getNumber(config.redisPort) ?? getNumber(config.databasePort);
+    return {
+      name: `${dependencyName} (external)`,
+      port: port ? Math.round(port) : void 0
+    };
+  }
+  if (externalRoot && isRecord2(externalRoot[dependencyName])) {
+    const config = externalRoot[dependencyName];
+    const host = getString(config.host) ?? getString(config.hostname);
+    if (host) {
+      const port = getNumber(config.port);
+      return {
+        name: `${dependencyName} (external)`,
+        port: port ? Math.round(port) : void 0
+      };
+    }
+  }
+  return null;
+}
+function buildPortMappings(port) {
+  if (!port) return void 0;
+  return [{ internal: port }];
+}
+function parseHelmChart(chartDir, project, sourceRoot, options) {
+  const chartPath = resolveChartPath(chartDir);
+  if (!chartPath) {
+    return buildEmptyGraph(project);
+  }
+  const chartContent = readFileSync2(chartPath, "utf-8");
+  const chart = parseChartYaml(chartContent);
+  if (!chart) {
+    return buildEmptyGraph(project, [resolveSourcePath(sourceRoot, chartPath)]);
+  }
+  const valuesPath = join2(chartDir, "values.yaml");
+  let values = {};
+  if (existsSync(valuesPath)) {
+    const valuesContent = readFileSync2(valuesPath, "utf-8");
+    values = parseValuesYaml(valuesContent);
+  }
+  const builder = new GraphBuilder(project);
+  builder.addSourceFile(resolveSourcePath(sourceRoot, chartPath));
+  if (existsSync(valuesPath)) {
+    builder.addSourceFile(resolveSourcePath(sourceRoot, valuesPath));
+  }
+  const dependencyNames = chart.dependencies?.map((dep) => dep.name) ?? [];
+  const detectedComponents = detectComponents(values, { dependencyNames });
+  const componentMap = buildComponentMap(chart.name, detectedComponents);
+  const aliasMap = buildAliasMap(values, componentMap);
+  const renderedInference = inferEdgesFromRenderedManifests({
+    chartDir,
+    releaseName: chart.name,
+    componentMap,
+    aliasMap,
+    valuesFiles: options?.valuesFiles
+  });
+  let components = detectedComponents;
+  if (renderedInference.renderedComponents.length > 0) {
+    const renderedSet = new Set(renderedInference.renderedComponents);
+    const jobSet = new Set(renderedInference.jobComponents);
+    components = detectedComponents.filter((component) => {
+      const nodeId = `${chart.name}-${component.name}`;
+      if (!renderedSet.has(nodeId)) return false;
+      if (jobSet.has(nodeId)) return false;
+      return true;
+    });
+  }
+  const chartConfig = extractServiceConfig(values);
+  const chartImage = chartConfig.image;
+  const chartSource = {
+    file: resolveSourcePath(sourceRoot, chartPath),
+    format: "helm"
+  };
+  const hasComponents = components.length > 0;
+  if (!hasComponents) {
+    builder.addNode(
+      chart.name,
+      chart.name,
+      inferServiceType(chart.name, chartImage),
+      chartSource,
+      {
+        image: chartImage,
+        ports: chartConfig.ports,
+        replicas: chartConfig.replicas,
+        resourceRequests: chartConfig.resourceRequests,
+        storageSize: chartConfig.storageSize
+      }
+    );
+  }
+  const dependencyTargets = [];
+  for (const dependency of chart.dependencies ?? []) {
+    const enabled = isDependencyEnabled(dependency, values);
+    if (enabled) {
+      const depId = dependency.name;
+      builder.addNode(
+        depId,
+        dependency.name,
+        inferServiceType(dependency.name, dependency.name),
+        chartSource
+      );
+      dependencyTargets.push({ id: depId, edgeType: "subchart" });
+    } else {
+      const external = extractExternalServiceConfig(values, dependency.name);
+      if (external) {
+        const externalId = `external-${dependency.name}`;
+        builder.addNode(
+          externalId,
+          external.name,
+          inferServiceType(dependency.name, dependency.name),
+          chartSource,
+          {
+            external: true,
+            ports: buildPortMappings(external.port)
+          }
+        );
+        dependencyTargets.push({ id: externalId, edgeType: "depends_on" });
+      }
+    }
+  }
+  if (hasComponents) {
+    for (const component of components) {
+      const componentConfig = extractServiceConfig(component.values);
+      const componentImage = componentConfig.image ?? chartImage;
+      const componentName = `${chart.name}-${component.name}`;
+      const componentType = inferServiceType(component.name, componentImage);
+      builder.addNode(
+        componentName,
+        componentName,
+        componentType,
+        chartSource,
+        {
+          image: componentImage,
+          ports: componentConfig.ports ?? chartConfig.ports,
+          replicas: componentConfig.replicas ?? chartConfig.replicas,
+          resourceRequests: componentConfig.resourceRequests ?? chartConfig.resourceRequests,
+          storageSize: componentConfig.storageSize ?? chartConfig.storageSize,
+          group: chart.name
+        }
+      );
+      for (const target of dependencyTargets) {
+        builder.addEdge(componentName, target.id, target.edgeType);
+      }
+    }
+  } else {
+    for (const target of dependencyTargets) {
+      builder.addEdge(chart.name, target.id, target.edgeType);
+    }
+  }
+  for (const service of renderedInference.externalServices) {
+    if (!builder.hasNode(service.id)) {
+      builder.addNode(
+        service.id,
+        service.name,
+        inferServiceType(service.name, service.name),
+        chartSource,
+        {
+          external: true,
+          ports: service.port ? [{ internal: service.port }] : void 0
+        }
+      );
+    }
+  }
+  for (const edge of renderedInference.edges) {
+    builder.addEdge(edge.from, edge.to, edge.type);
+  }
+  return builder.build();
+}
+
+// ../core/src/pipeline/index.ts
+import { join as join4 } from "path";
+
+// ../core/src/elk/types.ts
+var ELK_LAYOUT_OPTIONS = {
+  /** Standard left-to-right layered layout */
+  standard: {
+    "elk.algorithm": "layered",
+    "elk.direction": "RIGHT",
+    "elk.edgeRouting": "ORTHOGONAL",
+    "elk.spacing.nodeNode": "50",
+    "elk.layered.spacing.nodeNodeBetweenLayers": "80",
+    "elk.layered.mergeEdges": "false"
+  },
+  /** Semantic partitioning enabled */
+  semantic: {
+    "elk.algorithm": "layered",
+    "elk.direction": "RIGHT",
+    "elk.edgeRouting": "ORTHOGONAL",
+    "elk.spacing.nodeNode": "50",
+    "elk.layered.spacing.nodeNodeBetweenLayers": "80",
+    "elk.layered.mergeEdges": "false",
+    "elk.partitioning.activate": "true"
+  },
+  /** Compound node (for grouping related services) */
+  compound: {
+    "elk.algorithm": "layered",
+    "elk.direction": "DOWN",
+    "elk.edgeRouting": "ORTHOGONAL",
+    "elk.spacing.nodeNode": "20",
+    "elk.layered.spacing.nodeNodeBetweenLayers": "30",
+    "elk.hierarchyHandling": "INCLUDE_CHILDREN"
+  }
+};
+
+// ../core/src/elk/convert.ts
+var LAYER_PARTITIONS = {
+  entry: 0,
+  // Proxies, load balancers, external-facing
+  ui: 1,
+  // Web frontends, UI services
+  api: 2,
+  // API services, gateways, streaming
+  worker: 3,
+  // Background job processors (sidekiq, celery)
+  queue: 4,
+  // Message queues, brokers
+  data: 5
+  // Databases, caches, storage
+};
+var DEFAULT_NODE_SIZE = { width: 140, height: 50 };
+var NODE_SIZES = {
+  database: { width: 160, height: 80 },
+  cache: { width: 140, height: 70 },
+  storage: { width: 160, height: 80 },
+  queue: { width: 120, height: 60 },
+  proxy: { width: 100, height: 50 }
+};
+function parseCpuCores(value) {
+  if (!value) return void 0;
+  if (value.endsWith("m")) {
+    const milli = Number.parseFloat(value.slice(0, -1));
+    return Number.isFinite(milli) ? milli / 1e3 : void 0;
+  }
+  const cores = Number.parseFloat(value);
+  return Number.isFinite(cores) ? cores : void 0;
+}
+function parseMemoryMi(value) {
+  if (!value) return void 0;
+  const match = value.match(/^(\d+(?:\.\d+)?)([a-zA-Z]+)?$/);
+  if (!match) return void 0;
+  const amount = Number.parseFloat(match[1] ?? "");
+  if (!Number.isFinite(amount)) return void 0;
+  const unit = (match[2] ?? "").toLowerCase();
+  switch (unit) {
+    case "ki":
+      return amount / 1024;
+    case "mi":
+      return amount;
+    case "gi":
+      return amount * 1024;
+    case "ti":
+      return amount * 1024 * 1024;
+    case "k":
+      return amount / 1024;
+    case "m":
+      return amount;
+    case "g":
+      return amount * 1024;
+    default:
+      return amount;
+  }
+}
+function getResourceScale(node) {
+  const cpu = parseCpuCores(node.resourceRequests?.cpu);
+  const memory = parseMemoryMi(node.resourceRequests?.memory);
+  if (cpu === void 0 && memory === void 0) return 1;
+  if ((cpu ?? 0) >= 2 || (memory ?? 0) >= 2048) return 1.4;
+  if ((cpu ?? 0) >= 1 || (memory ?? 0) >= 1024) return 1.25;
+  if ((cpu ?? 0) >= 0.5 || (memory ?? 0) >= 512) return 1.1;
+  return 1;
+}
+function getSemanticLayer(node) {
+  switch (node.type) {
+    case "proxy":
+      return "entry";
+    case "ui":
+      return "ui";
+    case "database":
+    case "storage":
+      return "data";
+    case "cache":
+      return "data";
+    case "queue":
+      return "queue";
+  }
+  const nameLower = node.name.toLowerCase();
+  if (nameLower.includes("nginx") || nameLower.includes("haproxy") || nameLower.includes("traefik") || nameLower.includes("ingress") || nameLower.includes("caddy")) {
+    return "entry";
+  }
+  if (nameLower === "web" || nameLower.includes("frontend") || nameLower.includes("dashboard") || nameLower.includes("ui") || nameLower.includes("client") || nameLower.includes("app")) {
+    return "ui";
+  }
+  if (nameLower.includes("sidekiq") || nameLower.includes("celery") || nameLower.includes("resque") || nameLower.includes("worker") || nameLower.includes("job") || nameLower.includes("consumer") || nameLower.includes("processor")) {
+    return "worker";
+  }
+  if (nameLower.includes("api") || nameLower.includes("gateway") || nameLower.includes("relay") || nameLower.includes("streaming") || nameLower.includes("graphql") || nameLower.includes("grpc")) {
+    return "api";
+  }
+  if (nameLower.includes("seaweedfs") || nameLower.includes("objectstorage") || nameLower.includes("minio") || nameLower.includes("s3")) {
+    return "data";
+  }
+  return "api";
+}
+function getNodeSize(node) {
+  const base = NODE_SIZES[node.type] ?? DEFAULT_NODE_SIZE;
+  const scale = getResourceScale(node);
+  return {
+    width: Math.round(base.width * scale),
+    height: Math.round(base.height * scale)
+  };
+}
+function getLabelDimensions(text) {
+  return {
+    width: Math.max(40, text.length * 8),
+    height: 20
+  };
+}
+function convertNode(node, layer, enablePartitioning) {
+  const size = getNodeSize(node);
+  const labelDims = getLabelDimensions(node.name);
+  const elkNode = {
+    id: node.id,
+    width: Math.max(size.width, labelDims.width + 20),
+    height: size.height,
+    labels: [
+      {
+        text: node.name,
+        width: labelDims.width,
+        height: labelDims.height
+      }
+    ]
+  };
+  if (enablePartitioning) {
+    elkNode.layoutOptions = {
+      "elk.partitioning.partition": String(LAYER_PARTITIONS[layer])
+    };
+  }
+  return elkNode;
+}
+function infraGraphToElk(graph, options = {}) {
+  const enablePartitioning = options.semanticLayers !== false;
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    nodeTypeMap.set(node.id, node.type);
+  }
+  const cacheNodes = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    if (node.type === "cache") {
+      cacheNodes.add(node.id);
+    }
+  }
+  const nodePorts = /* @__PURE__ */ new Map();
+  const layerAssignments = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    layerAssignments.set(node.id, getSemanticLayer(node));
+  }
+  const edges = graph.edges.map((edge, index) => {
+    const edgeId = `e${index}`;
+    const targetIsCache = cacheNodes.has(edge.to);
+    if (targetIsCache) {
+      const sourcePortId = `${edge.from}-south-${index}`;
+      const targetPortId = `${edge.to}-north-${index}`;
+      if (!nodePorts.has(edge.from)) {
+        nodePorts.set(edge.from, { south: [], north: [] });
+      }
+      nodePorts.get(edge.from).south.push(sourcePortId);
+      if (!nodePorts.has(edge.to)) {
+        nodePorts.set(edge.to, { south: [], north: [] });
+      }
+      nodePorts.get(edge.to).north.push(targetPortId);
+      return {
+        id: edgeId,
+        sources: [sourcePortId],
+        targets: [targetPortId]
+      };
+    }
+    return {
+      id: edgeId,
+      sources: [edge.from],
+      targets: [edge.to]
+    };
+  });
+  const children = graph.nodes.map((node) => {
+    const layer = layerAssignments.get(node.id) ?? "api";
+    const elkNode = convertNode(node, layer, enablePartitioning);
+    const ports = nodePorts.get(node.id);
+    if (ports) {
+      const elkPorts = [];
+      for (const portId of ports.south) {
+        elkPorts.push({
+          id: portId,
+          layoutOptions: { "elk.port.side": "SOUTH" }
+        });
+      }
+      for (const portId of ports.north) {
+        elkPorts.push({
+          id: portId,
+          layoutOptions: { "elk.port.side": "NORTH" }
+        });
+      }
+      if (elkPorts.length > 0) {
+        elkNode.ports = elkPorts;
+        elkNode.layoutOptions = {
+          ...elkNode.layoutOptions,
+          "elk.portConstraints": "FIXED_SIDE"
+        };
+      }
+    }
+    return elkNode;
+  });
+  const layoutOptions = enablePartitioning ? ELK_LAYOUT_OPTIONS.semantic : ELK_LAYOUT_OPTIONS.standard;
+  const elkGraph = {
+    id: "root",
+    layoutOptions: { ...layoutOptions },
+    children,
+    edges
+  };
+  return {
+    graph: elkGraph,
+    layerAssignments
+  };
+}
+
+// ../core/src/elk/layout.ts
+import ELK from "elkjs";
+async function runLayout(graph) {
+  const elk = new ELK();
+  const result = await elk.layout(graph);
+  return {
+    graph: result,
+    width: result.width ?? 0,
+    height: result.height ?? 0
+  };
+}
+
+// ../core/src/excalidraw/types.ts
+var SERVICE_COLORS = {
+  database: {
+    stroke: "#1971c2",
+    background: "#a5d8ff"
+  },
+  cache: {
+    stroke: "#e03131",
+    background: "#ffc9c9"
+  },
+  queue: {
+    stroke: "#f08c00",
+    background: "#ffec99"
+  },
+  storage: {
+    stroke: "#2f9e44",
+    background: "#b2f2bb"
+  },
+  proxy: {
+    stroke: "#7950f2",
+    background: "#d0bfff"
+  },
+  container: {
+    stroke: "#495057",
+    background: "#dee2e6"
+  },
+  ui: {
+    stroke: "#0c8599",
+    background: "#99e9f2"
+  }
+};
+var SERVICE_SHAPES = {
+  database: "ellipse",
+  cache: "ellipse",
+  storage: "ellipse",
+  queue: "diamond",
+  proxy: "rectangle",
+  container: "rectangle",
+  ui: "rectangle"
+};
+var LAYOUT_CONFIG = {
+  nodeWidth: 180,
+  nodeHeight: 80,
+  horizontalGap: 100,
+  verticalGap: 80,
+  textPadding: 10,
+  fontSize: 16,
+  fontFamily: 1
+  // 1 = Virgil (hand-drawn), 2 = Helvetica, 3 = Cascadia
+};
+
+// ../core/src/excalidraw/elk-render.ts
+function generateSeed() {
+  return Math.floor(Math.random() * 2147483647);
+}
+function getServiceColors(type) {
+  return SERVICE_COLORS[type] ?? {
+    stroke: "#495057",
+    background: "#dee2e6"
+  };
+}
+function getShapeType(serviceType) {
+  const shape = SERVICE_SHAPES[serviceType];
+  if (shape === "ellipse" || shape === "diamond" || shape === "rectangle") {
+    return shape;
+  }
+  return "rectangle";
+}
+function createNodeElement(node, elkNode) {
+  const colors = getServiceColors(node.type);
+  const textId = `${node.id}-text`;
+  const shapeType = getShapeType(node.type);
+  return {
+    id: node.id,
+    type: shapeType,
+    x: elkNode.x ?? 0,
+    y: elkNode.y ?? 0,
+    width: elkNode.width ?? 140,
+    height: elkNode.height ?? 50,
+    angle: 0,
+    strokeColor: colors.stroke,
+    backgroundColor: colors.background,
+    fillStyle: "solid",
+    strokeWidth: 2,
+    strokeStyle: node.external ? "dashed" : "solid",
+    roughness: 1,
+    opacity: 100,
+    groupIds: [],
+    frameId: null,
+    roundness: shapeType === "rectangle" ? { type: 3 } : null,
+    seed: generateSeed(),
+    version: 1,
+    versionNonce: generateSeed(),
+    isDeleted: false,
+    boundElements: [{ id: textId, type: "text" }],
+    updated: Date.now(),
+    link: null,
+    locked: false
+  };
+}
+function createNodeText(node, elkNode) {
+  const x = elkNode.x ?? 0;
+  const y = elkNode.y ?? 0;
+  const width = elkNode.width ?? 140;
+  const height = elkNode.height ?? 50;
+  const fontSize = LAYOUT_CONFIG.fontSize;
+  const lineHeight = 1.25;
+  const textHeight = fontSize * lineHeight;
+  const avgCharWidth = fontSize * 0.6;
+  const textWidth = Math.min(node.name.length * avgCharWidth, width - 20);
+  return {
+    id: `${node.id}-text`,
+    type: "text",
+    x: x + (width - textWidth) / 2,
+    y: y + (height - textHeight) / 2,
+    width: textWidth,
+    height: textHeight,
+    angle: 0,
+    strokeColor: "#1e1e1e",
+    backgroundColor: "transparent",
+    fillStyle: "solid",
+    strokeWidth: 1,
+    strokeStyle: "solid",
+    roughness: 1,
+    opacity: 100,
+    groupIds: [],
+    frameId: null,
+    roundness: null,
+    seed: generateSeed(),
+    version: 1,
+    versionNonce: generateSeed(),
+    isDeleted: false,
+    boundElements: null,
+    updated: Date.now(),
+    link: null,
+    locked: false,
+    text: node.name,
+    fontSize,
+    fontFamily: LAYOUT_CONFIG.fontFamily,
+    textAlign: "center",
+    verticalAlign: "middle",
+    baseline: fontSize,
+    containerId: node.id,
+    originalText: node.name,
+    autoResize: true,
+    lineHeight
+  };
+}
+function elkSectionToArrowPoints(section) {
+  const startX = section.startPoint.x;
+  const startY = section.startPoint.y;
+  const points = [[0, 0]];
+  if (section.bendPoints) {
+    for (const bend of section.bendPoints) {
+      points.push([bend.x - startX, bend.y - startY]);
+    }
+  }
+  points.push([section.endPoint.x - startX, section.endPoint.y - startY]);
+  return { startX, startY, points };
+}
+function extractNodeId(portOrNodeId) {
+  const portPattern = /^(.+)-(north|south|east|west)-\d+$/;
+  const match = portOrNodeId.match(portPattern);
+  return match ? match[1] : portOrNodeId;
+}
+function calculateFixedPoint(connectionPoint, elkNode) {
+  const nodeX = elkNode.x ?? 0;
+  const nodeY = elkNode.y ?? 0;
+  const nodeWidth = elkNode.width ?? 140;
+  const nodeHeight = elkNode.height ?? 50;
+  let normalizedX = (connectionPoint.x - nodeX) / nodeWidth;
+  let normalizedY = (connectionPoint.y - nodeY) / nodeHeight;
+  normalizedX = Math.max(0, Math.min(1, normalizedX));
+  normalizedY = Math.max(0, Math.min(1, normalizedY));
+  return [normalizedX, normalizedY];
+}
+function createArrowElement(edgeId, sourcePortOrNodeId, targetPortOrNodeId, sections, elkNodeMap) {
+  if (!sections || sections.length === 0) {
+    return null;
+  }
+  const section = sections[0];
+  if (!section) return null;
+  const { startX, startY, points } = elkSectionToArrowPoints(section);
+  const sourceNodeId = extractNodeId(sourcePortOrNodeId);
+  const targetNodeId = extractNodeId(targetPortOrNodeId);
+  const sourceNode = elkNodeMap.get(sourceNodeId);
+  const targetNode = elkNodeMap.get(targetNodeId);
+  const startFixedPoint = sourceNode ? calculateFixedPoint(section.startPoint, sourceNode) : null;
+  const endFixedPoint = targetNode ? calculateFixedPoint(section.endPoint, targetNode) : null;
+  return {
+    id: edgeId,
+    type: "arrow",
+    x: startX,
+    y: startY,
+    width: Math.abs(points[points.length - 1]?.[0] ?? 0),
+    height: Math.abs(points[points.length - 1]?.[1] ?? 0),
+    angle: 0,
+    strokeColor: "#868e96",
+    backgroundColor: "transparent",
+    fillStyle: "solid",
+    strokeWidth: 2,
+    strokeStyle: "solid",
+    roughness: 1,
+    opacity: 100,
+    groupIds: [],
+    frameId: null,
+    roundness: { type: 2 },
+    seed: generateSeed(),
+    version: 1,
+    versionNonce: generateSeed(),
+    isDeleted: false,
+    boundElements: null,
+    updated: Date.now(),
+    link: null,
+    locked: false,
+    points,
+    startBinding: {
+      elementId: sourceNodeId,
+      focus: 0,
+      gap: 1,
+      fixedPoint: startFixedPoint
+    },
+    endBinding: {
+      elementId: targetNodeId,
+      focus: 0,
+      gap: 1,
+      fixedPoint: endFixedPoint
+    },
+    startArrowhead: null,
+    endArrowhead: "arrow",
+    elbowed: true
+  };
+}
+function buildElkNodeMap(elkGraph) {
+  const map = /* @__PURE__ */ new Map();
+  function addNodes(nodes) {
+    if (!nodes) return;
+    for (const node of nodes) {
+      map.set(node.id, node);
+      if (node.children) {
+        addNodes(node.children);
+      }
+    }
+  }
+  addNodes(elkGraph.children);
+  return map;
+}
+function renderWithElkLayout(graph, elkGraph, options = {}) {
+  const padding = options.padding ?? 50;
+  const elements = [];
+  const elkNodeMap = buildElkNodeMap(elkGraph);
+  const offsetElkNodeMap = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const elkNode = elkNodeMap.get(node.id);
+    if (!elkNode || elkNode.x === void 0 || elkNode.y === void 0) {
+      console.warn(`No ELK position for node: ${node.id}`);
+      continue;
+    }
+    const offsetNode = {
+      ...elkNode,
+      x: (elkNode.x ?? 0) + padding,
+      y: (elkNode.y ?? 0) + padding
+    };
+    offsetElkNodeMap.set(node.id, offsetNode);
+    elements.push(createNodeElement(node, offsetNode));
+    elements.push(createNodeText(node, offsetNode));
+  }
+  if (elkGraph.edges) {
+    for (const edge of elkGraph.edges) {
+      const sourceId = edge.sources[0];
+      const targetId = edge.targets[0];
+      if (!sourceId || !targetId) continue;
+      const offsetSections = edge.sections?.map((section) => ({
+        ...section,
+        startPoint: {
+          x: section.startPoint.x + padding,
+          y: section.startPoint.y + padding
+        },
+        endPoint: {
+          x: section.endPoint.x + padding,
+          y: section.endPoint.y + padding
+        },
+        bendPoints: section.bendPoints?.map((bp) => ({
+          x: bp.x + padding,
+          y: bp.y + padding
+        }))
+      }));
+      const arrow = createArrowElement(
+        edge.id,
+        sourceId,
+        targetId,
+        offsetSections ?? [],
+        offsetElkNodeMap
+      );
+      if (arrow) {
+        elements.push(arrow);
+        const sourceNodeId = extractNodeId(sourceId);
+        const targetNodeId = extractNodeId(targetId);
+        const sourceEl = elements.find((e) => e.id === sourceNodeId);
+        const targetEl = elements.find((e) => e.id === targetNodeId);
+        if (sourceEl && "boundElements" in sourceEl) {
+          sourceEl.boundElements = [
+            ...sourceEl.boundElements ?? [],
+            { id: edge.id, type: "arrow" }
+          ];
+        }
+        if (targetEl && "boundElements" in targetEl) {
+          targetEl.boundElements = [
+            ...targetEl.boundElements ?? [],
+            { id: edge.id, type: "arrow" }
+          ];
+        }
+      }
+    }
+  }
+  return {
+    type: "excalidraw",
+    version: 2,
+    source: "clarity-elk",
+    elements,
+    appState: {
+      viewBackgroundColor: "#ffffff",
+      gridSize: null
+    },
+    files: {}
+  };
+}
+
+// ../core/src/llm/client.ts
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_MODEL = "anthropic/claude-opus-4.5";
+var DEFAULT_MAX_TOKENS = 4096;
+async function sendMessage(apiKey, prompt, config) {
+  const messages = [
+    {
+      role: "user",
+      content: prompt
+    }
+  ];
+  const response = await fetch(`${OPENROUTER_BASE_URL}/chat/completions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://github.com/clarity-diagrams/clarity",
+      "X-Title": "Clarity Diagrams"
+    },
+    body: JSON.stringify({
+      model: config?.model ?? DEFAULT_MODEL,
+      max_tokens: config?.maxTokens ?? DEFAULT_MAX_TOKENS,
+      messages
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OpenRouter API error: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  if (data.error) {
+    throw new Error(`OpenRouter error: ${data.error.message}`);
+  }
+  const content = data.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error("No response content from OpenRouter");
+  }
+  return content;
+}
+function findBalancedJson(text, startChar, endChar) {
+  const startIdx = text.indexOf(startChar);
+  if (startIdx === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  for (let i = startIdx; i < text.length; i++) {
+    const char = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === startChar) {
+      depth++;
+    } else if (char === endChar) {
+      depth--;
+      if (depth === 0) {
+        return text.slice(startIdx, i + 1);
+      }
+    }
+  }
+  return null;
+}
+function parseJsonResponse(response) {
+  const jsonMatch = response.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const jsonString = jsonMatch ? jsonMatch[1]?.trim() : response.trim();
+  if (!jsonString) {
+    throw new Error("Empty response from LLM");
+  }
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    const objectIdx = response.indexOf("{");
+    const arrayIdx = response.indexOf("[");
+    const tryObjectFirst = objectIdx !== -1 && (arrayIdx === -1 || objectIdx < arrayIdx);
+    if (tryObjectFirst) {
+      const objectJson = findBalancedJson(response, "{", "}");
+      if (objectJson) {
+        try {
+          return JSON.parse(objectJson);
+        } catch {
+        }
+      }
+      const arrayJson = findBalancedJson(response, "[", "]");
+      if (arrayJson) {
+        try {
+          return JSON.parse(arrayJson);
+        } catch {
+        }
+      }
+    } else {
+      const arrayJson = findBalancedJson(response, "[", "]");
+      if (arrayJson) {
+        try {
+          return JSON.parse(arrayJson);
+        } catch {
+        }
+      }
+      const objectJson = findBalancedJson(response, "{", "}");
+      if (objectJson) {
+        try {
+          return JSON.parse(objectJson);
+        } catch {
+        }
+      }
+    }
+    throw new Error(
+      `Failed to parse JSON from LLM response: ${response.slice(0, 200)}`
+    );
+  }
+}
+
+// ../core/src/llm/prompts.ts
+function buildEnhancePrompt(graph) {
+  const servicesInfo = graph.nodes.map((node) => formatServiceInfo(node)).join("\n\n");
+  const edgesInfo = graph.edges.map((edge) => `- ${edge.from} -> ${edge.to} (${edge.type})`).join("\n");
+  return `You are an infrastructure architect analyzing a system to create clear, informative architecture diagrams.
+
+## Task
+Analyze the following infrastructure services and enhance each with:
+1. A brief description (what it does)
+2. A logical group name (for visual grouping)
+3. For services that interact with message queues: their queue role (producer, consumer, or both)
+
+## Services to Analyze
+
+${servicesInfo}
+
+## Dependencies
+${edgesInfo || "No explicit dependencies defined"}
+
+## Response Format
+Return ONLY valid JSON matching this structure:
+\`\`\`json
+{
+  "services": [
+    {
+      "id": "service-id",
+      "description": "Brief description of what this service does",
+      "group": "Group Name",
+      "queueRole": "producer"
+    }
+  ],
+  "groups": [
+    {
+      "name": "Group Name",
+      "description": "Brief description of this logical group"
+    }
+  ]
+}
+\`\`\`
+
+## Guidelines
+- Keep descriptions under 50 words
+- Group related services together (e.g., all databases in "Data Stores")
+- Use clear, non-technical group names suitable for architecture diagrams
+- Infer purpose from service name, image, ports, and environment variables
+- Check every service name for role hints (e.g., web/ui for frontends, schema/migrations for data tasks)
+- Create 3-5 groups for typical infrastructure (avoid too many or too few)
+- Only include queueRole for services that produce to or consume from message queues (Kafka, RabbitMQ, etc.)`;
+}
+function formatServiceInfo(node) {
+  const lines = [`### ${node.name} (id: ${node.id})`];
+  if (node.image) {
+    lines.push(`- Image: ${node.image}`);
+  }
+  lines.push(`- Type: ${node.type}`);
+  if (node.ports?.length) {
+    const ports = node.ports.map((p) => `${p.external ?? "?"}:${p.internal}`).join(", ");
+    lines.push(`- Ports: ${ports}`);
+  }
+  if (node.environment && Object.keys(node.environment).length > 0) {
+    const envKeys = Object.keys(node.environment).slice(0, 10).join(", ");
+    lines.push(
+      `- Environment: ${envKeys}${Object.keys(node.environment).length > 10 ? "..." : ""}`
+    );
+  }
+  if (node.volumes?.length) {
+    const volumes = node.volumes.slice(0, 3).map((v) => `${v.source}:${v.target}`).join(", ");
+    lines.push(`- Volumes: ${volumes}${node.volumes.length > 3 ? "..." : ""}`);
+  }
+  return lines.join("\n");
+}
+function applyEnhancements(graph, enhancements) {
+  const enhancementMap = new Map(enhancements.services.map((s) => [s.id, s]));
+  const enhancedNodes = graph.nodes.map((node) => {
+    const enhancement = enhancementMap.get(node.id);
+    if (enhancement) {
+      return {
+        ...node,
+        description: enhancement.description,
+        group: enhancement.group,
+        queueRole: enhancement.queueRole
+      };
+    }
+    return node;
+  });
+  return {
+    ...graph,
+    nodes: enhancedNodes
+  };
+}
+
+// ../core/src/output/png.ts
+async function checkBrowserAvailability() {
+  try {
+    const puppeteer = await import("puppeteer");
+    const browser = await puppeteer.default.launch({
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox"]
+    });
+    const executablePath = browser.process()?.spawnfile;
+    await browser.close();
+    return {
+      available: true,
+      browserPath: executablePath
+    };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    if (error.includes("Could not find Chromium") || error.includes("ENOENT")) {
+      return {
+        available: false,
+        error: `Chromium not found. Puppeteer should auto-download it on first run.
+
+If download failed, try:
+  1. Run: npx puppeteer browsers install chrome
+  2. Or set PUPPETEER_EXECUTABLE_PATH to your Chrome/Chromium installation
+
+On macOS: /Applications/Google Chrome.app/Contents/MacOS/Google Chrome
+On Linux: /usr/bin/chromium-browser or /usr/bin/google-chrome`
+      };
+    }
+    if (error.includes("EACCES") || error.includes("permission")) {
+      return {
+        available: false,
+        error: `Permission error launching browser.
+
+Try running with appropriate permissions or set PUPPETEER_EXECUTABLE_PATH
+to a browser you have access to.`
+      };
+    }
+    return {
+      available: false,
+      error: `Failed to launch browser: ${error}`
+    };
+  }
+}
+var DEFAULT_OPTIONS = {
+  width: 1920,
+  height: 1080,
+  backgroundColor: "#ffffff",
+  scale: 2,
+  padding: 50
+};
+async function renderExcalidrawToPng(excalidraw, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const puppeteer = await import("puppeteer");
+  const browser = await puppeteer.default.launch({
+    headless: true,
+    args: ["--no-sandbox", "--disable-setuid-sandbox"]
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setViewport({
+      width: 1920,
+      height: 1080,
+      deviceScaleFactor: opts.scale
+    });
+    const html = createExcalidrawExportHtml(excalidraw, opts);
+    await page.setContent(html, { waitUntil: "networkidle2", timeout: 6e4 });
+    await page.waitForFunction(
+      () => window.__EXCALIDRAW_LOADED__,
+      { timeout: 6e4 }
+    );
+    await page.evaluate(() => {
+      ;
+      window.exportToPng();
+    });
+    await page.waitForFunction(
+      () => window.__EXPORT_COMPLETE__,
+      { timeout: 6e4 }
+    );
+    const result = await page.evaluate(() => {
+      return {
+        data: window.__EXPORT_DATA__,
+        error: window.__EXPORT_ERROR__
+      };
+    });
+    if (!result.data) {
+      const errorMsg = result.error || "Unknown error";
+      throw new Error(`Failed to export PNG from Excalidraw: ${errorMsg}`);
+    }
+    return Buffer.from(result.data, "base64");
+  } finally {
+    await browser.close();
+  }
+}
+function createExcalidrawExportHtml(excalidraw, options) {
+  const data = JSON.stringify(excalidraw);
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@18.2.0",
+      "react/jsx-runtime": "https://esm.sh/react@18.2.0/jsx-runtime",
+      "react/jsx-dev-runtime": "https://esm.sh/react@18.2.0/jsx-dev-runtime",
+      "react-dom": "https://esm.sh/react-dom@18.2.0",
+      "react-dom/client": "https://esm.sh/react-dom@18.2.0/client"
+    }
+  }
+  </script>
+  <style>
+    * { margin: 0; padding: 0; }
+    body { background: ${options.backgroundColor}; }
+    #root { width: 100vw; height: 100vh; }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+
+  <script type="module">
+    import React from 'react';
+    import { createRoot } from 'react-dom/client';
+    import { Excalidraw, exportToBlob } from 'https://esm.sh/@excalidraw/excalidraw@0.18.0?external=react,react-dom';
+
+    window.__EXPORT_COMPLETE__ = false;
+    window.__EXPORT_DATA__ = null;
+    window.__EXPORT_ERROR__ = null;
+    window.__EXCALIDRAW_LOADED__ = false;
+
+    const data = ${data};
+
+    // Reference to the Excalidraw API
+    let excalidrawAPI = null;
+
+    // Create the Excalidraw component
+    const App = () => {
+      return React.createElement(Excalidraw, {
+        excalidrawAPI: (api) => {
+          excalidrawAPI = api;
+          window.__EXCALIDRAW_LOADED__ = true;
+        },
+        initialData: {
+          elements: data.elements || [],
+          appState: {
+            viewBackgroundColor: "${options.backgroundColor}",
+          },
+          files: data.files || {},
+        },
+        UIOptions: {
+          canvasActions: {
+            export: false,
+            loadScene: false,
+            saveToActiveFile: false,
+          },
+        },
+      });
+    };
+
+    // Render the app
+    const root = createRoot(document.getElementById('root'));
+    root.render(React.createElement(App));
+
+    window.exportToPng = async function() {
+      try {
+        if (!excalidrawAPI) {
+          window.__EXPORT_ERROR__ = 'Excalidraw API not ready';
+          window.__EXPORT_COMPLETE__ = true;
+          return;
+        }
+
+        // Get the processed elements from Excalidraw (with elbow routing applied)
+        const elements = excalidrawAPI.getSceneElements();
+        const appState = excalidrawAPI.getAppState();
+        const files = excalidrawAPI.getFiles();
+
+        const blob = await exportToBlob({
+          elements,
+          appState: {
+            ...appState,
+            exportBackground: true,
+            viewBackgroundColor: "${options.backgroundColor}",
+          },
+          files,
+        });
+
+        const reader = new FileReader();
+        reader.onloadend = () => {
+          window.__EXPORT_DATA__ = reader.result.split(',')[1];
+          window.__EXPORT_COMPLETE__ = true;
+        };
+        reader.onerror = (err) => {
+          window.__EXPORT_ERROR__ = 'FileReader error: ' + err;
+          window.__EXPORT_COMPLETE__ = true;
+        };
+        reader.readAsDataURL(blob);
+      } catch (error) {
+        window.__EXPORT_ERROR__ = 'Export failed: ' + error.message;
+        window.__EXPORT_COMPLETE__ = true;
+      }
+    };
+  </script>
+</body>
+</html>`;
+}
+
+// ../core/src/pipeline/storage.ts
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+
+// ../core/src/config/index.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join5 } from "path";
+function getConfigPath() {
+  return join5(homedir(), ".config", "clarity", "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const configDir = dirname(configPath);
+  if (!existsSync2(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function getApiKey() {
+  const config = loadConfig();
+  return config.openRouterApiKey ?? process.env.OPENROUTER_API_KEY;
+}
+function maskApiKey(key) {
+  if (key.length <= 12) {
+    return "*".repeat(key.length);
+  }
+  return `${key.slice(0, 8)}...${key.slice(-4)}`;
+}
+
+// src/commands/config.ts
+import { Command } from "commander";
+var configCommand = new Command("config").description(
+  "Manage Clarity configuration"
+);
+configCommand.command("set-key <key>").description("Set your OpenRouter API key").action((key) => {
+  const config = loadConfig();
+  config.openRouterApiKey = key;
+  saveConfig(config);
+  console.log(`API key saved to ${getConfigPath()}`);
+});
+configCommand.command("show").description("Show current configuration").action(() => {
+  const configPath = getConfigPath();
+  const config = loadConfig();
+  const envKey = process.env.OPENROUTER_API_KEY;
+  console.log(`Config file: ${configPath}
+`);
+  if (config.openRouterApiKey) {
+    console.log(
+      `OpenRouter API key (config): ${maskApiKey(config.openRouterApiKey)}`
+    );
+  } else if (envKey) {
+    console.log(`OpenRouter API key (env): ${maskApiKey(envKey)}`);
+  } else {
+    console.log("OpenRouter API key: not set");
+    console.log("\nTo enable LLM enhancement, run:");
+    console.log("  clarity config set-key <your-openrouter-api-key>");
+  }
+});
+configCommand.command("clear").description("Clear the stored API key").action(() => {
+  const config = loadConfig();
+  delete config.openRouterApiKey;
+  saveConfig(config);
+  console.log("API key cleared");
+  if (process.env.OPENROUTER_API_KEY) {
+    console.log(
+      "\nNote: OPENROUTER_API_KEY environment variable is still set"
+    );
+  }
+});
+configCommand.command("path").description("Show the config file path").action(() => {
+  console.log(getConfigPath());
+});
+
+// src/generate.ts
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, stat, writeFile as writeFile2 } from "fs/promises";
+import { basename, join as join6, resolve } from "path";
+async function detectIaCFiles(dirPath) {
+  const files = [];
+  const entries = await readdir2(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join6(dirPath, entry.name);
+    if (entry.isFile()) {
+      const name = entry.name.toLowerCase();
+      if (name.includes("docker-compose") || name === "compose.yml" || name === "compose.yaml") {
+        files.push({ type: "docker-compose", path: fullPath, name: entry.name });
+      }
+    }
+    if (entry.isDirectory()) {
+      const chartPath = join6(fullPath, "Chart.yaml");
+      try {
+        await stat(chartPath);
+        files.push({ type: "helm", path: fullPath, name: entry.name });
+      } catch {
+        try {
+          await stat(join6(fullPath, "Chart.yml"));
+          files.push({ type: "helm", path: fullPath, name: entry.name });
+        } catch {
+        }
+      }
+    }
+  }
+  try {
+    await stat(join6(dirPath, "Chart.yaml"));
+    files.push({ type: "helm", path: dirPath, name: basename(dirPath) });
+  } catch {
+    try {
+      await stat(join6(dirPath, "Chart.yml"));
+      files.push({ type: "helm", path: dirPath, name: basename(dirPath) });
+    } catch {
+    }
+  }
+  return files;
+}
+async function parseIaC(detected, verbose) {
+  if (detected.type === "docker-compose") {
+    if (verbose) console.log(`  Parsing Docker Compose: ${detected.path}`);
+    const content = await readFile2(detected.path, "utf-8");
+    return parseDockerCompose(content, detected.name, detected.name);
+  }
+  if (detected.type === "helm") {
+    if (verbose) console.log(`  Parsing Helm chart: ${detected.path}`);
+    return parseHelmChart(detected.path, detected.name, detected.path);
+  }
+  throw new Error(`Unknown IaC type: ${detected.type}`);
+}
+async function enhanceGraph(graph, apiKey, verbose) {
+  if (verbose) console.log("  Enhancing with LLM...");
+  const prompt = buildEnhancePrompt(graph);
+  const response = await sendMessage(apiKey, prompt);
+  const enhancements = parseJsonResponse(response);
+  if (!enhancements?.services) {
+    if (verbose) console.log("  Warning: No enhancements returned from LLM");
+    return graph;
+  }
+  return applyEnhancements(graph, enhancements);
+}
+async function generate(inputPath, options = {}) {
+  const resolvedInput = resolve(inputPath);
+  const outputDir = resolve(options.output ?? "./docs/diagrams");
+  const verbose = options.verbose ?? false;
+  const skipPng = options.png === false;
+  const skipLlm = options.llm === false;
+  if (!skipPng) {
+    const browserCheck = await checkBrowserAvailability();
+    if (!browserCheck.available) {
+      console.error(
+        "\x1B[31m\u2717\x1B[0m Browser not available for PNG rendering\n"
+      );
+      console.error(browserCheck.error);
+      console.error("\nUse --no-png to skip PNG generation");
+      process.exit(1);
+    }
+  }
+  const inputStat = await stat(resolvedInput);
+  let detected;
+  if (inputStat.isFile()) {
+    const name = basename(resolvedInput).toLowerCase();
+    if (name.includes("docker-compose") || name === "compose.yml" || name === "compose.yaml") {
+      detected = [
+        {
+          type: "docker-compose",
+          path: resolvedInput,
+          name: basename(resolvedInput)
+        }
+      ];
+    } else {
+      console.error(`\x1B[31m\u2717\x1B[0m Unrecognized file type: ${resolvedInput}`);
+      console.error("Supported: docker-compose.yml, compose.yml");
+      process.exit(1);
+    }
+  } else if (inputStat.isDirectory()) {
+    detected = await detectIaCFiles(resolvedInput);
+    if (detected.length === 0) {
+      console.error(`\x1B[31m\u2717\x1B[0m No IaC files found in: ${resolvedInput}`);
+      console.error("Looking for: docker-compose.yml, compose.yml, Chart.yaml");
+      process.exit(1);
+    }
+  } else {
+    console.error(`\x1B[31m\u2717\x1B[0m Invalid path: ${resolvedInput}`);
+    process.exit(1);
+  }
+  await mkdir2(outputDir, { recursive: true });
+  const apiKey = getApiKey();
+  const llmEnabled = !skipLlm && !!apiKey;
+  if (!skipLlm && !apiKey && verbose) {
+    console.log("  Note: No API key configured, skipping LLM enhancement");
+    console.log("  Run: iac-diagrams config set-key <your-openrouter-key>");
+  }
+  for (const file of detected) {
+    console.log(`
+Generating diagram for: ${file.name}`);
+    if (verbose) console.log("  Step 1: Parsing...");
+    let graph = await parseIaC(file, verbose);
+    if (verbose) {
+      console.log(`    Found ${graph.nodes.length} services`);
+      console.log(`    Found ${graph.edges.length} dependencies`);
+    }
+    if (llmEnabled && apiKey) {
+      if (verbose) console.log("  Step 2: Enhancing with LLM...");
+      try {
+        graph = await enhanceGraph(graph, apiKey, verbose);
+      } catch (err) {
+        console.error(
+          `  \x1B[33m!\x1B[0m LLM enhancement failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else if (verbose) {
+      console.log("  Step 2: Skipping LLM enhancement");
+    }
+    if (verbose) console.log("  Step 3: Computing layout...");
+    const elkConversion = infraGraphToElk(graph);
+    const elkLayoutResult = await runLayout(elkConversion.graph);
+    if (verbose) console.log("  Step 4: Generating Excalidraw...");
+    const excalidraw = renderWithElkLayout(graph, elkLayoutResult.graph);
+    const baseName = file.name.replace(/\.(yml|yaml)$/i, "");
+    const excalidrawPath = join6(outputDir, `${baseName}.excalidraw`);
+    await writeFile2(excalidrawPath, JSON.stringify(excalidraw, null, 2));
+    console.log(`  \x1B[32m\u2713\x1B[0m Saved: ${excalidrawPath}`);
+    if (!skipPng) {
+      if (verbose) console.log("  Step 5: Rendering PNG...");
+      const pngBuffer = await renderExcalidrawToPng(excalidraw);
+      const pngPath = join6(outputDir, `${baseName}.png`);
+      await writeFile2(pngPath, pngBuffer);
+      console.log(`  \x1B[32m\u2713\x1B[0m Saved: ${pngPath}`);
+    }
+  }
+  console.log("\n\x1B[32m\u2713\x1B[0m Done!");
+}
+
+// src/index.ts
+var program = new Command2().name("iac-diagrams").description(
+  "Generate architecture diagrams from Infrastructure-as-Code files"
+).version("0.1.0").argument(
+  "[path]",
+  "File or directory to process (default: current directory)",
+  "."
+).option("-o, --output <dir>", "Output directory", "./docs/diagrams").option("--no-llm", "Disable LLM enhancement").option("--no-png", "Skip PNG rendering (output .excalidraw only)").option("-v, --verbose", "Show detailed output").action(
+  async (path, options) => {
+    await generate(path, options);
+  }
+);
+program.addCommand(configCommand);
+program.parse();