@chamuka-labs/drawit-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2817 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/utils/io.ts
+var import_node_fs = require("fs");
+function readInput(filePath, stdin = false) {
+  if (stdin || filePath === "-") {
+    return readStdin();
+  }
+  if (!filePath) {
+    throw new Error("No input file specified. Use --stdin to read from stdin.");
+  }
+  try {
+    return (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to read file "${filePath}": ${message}`);
+  }
+}
+function readStdin() {
+  const chunks = [];
+  const fd = 0;
+  try {
+    const buf = Buffer.alloc(65536);
+    let bytesRead;
+    while (true) {
+      try {
+        bytesRead = (0, import_node_fs.readSync)(fd, buf, 0, buf.length, null);
+        if (bytesRead === 0) break;
+        chunks.push(Buffer.from(buf.subarray(0, bytesRead)));
+      } catch {
+        break;
+      }
+    }
+  } catch {
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function writeOutput(content, outputPath) {
+  if (!outputPath || outputPath === "-") {
+    process.stdout.write(content);
+    return;
+  }
+  try {
+    (0, import_node_fs.writeFileSync)(outputPath, content, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to write to "${outputPath}": ${message}`);
+  }
+}
+
+// ../chamuka-drawit-sdk/dist/types/elements.js
+var import_zod = require("zod");
+var PositionSchema = import_zod.z.object({
+  x: import_zod.z.number(),
+  y: import_zod.z.number()
+});
+var SizeSchema = import_zod.z.object({
+  width: import_zod.z.number().positive(),
+  height: import_zod.z.number().positive()
+});
+var CornerRadiiSchema = import_zod.z.object({
+  topLeft: import_zod.z.number().min(0),
+  topRight: import_zod.z.number().min(0),
+  bottomRight: import_zod.z.number().min(0),
+  bottomLeft: import_zod.z.number().min(0)
+});
+var EdgeRoutingSchema = import_zod.z.enum(["straight", "orthogonal", "bezier"]);
+var StyleSchema = import_zod.z.object({
+  fillStyle: import_zod.z.string().optional(),
+  strokeStyle: import_zod.z.string().optional(),
+  lineWidth: import_zod.z.number().min(0).optional(),
+  fillOpacity: import_zod.z.number().min(0).max(1).optional(),
+  strokeOpacity: import_zod.z.number().min(0).max(1).optional(),
+  cornerRadii: CornerRadiiSchema.optional(),
+  cornerRadius: import_zod.z.number().min(0).optional(),
+  lineDash: import_zod.z.array(import_zod.z.number()).optional(),
+  routing: EdgeRoutingSchema.optional(),
+  lineCap: import_zod.z.enum(["butt", "round", "square"]).optional(),
+  lineJoin: import_zod.z.enum(["miter", "round", "bevel"]).optional(),
+  shadowColor: import_zod.z.string().optional(),
+  shadowBlur: import_zod.z.number().min(0).optional(),
+  shadowOffsetX: import_zod.z.number().optional(),
+  shadowOffsetY: import_zod.z.number().optional()
+});
+var TextPropsSchema = import_zod.z.object({
+  content: import_zod.z.string(),
+  fontSize: import_zod.z.number().positive().optional(),
+  fontFamily: import_zod.z.string().optional(),
+  color: import_zod.z.string().optional(),
+  textAlign: import_zod.z.enum(["left", "center", "right"]).optional(),
+  verticalAlign: import_zod.z.enum(["top", "middle", "bottom"]).optional(),
+  padding: import_zod.z.number().min(0).optional(),
+  fontWeight: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+  fontStyle: import_zod.z.enum(["normal", "italic", "oblique"]).optional()
+});
+var ShapeTypeSchema = import_zod.z.enum([
+  "rectangle",
+  "ellipse",
+  "diamond",
+  "triangle",
+  "hexagon",
+  "star",
+  "polygon",
+  "icon",
+  "polyline",
+  "line"
+]);
+var NodeElementSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("node"),
+  position: PositionSchema,
+  size: SizeSchema.optional(),
+  shape: ShapeTypeSchema.optional(),
+  text: import_zod.z.union([import_zod.z.string(), TextPropsSchema]).optional(),
+  style: StyleSchema.optional(),
+  angle: import_zod.z.number().optional(),
+  zIndex: import_zod.z.number().optional(),
+  constrainAspectRatio: import_zod.z.boolean().optional(),
+  metadata: import_zod.z.record(import_zod.z.any()).optional()
+});
+var EdgeLabelSchema = import_zod.z.object({
+  text: import_zod.z.string(),
+  fontSize: import_zod.z.number().positive().optional(),
+  color: import_zod.z.string().optional(),
+  position: import_zod.z.number().min(0).max(1).optional()
+});
+var EdgeElementSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("edge"),
+  source: import_zod.z.string(),
+  target: import_zod.z.string(),
+  label: import_zod.z.union([import_zod.z.string(), EdgeLabelSchema]).optional(),
+  style: StyleSchema.optional(),
+  position: PositionSchema.optional(),
+  zIndex: import_zod.z.number().optional(),
+  points: import_zod.z.array(PositionSchema).optional(),
+  metadata: import_zod.z.record(import_zod.z.any()).optional()
+});
+var DiagramElementSchema = import_zod.z.discriminatedUnion("type", [
+  NodeElementSchema,
+  EdgeElementSchema
+]);
+var ElementUpdateSchema = import_zod.z.object({
+  position: PositionSchema.optional(),
+  size: SizeSchema.optional(),
+  text: import_zod.z.union([import_zod.z.string(), TextPropsSchema]).optional(),
+  style: StyleSchema.optional(),
+  angle: import_zod.z.number().optional(),
+  zIndex: import_zod.z.number().optional(),
+  metadata: import_zod.z.record(import_zod.z.any()).optional()
+});
+
+// ../chamuka-drawit-sdk/dist/tools/definitions.js
+var import_zod2 = require("zod");
+var AddNodeInputSchema = import_zod2.z.object({
+  id: import_zod2.z.string().optional().describe("Unique identifier for the node"),
+  position: PositionSchema.describe("Position in canvas coordinates"),
+  size: SizeSchema.optional().describe("Size of the node"),
+  shape: ShapeTypeSchema.optional().describe("Shape type"),
+  text: import_zod2.z.union([import_zod2.z.string(), TextPropsSchema]).optional().describe("Text content"),
+  style: StyleSchema.optional().describe("Visual styling options"),
+  angle: import_zod2.z.number().optional().describe("Rotation angle in degrees"),
+  zIndex: import_zod2.z.number().optional().describe("Layer order (higher = on top)"),
+  metadata: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Custom metadata")
+});
+var AddEdgeInputSchema = import_zod2.z.object({
+  id: import_zod2.z.string().optional().describe("Unique identifier for the edge"),
+  source: import_zod2.z.string().describe("ID of the source node"),
+  target: import_zod2.z.string().describe("ID of the target node"),
+  label: import_zod2.z.union([import_zod2.z.string(), EdgeLabelSchema]).optional().describe("Edge label"),
+  style: StyleSchema.optional().describe("Visual styling options"),
+  zIndex: import_zod2.z.number().optional().describe("Layer order"),
+  metadata: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Custom metadata")
+});
+var ModifyElementInputSchema = import_zod2.z.object({
+  elementId: import_zod2.z.string().describe("ID of the element to modify"),
+  position: PositionSchema.optional().describe("New position"),
+  size: SizeSchema.optional().describe("New size"),
+  text: import_zod2.z.union([import_zod2.z.string(), TextPropsSchema]).optional().describe("New text"),
+  style: StyleSchema.optional().describe("Style updates"),
+  angle: import_zod2.z.number().optional().describe("New rotation angle"),
+  zIndex: import_zod2.z.number().optional().describe("New layer order"),
+  metadata: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Metadata updates")
+});
+var RemoveElementInputSchema = import_zod2.z.object({
+  elementId: import_zod2.z.string().describe("ID of the element to remove")
+});
+var RemoveElementsInputSchema = import_zod2.z.object({
+  elementIds: import_zod2.z.array(import_zod2.z.string()).describe("IDs of elements to remove")
+});
+var ExportDiagramInputSchema = import_zod2.z.object({
+  format: import_zod2.z.enum(["svg", "json", "png"]).describe("Export format")
+});
+var GetElementInputSchema = import_zod2.z.object({
+  elementId: import_zod2.z.string().describe("ID of the element to retrieve")
+});
+var EmptyInputSchema = import_zod2.z.object({});
+
+// src/core/metadata.ts
+var import_zod3 = require("zod");
+var MetadataSchema = import_zod3.z.object({
+  width: import_zod3.z.number().positive(),
+  height: import_zod3.z.number().positive(),
+  background: import_zod3.z.string(),
+  metadata: import_zod3.z.object({
+    name: import_zod3.z.string().optional(),
+    diagramType: import_zod3.z.string().optional(),
+    elementCount: import_zod3.z.number().optional(),
+    createdAt: import_zod3.z.number().optional(),
+    modifiedAt: import_zod3.z.number().optional()
+  }).passthrough().optional()
+});
+function parseMetadata(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return { success: false, error: "First line is not valid JSON" };
+  }
+  const result = MetadataSchema.safeParse(obj);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+    return { success: false, error: `Invalid metadata: ${errors}` };
+  }
+  return { success: true, data: result.data };
+}
+function isMetadataLine(obj) {
+  return "width" in obj && "height" in obj && !("type" in obj);
+}
+
+// src/core/parser.ts
+function isElementLike(obj) {
+  if (typeof obj.id !== "string" || !obj.id) return false;
+  if (obj.type === "node") {
+    return obj.position != null && typeof obj.position === "object";
+  }
+  if (obj.type === "edge") {
+    return typeof obj.source === "string" && typeof obj.target === "string";
+  }
+  return false;
+}
+function parseDiagram(content, strict = false) {
+  const lines = content.split("\n");
+  const result = {
+    metadata: null,
+    elements: [],
+    nodes: [],
+    edges: [],
+    errors: []
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    const lineNum = i + 1;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      result.errors.push({ line: lineNum, message: "Invalid JSON", raw: line.slice(0, 100) });
+      continue;
+    }
+    if (typeof obj !== "object" || obj === null) {
+      result.errors.push({ line: lineNum, message: "Line is not a JSON object" });
+      continue;
+    }
+    const record = obj;
+    if (result.metadata === null && isMetadataLine(record)) {
+      const metaResult = parseMetadata(line);
+      if (metaResult.success) {
+        result.metadata = metaResult.data;
+      } else {
+        result.errors.push({ line: lineNum, message: metaResult.error });
+      }
+      continue;
+    }
+    if (strict) {
+      const validated = DiagramElementSchema.safeParse(obj);
+      if (!validated.success) {
+        const errorMessages = validated.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+        result.errors.push({ line: lineNum, message: `Schema validation failed: ${errorMessages}` });
+        continue;
+      }
+      const element = { ...record, ...validated.data };
+      if (record.style && typeof record.style === "object") {
+        element.style = { ...record.style };
+      }
+      if (record.metadata && typeof record.metadata === "object") {
+        element.metadata = { ...record.metadata };
+      }
+      addElement(result, element);
+    } else {
+      if (!isElementLike(record)) {
+        result.errors.push({ line: lineNum, message: "Not a recognized element (missing id, type, or required fields)" });
+        continue;
+      }
+      const element = record;
+      addElement(result, element);
+    }
+  }
+  if (strict) {
+    if (!result.metadata) {
+      result.errors.push({ line: 1, message: "Missing metadata first line (required in strict mode)" });
+    }
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const el of result.elements) {
+    if (ids.has(el.id)) {
+      result.errors.push({ line: 0, message: `Duplicate element ID: "${el.id}"` });
+    }
+    ids.add(el.id);
+  }
+  const nodeIds = new Set(result.nodes.map((n) => n.id));
+  for (const edge of result.edges) {
+    if (!nodeIds.has(edge.source)) {
+      result.errors.push({ line: 0, message: `Edge "${edge.id}" references missing source node "${edge.source}"` });
+    }
+    if (!nodeIds.has(edge.target)) {
+      result.errors.push({ line: 0, message: `Edge "${edge.id}" references missing target node "${edge.target}"` });
+    }
+  }
+  return result;
+}
+function addElement(result, element) {
+  result.elements.push(element);
+  if (element.type === "node") {
+    result.nodes.push(element);
+  } else if (element.type === "edge") {
+    result.edges.push(element);
+  }
+}
+
+// src/utils/format.ts
+function formatErrors(errors) {
+  if (errors.length === 0) return "";
+  return errors.map((e) => {
+    const lineInfo = e.line > 0 ? `Line ${e.line}: ` : "";
+    const rawInfo = e.raw ? ` (raw: "${e.raw}")` : "";
+    return `  ${lineInfo}${e.message}${rawInfo}`;
+  }).join("\n");
+}
+function formatKV(key, value, indent = 0) {
+  const prefix = " ".repeat(indent);
+  const displayValue = value === null || value === void 0 ? "(none)" : String(value);
+  return `${prefix}${key}: ${displayValue}`;
+}
+function formatHeader(title) {
+  return `
+${title}
+${"\u2500".repeat(title.length)}`;
+}
+function formatCount(label, count) {
+  return `  ${label}: ${count}`;
+}
+
+// src/commands/validate.ts
+function registerValidateCommand(program2) {
+  program2.command("validate <file>").description("Validate a .drawit file against the schema").option("--format <format>", "Output format: text or json", "text").option("--strict", "Enable strict validation (duplicate IDs, edge references)", false).option("--stdin", "Read from stdin instead of file").action((file, opts) => {
+    try {
+      const content = readInput(opts.stdin ? "-" : file);
+      const result = parseDiagram(content, opts.strict);
+      if (opts.format === "json") {
+        const output = {
+          valid: result.errors.length === 0,
+          errors: result.errors,
+          stats: {
+            nodes: result.nodes.length,
+            edges: result.edges.length,
+            hasMetadata: result.metadata !== null
+          }
+        };
+        process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+      } else {
+        if (result.errors.length === 0) {
+          process.stdout.write(`Valid .drawit file (${result.nodes.length} nodes, ${result.edges.length} edges)
+`);
+        } else {
+          process.stderr.write(`Found ${result.errors.length} error(s):
+`);
+          process.stderr.write(formatErrors(result.errors) + "\n");
+        }
+      }
+      process.exitCode = result.errors.length === 0 ? 0 : 1;
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/svg/utils.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function regularPolygonPoints(cx, cy, rx, ry, sides, startAngle = -Math.PI / 2) {
+  const points = [];
+  for (let i = 0; i < sides; i++) {
+    const angle = startAngle + 2 * Math.PI * i / sides;
+    points.push({
+      x: cx + rx * Math.cos(angle),
+      y: cy + ry * Math.sin(angle)
+    });
+  }
+  return points;
+}
+function pointsToSvg(points) {
+  return points.map((p) => `${p.x},${p.y}`).join(" ");
+}
+function starPoints(cx, cy, rx, ry, numPoints, innerRadius) {
+  const points = [];
+  const irx = rx * innerRadius;
+  const iry = ry * innerRadius;
+  const startAngle = -Math.PI / 2;
+  for (let i = 0; i < numPoints * 2; i++) {
+    const angle = startAngle + Math.PI * i / numPoints;
+    const isOuter = i % 2 === 0;
+    points.push({
+      x: cx + (isOuter ? rx : irx) * Math.cos(angle),
+      y: cy + (isOuter ? ry : iry) * Math.sin(angle)
+    });
+  }
+  return points;
+}
+function getStyleProps(style = {}) {
+  return {
+    fill: String(style.fillStyle ?? style.fill ?? "none"),
+    stroke: String(style.strokeStyle ?? style.stroke ?? "none"),
+    strokeWidth: Number(style.lineWidth ?? style.strokeWidth ?? 2),
+    fillOpacity: Number(style.fillOpacity ?? 1),
+    strokeOpacity: Number(style.strokeOpacity ?? 1),
+    lineDash: Array.isArray(style.lineDash) ? style.lineDash : []
+  };
+}
+
+// src/svg/shapes.ts
+function renderNodeShape(node) {
+  const shape = node.shape ?? "rectangle";
+  const pos = node.position;
+  const size = node.size ?? { width: 100, height: 60 };
+  const style = node.style ?? {};
+  const metadata = node.metadata ?? {};
+  const s = getStyleProps(style);
+  const styleAttrs = buildStyleAttrs(s);
+  const transform = node.angle ? ` transform="rotate(${node.angle} ${pos.x + size.width / 2} ${pos.y + size.height / 2})"` : "";
+  let shapeEl = "";
+  switch (shape) {
+    case "rectangle":
+      shapeEl = renderRectangle(pos, size, style, styleAttrs);
+      break;
+    case "ellipse":
+      shapeEl = renderEllipse(pos, size, styleAttrs);
+      break;
+    case "diamond":
+      shapeEl = renderDiamond(pos, size, styleAttrs);
+      break;
+    case "triangle":
+      shapeEl = renderTriangle(pos, size, styleAttrs);
+      break;
+    case "hexagon":
+      shapeEl = renderRegularPolygon(pos, size, 6, styleAttrs);
+      break;
+    case "polygon":
+      shapeEl = renderRegularPolygon(pos, size, Number(metadata.sides ?? 6), styleAttrs);
+      break;
+    case "star":
+      shapeEl = renderStar(pos, size, metadata, styleAttrs);
+      break;
+    case "polyline":
+      shapeEl = renderPolyline(pos, metadata, styleAttrs);
+      break;
+    case "icon":
+      shapeEl = renderIcon(pos, size, style, styleAttrs);
+      break;
+    case "line":
+      shapeEl = renderLine(pos, size, styleAttrs);
+      break;
+    default:
+      shapeEl = renderRectangle(pos, size, style, styleAttrs);
+  }
+  return `<g${transform}>${shapeEl}</g>`;
+}
+function buildStyleAttrs(s) {
+  let attrs = ` fill="${s.fill}" stroke="${s.stroke}" stroke-width="${s.strokeWidth}"`;
+  if (s.fillOpacity < 1) attrs += ` fill-opacity="${s.fillOpacity}"`;
+  if (s.strokeOpacity < 1) attrs += ` stroke-opacity="${s.strokeOpacity}"`;
+  if (s.lineDash.length > 0) attrs += ` stroke-dasharray="${s.lineDash.join(",")}"`;
+  return attrs;
+}
+function renderRectangle(pos, size, style, styleAttrs) {
+  let rx = 0;
+  let ry = 0;
+  const cornerRadii = style.cornerRadii;
+  const cornerRadius = style.cornerRadius;
+  if (cornerRadii) {
+    rx = (cornerRadii.topLeft + cornerRadii.topRight + cornerRadii.bottomRight + cornerRadii.bottomLeft) / 4;
+    ry = rx;
+  } else if (cornerRadius !== void 0) {
+    rx = cornerRadius;
+    ry = cornerRadius;
+  }
+  const radiusAttrs = rx > 0 ? ` rx="${rx}" ry="${ry}"` : "";
+  return `<rect x="${pos.x}" y="${pos.y}" width="${size.width}" height="${size.height}"${radiusAttrs}${styleAttrs}/>`;
+}
+function renderEllipse(pos, size, styleAttrs) {
+  const cx = pos.x + size.width / 2;
+  const cy = pos.y + size.height / 2;
+  return `<ellipse cx="${cx}" cy="${cy}" rx="${size.width / 2}" ry="${size.height / 2}"${styleAttrs}/>`;
+}
+function renderDiamond(pos, size, styleAttrs) {
+  const cx = pos.x + size.width / 2;
+  const cy = pos.y + size.height / 2;
+  const points = [
+    { x: cx, y: pos.y },
+    { x: pos.x + size.width, y: cy },
+    { x: cx, y: pos.y + size.height },
+    { x: pos.x, y: cy }
+  ];
+  return `<polygon points="${pointsToSvg(points)}"${styleAttrs}/>`;
+}
+function renderTriangle(pos, size, styleAttrs) {
+  const points = [
+    { x: pos.x + size.width / 2, y: pos.y },
+    { x: pos.x + size.width, y: pos.y + size.height },
+    { x: pos.x, y: pos.y + size.height }
+  ];
+  return `<polygon points="${pointsToSvg(points)}"${styleAttrs}/>`;
+}
+function renderRegularPolygon(pos, size, sides, styleAttrs) {
+  const cx = pos.x + size.width / 2;
+  const cy = pos.y + size.height / 2;
+  const points = regularPolygonPoints(cx, cy, size.width / 2, size.height / 2, sides);
+  return `<polygon points="${pointsToSvg(points)}"${styleAttrs}/>`;
+}
+function renderStar(pos, size, metadata, styleAttrs) {
+  const cx = pos.x + size.width / 2;
+  const cy = pos.y + size.height / 2;
+  const numPoints = Number(metadata.points ?? 5);
+  const innerRadius = Number(metadata.innerRadius ?? 0.4);
+  const points = starPoints(cx, cy, size.width / 2, size.height / 2, numPoints, innerRadius);
+  return `<polygon points="${pointsToSvg(points)}"${styleAttrs}/>`;
+}
+function renderPolyline(pos, metadata, styleAttrs) {
+  const polylinePoints = metadata.polylinePoints;
+  if (!polylinePoints || polylinePoints.length === 0) {
+    return "";
+  }
+  const absolutePoints = polylinePoints.map((p) => ({
+    x: pos.x + p.x,
+    y: pos.y + p.y
+  }));
+  const isClosed = metadata.isPolylineClosed === true;
+  const tag = isClosed ? "polygon" : "polyline";
+  return `<${tag} points="${pointsToSvg(absolutePoints)}"${styleAttrs}/>`;
+}
+function renderIcon(pos, size, style, styleAttrs) {
+  const iconName = String(style.iconName ?? "icon");
+  const iconColor = style.iconOptions?.color ?? style.strokeStyle ?? "#666666";
+  return `<rect x="${pos.x}" y="${pos.y}" width="${size.width}" height="${size.height}" fill="none" stroke="${iconColor}" stroke-width="1" rx="4"/><text x="${pos.x + size.width / 2}" y="${pos.y + size.height / 2}" fill="${iconColor}" font-size="10" text-anchor="middle" dominant-baseline="middle" font-family="sans-serif">${escapeXml(iconName)}</text>`;
+}
+function renderLine(pos, size, styleAttrs) {
+  return `<line x1="${pos.x}" y1="${pos.y}" x2="${pos.x + size.width}" y2="${pos.y + size.height}"${styleAttrs}/>`;
+}
+
+// src/svg/text.ts
+function renderNodeText(node) {
+  if (!node.text) return "";
+  const size = node.size ?? { width: 100, height: 60 };
+  const pos = node.position;
+  let textProps;
+  if (typeof node.text === "string") {
+    textProps = { content: node.text };
+  } else {
+    textProps = node.text;
+  }
+  if (!textProps.content) return "";
+  const fontSize = textProps.fontSize ?? 14;
+  const fontFamily = mapFontFamily(textProps.fontFamily ?? "sans-serif");
+  const color = textProps.color ?? "#000000";
+  const textAlign = textProps.textAlign ?? "center";
+  const verticalAlign = textProps.verticalAlign ?? "middle";
+  const padding = textProps.padding ?? 8;
+  const fontWeight = textProps.fontWeight ?? "normal";
+  const fontStyle = textProps.fontStyle ?? "normal";
+  const lineHeight = textProps.lineHeight ?? 1.4;
+  const anchor = textAlign === "left" ? "start" : textAlign === "right" ? "end" : "middle";
+  let textX;
+  if (textAlign === "left") {
+    textX = pos.x + padding;
+  } else if (textAlign === "right") {
+    textX = pos.x + size.width - padding;
+  } else {
+    textX = pos.x + size.width / 2;
+  }
+  const lines = textProps.content.split("\n");
+  const totalLineHeight = fontSize * lineHeight;
+  const totalTextHeight = lines.length * totalLineHeight;
+  let startY;
+  if (verticalAlign === "top") {
+    startY = pos.y + padding + fontSize;
+  } else if (verticalAlign === "bottom") {
+    startY = pos.y + size.height - padding - totalTextHeight + fontSize;
+  } else {
+    startY = pos.y + (size.height - totalTextHeight) / 2 + fontSize;
+  }
+  const tspans = [];
+  for (let i = 0; i < lines.length; i++) {
+    const y = startY + i * totalLineHeight;
+    const segments = parseMarkdownLite(lines[i]);
+    const renderedSegments = segments.map((seg) => {
+      let attrs = "";
+      if (seg.bold) attrs += ' font-weight="bold"';
+      if (seg.italic) attrs += ' font-style="italic"';
+      if (seg.code) attrs += ' font-family="monospace"';
+      return `<tspan${attrs}>${escapeXml(seg.text)}</tspan>`;
+    });
+    tspans.push(`<tspan x="${textX}" y="${y}">${renderedSegments.join("")}</tspan>`);
+  }
+  return `<text fill="${color}" font-size="${fontSize}" font-family="${escapeXml(fontFamily)}" font-weight="${fontWeight}" font-style="${fontStyle}" text-anchor="${anchor}" dominant-baseline="auto">${tspans.join("")}</text>`;
+}
+function parseMarkdownLite(text) {
+  const segments = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    const boldMatch = remaining.match(/^\*\*(.+?)\*\*/);
+    if (boldMatch) {
+      segments.push({ text: boldMatch[1], bold: true, italic: false, code: false });
+      remaining = remaining.slice(boldMatch[0].length);
+      continue;
+    }
+    const italicMatch = remaining.match(/^\*(.+?)\*/);
+    if (italicMatch) {
+      segments.push({ text: italicMatch[1], bold: false, italic: true, code: false });
+      remaining = remaining.slice(italicMatch[0].length);
+      continue;
+    }
+    const codeMatch = remaining.match(/^`(.+?)`/);
+    if (codeMatch) {
+      segments.push({ text: codeMatch[1], bold: false, italic: false, code: true });
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+    const nextMarker = remaining.search(/[*`]/);
+    if (nextMarker === -1) {
+      segments.push({ text: remaining, bold: false, italic: false, code: false });
+      break;
+    } else if (nextMarker === 0) {
+      segments.push({ text: remaining[0], bold: false, italic: false, code: false });
+      remaining = remaining.slice(1);
+    } else {
+      segments.push({ text: remaining.slice(0, nextMarker), bold: false, italic: false, code: false });
+      remaining = remaining.slice(nextMarker);
+    }
+  }
+  return segments.length > 0 ? segments : [{ text: "", bold: false, italic: false, code: false }];
+}
+function mapFontFamily(family) {
+  const map = {
+    geist: "Geist, system-ui, sans-serif",
+    "geist-mono": "Geist Mono, monospace",
+    lato: "Lato, sans-serif",
+    merriweather: "Merriweather, serif",
+    montserrat: "Montserrat, sans-serif",
+    "open-sans": "Open Sans, sans-serif",
+    "playfair-display": "Playfair Display, serif",
+    roboto: "Roboto, sans-serif",
+    georgia: "Georgia, serif",
+    pacifico: "Pacifico, cursive"
+  };
+  return map[family] ?? family;
+}
+
+// src/svg/edges.ts
+function generateMarkerDefs() {
+  return `<defs>
+    <marker id="arrowhead-end" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto">
+      <polygon points="0 0, 10 3.5, 0 7" fill="context-stroke"/>
+    </marker>
+    <marker id="arrowhead-start" markerWidth="10" markerHeight="7" refX="0" refY="3.5" orient="auto">
+      <polygon points="10 0, 0 3.5, 10 7" fill="context-stroke"/>
+    </marker>
+    <marker id="arrowhead-diamond" markerWidth="12" markerHeight="8" refX="6" refY="4" orient="auto">
+      <polygon points="0 4, 6 0, 12 4, 6 8" fill="context-stroke"/>
+    </marker>
+    <marker id="arrowhead-circle" markerWidth="8" markerHeight="8" refX="4" refY="4" orient="auto">
+      <circle cx="4" cy="4" r="3" fill="context-stroke"/>
+    </marker>
+  </defs>`;
+}
+function renderEdge(edge, nodeLookup) {
+  const style = edge.style ?? {};
+  const s = getStyleProps(style);
+  const routing = String(style.routing ?? "straight");
+  const sourceNode = nodeLookup.get(edge.source);
+  const targetNode = nodeLookup.get(edge.target);
+  if (!sourceNode || !targetNode) {
+    return `<!-- Edge ${edge.id}: missing source or target -->`;
+  }
+  const sourceSize = sourceNode.size ?? { width: 100, height: 60 };
+  const targetSize = targetNode.size ?? { width: 100, height: 60 };
+  const sx = sourceNode.position.x + sourceSize.width / 2;
+  const sy = sourceNode.position.y + sourceSize.height / 2;
+  const tx = targetNode.position.x + targetSize.width / 2;
+  const ty = targetNode.position.y + targetSize.height / 2;
+  let attrs = ` stroke="${s.stroke}" stroke-width="${s.strokeWidth}" fill="none"`;
+  if (s.strokeOpacity < 1) attrs += ` stroke-opacity="${s.strokeOpacity}"`;
+  if (s.lineDash.length > 0) attrs += ` stroke-dasharray="${s.lineDash.join(",")}"`;
+  if (style.arrowheadEnd === true || style.markerEnd === "arrow") {
+    attrs += ' marker-end="url(#arrowhead-end)"';
+  }
+  if (style.arrowheadStart === true || style.markerStart === "arrow") {
+    attrs += ' marker-start="url(#arrowhead-start)"';
+  }
+  let pathEl;
+  const waypoints = edge.points;
+  if (waypoints && waypoints.length > 0) {
+    const allPoints = [{ x: sx, y: sy }, ...waypoints, { x: tx, y: ty }];
+    const d = allPoints.map((p, i) => `${i === 0 ? "M" : "L"}${p.x} ${p.y}`).join(" ");
+    pathEl = `<path d="${d}"${attrs}/>`;
+  } else if (routing === "orthogonal") {
+    pathEl = renderOrthogonalEdge(sx, sy, tx, ty, style, attrs);
+  } else if (routing === "bezier") {
+    pathEl = renderBezierEdge(sx, sy, tx, ty, attrs);
+  } else {
+    pathEl = `<line x1="${sx}" y1="${sy}" x2="${tx}" y2="${ty}"${attrs}/>`;
+  }
+  const labelEl = renderEdgeLabel(edge, sx, sy, tx, ty);
+  return pathEl + labelEl;
+}
+function renderOrthogonalEdge(sx, sy, tx, ty, style, attrs) {
+  const cornerRadius = Number(style.cornerRadius ?? 0);
+  const midX = tx;
+  const midY = sy;
+  if (cornerRadius > 0 && Math.abs(tx - sx) > cornerRadius * 2 && Math.abs(ty - sy) > cornerRadius * 2) {
+    const dx = tx > sx ? 1 : -1;
+    const dy = ty > sy ? 1 : -1;
+    const r = Math.min(cornerRadius, Math.abs(tx - sx) / 2, Math.abs(ty - sy) / 2);
+    const d2 = [
+      `M${sx} ${sy}`,
+      `L${midX - dx * r} ${sy}`,
+      `Q${midX} ${sy} ${midX} ${sy + dy * r}`,
+      `L${tx} ${ty}`
+    ].join(" ");
+    return `<path d="${d2}"${attrs}/>`;
+  }
+  const d = `M${sx} ${sy} L${midX} ${midY} L${tx} ${ty}`;
+  return `<path d="${d}"${attrs}/>`;
+}
+function renderBezierEdge(sx, sy, tx, ty, attrs) {
+  const dx = Math.abs(tx - sx) * 0.5;
+  const d = `M${sx} ${sy} C${sx + dx} ${sy}, ${tx - dx} ${ty}, ${tx} ${ty}`;
+  return `<path d="${d}"${attrs}/>`;
+}
+function renderEdgeLabel(edge, sx, sy, tx, ty) {
+  if (!edge.label) return "";
+  let text;
+  let fontSize = 14;
+  let color = "#475569";
+  let offsetX = 0;
+  let offsetY = -10;
+  if (typeof edge.label === "string") {
+    text = edge.label;
+  } else {
+    text = edge.label.text ?? "";
+    fontSize = edge.label.fontSize ?? fontSize;
+    color = edge.label.color ?? color;
+  }
+  if (!text) return "";
+  const midX = (sx + tx) / 2 + offsetX;
+  const midY = (sy + ty) / 2 + offsetY;
+  return `<text x="${midX}" y="${midY}" fill="${color}" font-size="${fontSize}" text-anchor="middle" dominant-baseline="auto" font-family="sans-serif">${escapeXml(text)}</text>`;
+}
+
+// src/svg/renderer.ts
+function renderToSvg(metadata, elements, options = {}) {
+  const padding = options.padding ?? 0;
+  const width = (metadata?.width ?? 800) + padding * 2;
+  const height = (metadata?.height ?? 600) + padding * 2;
+  const background = options.background ?? metadata?.background ?? "#ffffff";
+  const nodes = [];
+  const edges = [];
+  for (const el of elements) {
+    if (el.type === "node") nodes.push(el);
+    else if (el.type === "edge") edges.push(el);
+  }
+  const nodeLookup = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeLookup.set(node.id, node);
+  }
+  const sortedElements = [...elements].sort((a, b) => (a.zIndex ?? 0) - (b.zIndex ?? 0));
+  const hasArrowheads = edges.some((e) => {
+    const style = e.style ?? {};
+    return style.arrowheadEnd === true || style.arrowheadStart === true || style.markerEnd === "arrow" || style.markerStart === "arrow";
+  });
+  const parts = [];
+  parts.push(`<?xml version="1.0" encoding="UTF-8"?>`);
+  parts.push(
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${-padding} ${-padding} ${width} ${height}">`
+  );
+  if (hasArrowheads) {
+    parts.push(`  ${generateMarkerDefs()}`);
+  }
+  parts.push(`  <rect x="${-padding}" y="${-padding}" width="${width}" height="${height}" fill="${escapeXml(background)}"/>`);
+  for (const el of sortedElements) {
+    if (el.type === "node") {
+      const node = el;
+      parts.push(`  ${renderNodeShape(node)}`);
+      const textSvg = renderNodeText(node);
+      if (textSvg) parts.push(`  ${textSvg}`);
+    } else if (el.type === "edge") {
+      const edge = el;
+      parts.push(`  ${renderEdge(edge, nodeLookup)}`);
+    }
+  }
+  parts.push(`</svg>`);
+  return parts.join("\n");
+}
+function computeBoundingBox(elements) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const el of elements) {
+    if (el.type === "node") {
+      const node = el;
+      const size = node.size ?? { width: 100, height: 60 };
+      minX = Math.min(minX, node.position.x);
+      minY = Math.min(minY, node.position.y);
+      maxX = Math.max(maxX, node.position.x + size.width);
+      maxY = Math.max(maxY, node.position.y + size.height);
+    }
+  }
+  if (minX === Infinity) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0, width: 0, height: 0 };
+  }
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+
+// src/commands/inspect.ts
+function registerInspectCommand(program2) {
+  program2.command("inspect <file>").description("Show structured summary of a .drawit file").option("--format <format>", "Output format: text or json", "text").option("--elements", "List all element IDs").option("--stdin", "Read from stdin instead of file").action((file, opts) => {
+    try {
+      const content = readInput(opts.stdin ? "-" : file);
+      const result = parseDiagram(content, false);
+      const shapeBreakdown = {};
+      for (const node of result.nodes) {
+        const shape = node.shape ?? "rectangle";
+        shapeBreakdown[shape] = (shapeBreakdown[shape] ?? 0) + 1;
+      }
+      const zIndices = result.elements.map((e) => e.zIndex ?? 0);
+      const minZ = zIndices.length > 0 ? Math.min(...zIndices) : 0;
+      const maxZ = zIndices.length > 0 ? Math.max(...zIndices) : 0;
+      const bbox = computeBoundingBox(result.elements);
+      const connections = result.edges.map((e) => ({
+        id: e.id,
+        source: e.source,
+        target: e.target
+      }));
+      if (opts.format === "json") {
+        const output = {
+          metadata: result.metadata,
+          elementCount: result.elements.length,
+          nodeCount: result.nodes.length,
+          edgeCount: result.edges.length,
+          shapeBreakdown,
+          zIndexRange: { min: minZ, max: maxZ },
+          boundingBox: bbox,
+          connections,
+          errors: result.errors,
+          ...opts.elements ? { elementIds: result.elements.map((e) => ({ id: e.id, type: e.type })) } : {}
+        };
+        process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+      } else {
+        const lines = [];
+        lines.push(formatHeader("Canvas"));
+        if (result.metadata) {
+          lines.push(formatKV("Dimensions", `${result.metadata.width} x ${result.metadata.height}`, 2));
+          lines.push(formatKV("Background", result.metadata.background, 2));
+          if (result.metadata.metadata?.name) {
+            lines.push(formatKV("Name", result.metadata.metadata.name, 2));
+          }
+          if (result.metadata.metadata?.diagramType) {
+            lines.push(formatKV("Type", result.metadata.metadata.diagramType, 2));
+          }
+        } else {
+          lines.push("  (no metadata found)");
+        }
+        lines.push(formatHeader("Elements"));
+        lines.push(formatCount("Nodes", result.nodes.length));
+        lines.push(formatCount("Edges", result.edges.length));
+        lines.push(formatCount("Total", result.elements.length));
+        if (Object.keys(shapeBreakdown).length > 0) {
+          lines.push(formatHeader("Shapes"));
+          for (const [shape, count] of Object.entries(shapeBreakdown).sort((a, b) => b[1] - a[1])) {
+            lines.push(formatCount(shape, count));
+          }
+        }
+        lines.push(formatHeader("Layout"));
+        lines.push(formatKV("Z-index range", `${minZ} to ${maxZ}`, 2));
+        if (bbox.width > 0) {
+          lines.push(formatKV("Bounding box", `(${bbox.minX}, ${bbox.minY}) to (${bbox.maxX}, ${bbox.maxY})`, 2));
+          lines.push(formatKV("Content size", `${bbox.width} x ${bbox.height}`, 2));
+        }
+        if (connections.length > 0) {
+          lines.push(formatHeader("Connections"));
+          for (const conn of connections) {
+            lines.push(`  ${conn.source} -> ${conn.target}  [${conn.id}]`);
+          }
+        }
+        if (opts.elements) {
+          lines.push(formatHeader("Element IDs"));
+          for (const el of result.elements) {
+            const extra = el.type === "node" ? ` (${el.shape ?? "rectangle"})` : ` (${el.type})`;
+            lines.push(`  ${el.id}${extra}`);
+          }
+        }
+        if (result.errors.length > 0) {
+          lines.push(formatHeader("Warnings"));
+          lines.push(`  ${result.errors.length} parse error(s) found`);
+        }
+        process.stdout.write(lines.join("\n") + "\n");
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/export.ts
+function registerExportCommand(program2) {
+  program2.command("export <file>").description("Export a .drawit file to SVG, JSON, or NDJSON").requiredOption("--format <format>", "Export format: svg, json, or ndjson").option("--output <path>", "Output file path (default: stdout)").option("--padding <px>", "Padding around the diagram (SVG only)", "0").option("--background <color>", "Override background color (SVG only)").option("--stdin", "Read from stdin instead of file").action(
+    (file, opts) => {
+      try {
+        const content = readInput(opts.stdin ? "-" : file);
+        const result = parseDiagram(content, false);
+        if (result.errors.length > 0) {
+          process.stderr.write(
+            `Warning: ${result.errors.length} parse error(s) found. Output may be incomplete.
+`
+          );
+        }
+        let output;
+        switch (opts.format) {
+          case "svg":
+            output = renderToSvg(result.metadata, result.elements, {
+              padding: parseInt(opts.padding, 10),
+              background: opts.background
+            });
+            break;
+          case "json": {
+            const jsonOutput = {
+              metadata: result.metadata,
+              elements: result.elements
+            };
+            output = JSON.stringify(jsonOutput, null, 2);
+            break;
+          }
+          case "ndjson": {
+            const lines = [];
+            if (result.metadata) {
+              lines.push(JSON.stringify(result.metadata));
+            }
+            for (const el of result.elements) {
+              lines.push(JSON.stringify(el));
+            }
+            output = lines.join("\n") + "\n";
+            break;
+          }
+          default:
+            process.stderr.write(`Unsupported format: ${opts.format}. Use svg, json, or ndjson.
+`);
+            process.exitCode = 1;
+            return;
+        }
+        writeOutput(output, opts.output);
+      } catch (err) {
+        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+
+// src/commands/create.ts
+var TEMPLATES = {
+  blank: () => [],
+  flowchart: () => [
+    '{"id":"start","type":"node","position":{"x":340,"y":40},"size":{"width":120,"height":60},"shape":"rectangle","constrainAspectRatio":false,"angle":0,"zIndex":1,"style":{"fillStyle":"#10B981","strokeStyle":"#059669","lineWidth":2,"fillOpacity":1,"strokeOpacity":1,"cornerRadii":{"topLeft":8,"topRight":8,"bottomRight":8,"bottomLeft":8}},"text":{"content":"Start","fontSize":16,"fontFamily":"geist","color":"#FFFFFF","textAlign":"center","verticalAlign":"middle"},"metadata":{}}',
+    '{"id":"process","type":"node","position":{"x":340,"y":160},"size":{"width":120,"height":60},"shape":"rectangle","constrainAspectRatio":false,"angle":0,"zIndex":1,"style":{"fillStyle":"#3B82F6","strokeStyle":"#1E40AF","lineWidth":2,"fillOpacity":1,"strokeOpacity":1,"cornerRadii":{"topLeft":8,"topRight":8,"bottomRight":8,"bottomLeft":8}},"text":{"content":"Process","fontSize":16,"fontFamily":"geist","color":"#FFFFFF","textAlign":"center","verticalAlign":"middle"},"metadata":{}}',
+    '{"id":"end","type":"node","position":{"x":340,"y":280},"size":{"width":120,"height":60},"shape":"rectangle","constrainAspectRatio":false,"angle":0,"zIndex":1,"style":{"fillStyle":"#EF4444","strokeStyle":"#DC2626","lineWidth":2,"fillOpacity":1,"strokeOpacity":1,"cornerRadii":{"topLeft":8,"topRight":8,"bottomRight":8,"bottomLeft":8}},"text":{"content":"End","fontSize":16,"fontFamily":"geist","color":"#FFFFFF","textAlign":"center","verticalAlign":"middle"},"metadata":{}}',
+    '{"id":"edge1","type":"edge","source":"start","target":"process","zIndex":0,"style":{"strokeStyle":"#64748B","strokeOpacity":1,"lineWidth":2,"routing":"orthogonal","cornerRadius":8,"arrowheadEnd":true},"metadata":{}}',
+    '{"id":"edge2","type":"edge","source":"process","target":"end","zIndex":0,"style":{"strokeStyle":"#64748B","strokeOpacity":1,"lineWidth":2,"routing":"orthogonal","cornerRadius":8,"arrowheadEnd":true},"metadata":{}}'
+  ]
+};
+function registerCreateCommand(program2) {
+  program2.command("create <file>").description("Scaffold a new .drawit file with metadata").option("--width <px>", "Canvas width", "800").option("--height <px>", "Canvas height", "600").option("--background <color>", "Background color", "#ffffff").option("--name <name>", "Diagram name").option("--type <type>", "Diagram type (e.g., flowchart, technical)").option("--template <name>", "Template: blank, flowchart", "blank").option("--stdout", "Output to stdout instead of file").action(
+    (file, opts) => {
+      try {
+        const metadata = {
+          width: parseInt(opts.width, 10),
+          height: parseInt(opts.height, 10),
+          background: opts.background,
+          metadata: {
+            ...opts.name ? { name: opts.name } : {},
+            ...opts.type ? { diagramType: opts.type } : {}
+          }
+        };
+        const templateFn = TEMPLATES[opts.template];
+        if (!templateFn) {
+          process.stderr.write(
+            `Unknown template: ${opts.template}. Available: ${Object.keys(TEMPLATES).join(", ")}
+`
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const lines = [JSON.stringify(metadata), ...templateFn()];
+        const content = lines.join("\n") + "\n";
+        writeOutput(content, opts.stdout ? void 0 : file);
+        if (!opts.stdout) {
+          process.stdout.write(`Created ${file}
+`);
+        }
+      } catch (err) {
+        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+
+// src/commands/merge.ts
+function registerMergeCommand(program2) {
+  program2.command("merge <files...>").description("Combine multiple .drawit files with automatic layout").option("--output <path>", "Output file path (default: stdout)", "-").option("--layout <direction>", "Layout direction: horizontal or vertical", "horizontal").option("--gap <px>", "Gap between merged diagrams", "100").action((files, opts) => {
+    try {
+      if (files.length < 2) {
+        process.stderr.write("Merge requires at least two input files.\n");
+        process.exitCode = 1;
+        return;
+      }
+      const gap = parseInt(opts.gap, 10);
+      const isHorizontal = opts.layout === "horizontal";
+      let offsetX = 0;
+      let offsetY = 0;
+      let totalWidth = 0;
+      let totalHeight = 0;
+      const allElements = [];
+      const usedIds = /* @__PURE__ */ new Set();
+      let firstMetadata = null;
+      for (const file of files) {
+        const content = readInput(file);
+        const parsed = parseDiagram(content, false);
+        if (!firstMetadata && parsed.metadata) {
+          firstMetadata = parsed.metadata;
+        }
+        const bbox = computeBoundingBox(parsed.elements);
+        for (const el of parsed.elements) {
+          let id = el.id;
+          let suffix = 1;
+          while (usedIds.has(id)) {
+            id = `${el.id}_${suffix++}`;
+          }
+          usedIds.add(id);
+          if (el.type === "node") {
+            const node = el;
+            const offsetNode = {
+              ...node,
+              id,
+              position: {
+                x: node.position.x + offsetX,
+                y: node.position.y + offsetY
+              }
+            };
+            allElements.push(offsetNode);
+          } else {
+            allElements.push({ ...el, id });
+          }
+        }
+        if (isHorizontal) {
+          offsetX += (bbox.width > 0 ? bbox.maxX - (bbox.minX < 0 ? bbox.minX : 0) : parsed.metadata?.width ?? 800) + gap;
+          totalWidth = offsetX - gap;
+          totalHeight = Math.max(totalHeight, bbox.height > 0 ? bbox.maxY : parsed.metadata?.height ?? 600);
+        } else {
+          offsetY += (bbox.height > 0 ? bbox.maxY - (bbox.minY < 0 ? bbox.minY : 0) : parsed.metadata?.height ?? 600) + gap;
+          totalHeight = offsetY - gap;
+          totalWidth = Math.max(totalWidth, bbox.width > 0 ? bbox.maxX : parsed.metadata?.width ?? 800);
+        }
+      }
+      const metadata = {
+        width: totalWidth,
+        height: totalHeight,
+        background: firstMetadata?.background ?? "#ffffff",
+        metadata: { name: "Merged Diagram", diagramType: "merged" }
+      };
+      const lines = [JSON.stringify(metadata)];
+      for (const el of allElements) {
+        lines.push(JSON.stringify(el));
+      }
+      writeOutput(lines.join("\n") + "\n", opts.output === "-" ? void 0 : opts.output);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/map.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var import_node_child_process = require("child_process");
+
+// src/utils/code-analyzer.ts
+var import_node_fs2 = require("fs");
+var import_node_path = require("path");
+var IMPORT_REGEX = /^\s*import\s+(?:(?:[\w*{][^'"]*)\s+from\s+)?['"]([^'"]+)['"]/gm;
+var EXPORT_FROM_REGEX = /^\s*export\s+(?:\{[^}]*\}|\*(?:\s+as\s+\w+)?)\s+from\s+['"]([^'"]+)['"]/gm;
+var REQUIRE_REGEX = /(?:^|[^.])\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
+function sanitizeId(relativePath) {
+  return "f_" + relativePath.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function walkDir(current, root, depth, options, results) {
+  if (depth > options.maxDepth) return;
+  let entries;
+  try {
+    entries = (0, import_node_fs2.readdirSync)(current, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = (0, import_node_path.join)(current, entry.name);
+    const relFromRoot = (0, import_node_path.relative)(root, fullPath);
+    if (entry.name.startsWith(".")) continue;
+    if (isExcluded(entry.name, relFromRoot, options.excludePatterns)) continue;
+    if (entry.isDirectory()) {
+      walkDir(fullPath, root, depth + 1, options, results);
+    } else if (entry.isFile()) {
+      const ext = (0, import_node_path.extname)(entry.name);
+      if (options.includeExtensions.includes(ext)) {
+        results.push(fullPath);
+      }
+    }
+  }
+}
+function isExcluded(name, relPath, patterns) {
+  for (const pattern of patterns) {
+    if (name === pattern) return true;
+    if (relPath === pattern || relPath.startsWith(pattern + "/")) return true;
+  }
+  return false;
+}
+function extractImportPaths(content) {
+  const paths = [];
+  let match;
+  IMPORT_REGEX.lastIndex = 0;
+  while ((match = IMPORT_REGEX.exec(content)) !== null) {
+    paths.push(match[1]);
+  }
+  EXPORT_FROM_REGEX.lastIndex = 0;
+  while ((match = EXPORT_FROM_REGEX.exec(content)) !== null) {
+    paths.push(match[1]);
+  }
+  REQUIRE_REGEX.lastIndex = 0;
+  while ((match = REQUIRE_REGEX.exec(content)) !== null) {
+    paths.push(match[1]);
+  }
+  return [...new Set(paths)];
+}
+function resolveLocalImport(fromFile, importPath, pathToId, extensions) {
+  const base = (0, import_node_path.resolve)((0, import_node_path.dirname)(fromFile), importPath);
+  const candidates = [
+    base,
+    ...extensions.map((ext) => base + ext),
+    ...extensions.map((ext) => (0, import_node_path.join)(base, "index" + ext))
+  ];
+  for (const candidate of candidates) {
+    const id = pathToId.get(candidate);
+    if (id !== void 0) {
+      return id;
+    }
+  }
+  return null;
+}
+function analyzeCodebase(rootDir, options) {
+  const absolutePaths = [];
+  walkDir(rootDir, rootDir, 0, options, absolutePaths);
+  const pathToId = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const absPath of absolutePaths) {
+    const rel = (0, import_node_path.relative)(rootDir, absPath);
+    const id = sanitizeId(rel);
+    pathToId.set(absPath, id);
+    const parentRel = (0, import_node_path.relative)(rootDir, (0, import_node_path.dirname)(absPath));
+    entries.push({
+      id,
+      absolutePath: absPath,
+      relativePath: rel,
+      fileName: (0, import_node_path.basename)(absPath),
+      dirPath: parentRel || ".",
+      imports: [],
+      ext: (0, import_node_path.extname)(absPath),
+      x: 0,
+      y: 0
+    });
+  }
+  for (const entry of entries) {
+    try {
+      const content = (0, import_node_fs2.readFileSync)(entry.absolutePath, "utf-8");
+      const rawImports = extractImportPaths(content);
+      for (const importPath of rawImports) {
+        if (!importPath.startsWith("./") && !importPath.startsWith("../")) continue;
+        const resolvedId = resolveLocalImport(
+          entry.absolutePath,
+          importPath,
+          pathToId,
+          options.includeExtensions
+        );
+        if (resolvedId && !entry.imports.includes(resolvedId)) {
+          entry.imports.push(resolvedId);
+        }
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function sanitizeDirId(relativePath) {
+  return "d_" + (relativePath === "." ? "root" : relativePath.replace(/[^a-zA-Z0-9]/g, "_"));
+}
+function dominantExtFrom(extCounts) {
+  let best = "";
+  let bestCount = 0;
+  for (const [ext, count] of extCounts) {
+    if (count > bestCount) {
+      bestCount = count;
+      best = ext;
+    }
+  }
+  return best || ".ts";
+}
+function buildDirNode(current, root, depth, options, parentId) {
+  if (depth > options.maxDepth) return null;
+  const relPath = (0, import_node_path.relative)(root, current) || ".";
+  const name = depth === 0 ? (0, import_node_path.basename)(current) : (0, import_node_path.basename)(current);
+  const id = sanitizeDirId(relPath);
+  let entries;
+  try {
+    entries = (0, import_node_fs2.readdirSync)(current, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let fileCount = 0;
+  const extCounts = /* @__PURE__ */ new Map();
+  const children = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const fullPath = (0, import_node_path.join)(current, entry.name);
+    const relFromRoot = (0, import_node_path.relative)(root, fullPath);
+    if (isExcluded(entry.name, relFromRoot, options.excludePatterns)) continue;
+    if (entry.isDirectory()) {
+      const child = buildDirNode(fullPath, root, depth + 1, options, id);
+      if (child && child.totalFileCount > 0) {
+        children.push(child);
+        for (const [ext, count] of Object.entries(
+          Object.fromEntries(
+            child.totalFileCount > 0 ? [[child.dominantExt, child.totalFileCount]] : []
+          )
+        )) {
+          extCounts.set(ext, (extCounts.get(ext) ?? 0) + count);
+        }
+      }
+    } else if (entry.isFile()) {
+      const ext = (0, import_node_path.extname)(entry.name);
+      if (options.includeExtensions.includes(ext)) {
+        fileCount++;
+        extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+      }
+    }
+  }
+  const totalFileCount = fileCount + children.reduce((s, c) => s + c.totalFileCount, 0);
+  return {
+    id,
+    name,
+    relativePath: relPath,
+    depth,
+    fileCount,
+    totalFileCount,
+    children,
+    dominantExt: dominantExtFrom(extCounts),
+    parentId,
+    x: 0,
+    y: 0
+  };
+}
+function analyzeStructure(rootDir, options) {
+  const root = buildDirNode(rootDir, rootDir, 0, options, null);
+  if (!root) {
+    return {
+      id: "d_root",
+      name: (0, import_node_path.basename)(rootDir),
+      relativePath: ".",
+      depth: 0,
+      fileCount: 0,
+      totalFileCount: 0,
+      children: [],
+      dominantExt: ".ts",
+      parentId: null,
+      x: 0,
+      y: 0
+    };
+  }
+  return root;
+}
+function quickCountFiles(rootDir, options, earlyExitThreshold = 1e3) {
+  let count = 0;
+  function walk(current, depth) {
+    if (depth > options.maxDepth || count > earlyExitThreshold) return;
+    let entries;
+    try {
+      entries = (0, import_node_fs2.readdirSync)(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (count > earlyExitThreshold) return;
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = (0, import_node_path.join)(current, entry.name);
+      const relFromRoot = (0, import_node_path.relative)(rootDir, fullPath);
+      if (isExcluded(entry.name, relFromRoot, options.excludePatterns)) continue;
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        const ext = (0, import_node_path.extname)(entry.name);
+        if (options.includeExtensions.includes(ext)) count++;
+      }
+    }
+  }
+  walk(rootDir, 0);
+  return count;
+}
+function parseIncludeExtensions(pattern) {
+  const braceMatch = pattern.match(/\{([^}]+)\}/);
+  if (braceMatch) {
+    return braceMatch[1].split(",").map((e) => `.${e.trim()}`);
+  }
+  const extMatch = pattern.match(/\*(\.\w+)$/);
+  if (extMatch) return [extMatch[1]];
+  return [".ts", ".tsx", ".js", ".jsx"];
+}
+
+// src/utils/map-layout.ts
+var NODE_W = 190;
+var NODE_H = 48;
+var NODE_GAP_X = 14;
+var NODE_GAP_Y = 10;
+var NODES_PER_ROW = 3;
+var GROUP_PAD = 24;
+var GROUP_HEADER = 30;
+var GROUP_GAP_X = 40;
+var GROUP_GAP_Y = 36;
+var GROUPS_PER_COL = 4;
+var CANVAS_PAD = 60;
+var MIN_CANVAS_W = 1200;
+var MIN_CANVAS_H = 800;
+function layoutGroups(files) {
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = f.dirPath;
+    if (!groupMap.has(dir)) groupMap.set(dir, []);
+    groupMap.get(dir).push(f);
+  }
+  const sortedDirs = [...groupMap.keys()].sort((a, b) => {
+    if (a === ".") return -1;
+    if (b === ".") return 1;
+    return a.localeCompare(b);
+  });
+  const groups = sortedDirs.map((dir) => {
+    const groupFiles = groupMap.get(dir);
+    const N = groupFiles.length;
+    const cols = Math.min(N, NODES_PER_ROW);
+    const rows = Math.ceil(N / NODES_PER_ROW);
+    const innerW = cols * NODE_W + (cols - 1) * NODE_GAP_X;
+    const innerH = rows * NODE_H + (rows - 1) * NODE_GAP_Y;
+    return {
+      dirId: dir === "." ? "root" : dir.replace(/[^a-zA-Z0-9]/g, "_"),
+      label: dir === "." ? "/ (root)" : dir,
+      files: groupFiles,
+      x: 0,
+      y: 0,
+      w: innerW + GROUP_PAD * 2,
+      h: innerH + GROUP_PAD * 2 + GROUP_HEADER
+    };
+  });
+  const columns = [];
+  let currentCol = [];
+  for (const g of groups) {
+    if (currentCol.length >= GROUPS_PER_COL) {
+      columns.push(currentCol);
+      currentCol = [];
+    }
+    currentCol.push(g);
+  }
+  if (currentCol.length > 0) columns.push(currentCol);
+  let curX = CANVAS_PAD;
+  let maxY = CANVAS_PAD;
+  for (const column of columns) {
+    const colW = Math.max(...column.map((g) => g.w));
+    let curY = CANVAS_PAD;
+    for (const g of column) {
+      g.x = curX;
+      g.y = curY;
+      curY += g.h + GROUP_GAP_Y;
+    }
+    maxY = Math.max(maxY, curY - GROUP_GAP_Y);
+    curX += colW + GROUP_GAP_X;
+  }
+  const canvasW = Math.max(MIN_CANVAS_W, curX - GROUP_GAP_X + CANVAS_PAD);
+  const canvasH = Math.max(MIN_CANVAS_H, maxY + CANVAS_PAD);
+  for (const g of groups) {
+    g.files.forEach((f, i) => {
+      const col = i % NODES_PER_ROW;
+      const row = Math.floor(i / NODES_PER_ROW);
+      f.x = g.x + GROUP_PAD + col * (NODE_W + NODE_GAP_X);
+      f.y = g.y + GROUP_HEADER + GROUP_PAD + row * (NODE_H + NODE_GAP_Y);
+    });
+  }
+  return { groups, canvasW, canvasH };
+}
+var DIR_W = 260;
+var DIR_H = 72;
+var X_STEP = 340;
+var DIR_Y_GAP = 20;
+var DIR_CANVAS_PAD = 80;
+var DIR_MIN_W = 1400;
+var DIR_MIN_H = 900;
+function assignY(node, slotStart) {
+  if (node.children.length === 0) {
+    node.y = DIR_CANVAS_PAD + slotStart * (DIR_H + DIR_Y_GAP);
+    return slotStart + 1;
+  }
+  let slot = slotStart;
+  const firstChildY_ref = { y: 0 };
+  let lastChildY = 0;
+  let first = true;
+  for (const child of node.children) {
+    if (first) {
+    }
+    slot = assignY(child, slot);
+    if (first) {
+      firstChildY_ref.y = child.y;
+      first = false;
+    }
+    lastChildY = child.y;
+  }
+  node.y = (firstChildY_ref.y + lastChildY) / 2;
+  return slot;
+}
+function layoutTree(root) {
+  function assignX(node) {
+    node.x = DIR_CANVAS_PAD + node.depth * X_STEP;
+    for (const child of node.children) assignX(child);
+  }
+  assignX(root);
+  assignY(root, 0);
+  const nodes = [];
+  const edges = [];
+  function collect(node) {
+    nodes.push(node);
+    for (const child of node.children) {
+      edges.push({ source: node.id, target: child.id });
+      collect(child);
+    }
+  }
+  collect(root);
+  const maxDepth = Math.max(...nodes.map((n) => n.depth));
+  const maxY = Math.max(...nodes.map((n) => n.y));
+  const canvasW = Math.max(DIR_MIN_W, DIR_CANVAS_PAD + (maxDepth + 1) * X_STEP + DIR_CANVAS_PAD);
+  const canvasH = Math.max(DIR_MIN_H, maxY + DIR_H + DIR_CANVAS_PAD);
+  return { nodes, canvasW, canvasH, edges };
+}
+
+// src/commands/map.ts
+var DEFAULT_EXCLUDE = "node_modules,dist,build,.next,.git,out,coverage,.turbo";
+var AUTO_THRESHOLD = 80;
+function makeAnalyzeOptions(opts) {
+  return {
+    maxDepth: parseInt(opts.depth, 10),
+    excludePatterns: opts.exclude.split(",").map((s) => s.trim()).filter(Boolean),
+    includeExtensions: parseIncludeExtensions(opts.include)
+  };
+}
+function tryOpenInVSCode(path) {
+  try {
+    (0, import_node_child_process.execSync)(`code "${path}"`, { stdio: "ignore" });
+  } catch {
+    process.stderr.write(
+      `Could not open in VS Code automatically.
+  Open manually: code "${path}"
+`
+    );
+  }
+}
+function getFileNodeStyle(ext, fileName) {
+  if (fileName.includes(".test.") || fileName.includes(".spec.")) {
+    return { fillStyle: "#78350f", strokeStyle: "#d97706" };
+  }
+  if ([".json", ".yaml", ".yml", ".toml", ".env"].includes(ext)) {
+    return { fillStyle: "#1e1b4b", strokeStyle: "#7c3aed" };
+  }
+  switch (ext) {
+    case ".tsx":
+    case ".jsx":
+      return { fillStyle: "#0c4a6e", strokeStyle: "#0ea5e9" };
+    case ".ts":
+      return { fillStyle: "#1e3a5f", strokeStyle: "#3b82f6" };
+    case ".js":
+      return { fillStyle: "#422006", strokeStyle: "#f59e0b" };
+    default:
+      return { fillStyle: "#1e293b", strokeStyle: "#64748b" };
+  }
+}
+function buildFilesDiagramLines(files, groups, canvasW, canvasH, rootDirName, drawEdges) {
+  const lines = [];
+  lines.push(
+    JSON.stringify({
+      width: canvasW,
+      height: canvasH,
+      background: "#0f172a",
+      metadata: {
+        name: `${rootDirName} - Code Map`,
+        diagramType: "code-map",
+        mode: "files",
+        generatedAt: Date.now(),
+        fileCount: files.length
+      }
+    })
+  );
+  for (const group of groups) {
+    lines.push(
+      JSON.stringify({
+        id: `grp_${group.dirId}`,
+        type: "node",
+        position: { x: group.x, y: group.y },
+        size: { width: group.w, height: group.h },
+        shape: "rectangle",
+        zIndex: 1,
+        constrainAspectRatio: false,
+        angle: 0,
+        style: {
+          fillStyle: "#0f2744",
+          strokeStyle: "#1e4080",
+          lineWidth: 1,
+          fillOpacity: 0.85,
+          strokeOpacity: 1,
+          cornerRadii: { topLeft: 8, topRight: 8, bottomRight: 8, bottomLeft: 8 }
+        },
+        text: {
+          content: group.label,
+          fontSize: 11,
+          fontFamily: "geist",
+          color: "#94a3b8",
+          textAlign: "left",
+          verticalAlign: "top"
+        },
+        metadata: { isGroupBox: true, dirPath: group.label }
+      })
+    );
+    for (const file of group.files) {
+      const style = getFileNodeStyle(file.ext, file.fileName);
+      lines.push(
+        JSON.stringify({
+          id: file.id,
+          type: "node",
+          position: { x: file.x, y: file.y },
+          size: { width: NODE_W, height: NODE_H },
+          shape: "rectangle",
+          zIndex: 2,
+          constrainAspectRatio: false,
+          angle: 0,
+          style: {
+            ...style,
+            lineWidth: 1,
+            fillOpacity: 1,
+            strokeOpacity: 1,
+            cornerRadii: { topLeft: 4, topRight: 4, bottomRight: 4, bottomLeft: 4 }
+          },
+          text: {
+            content: file.fileName,
+            fontSize: 11,
+            fontFamily: "geist",
+            color: "#e2e8f0",
+            textAlign: "center",
+            verticalAlign: "middle"
+          },
+          metadata: { filePath: file.relativePath, ext: file.ext }
+        })
+      );
+    }
+  }
+  if (drawEdges) {
+    const fileIdSet = new Set(files.map((f) => f.id));
+    let edgeCounter = 0;
+    for (const file of files) {
+      for (const importId of file.imports) {
+        if (fileIdSet.has(importId)) {
+          lines.push(
+            JSON.stringify({
+              id: `e_${edgeCounter++}`,
+              type: "edge",
+              source: file.id,
+              target: importId,
+              zIndex: 0,
+              style: { strokeStyle: "#334155", lineWidth: 1, arrowheadEnd: true, strokeOpacity: 0.55 },
+              metadata: {}
+            })
+          );
+        }
+      }
+    }
+  }
+  return lines;
+}
+function getDirNodeStyle(dominantExt) {
+  switch (dominantExt) {
+    case ".tsx":
+    case ".jsx":
+      return { fillStyle: "#0c3d5e", strokeStyle: "#0ea5e9" };
+    case ".ts":
+      return { fillStyle: "#1a2f52", strokeStyle: "#3b82f6" };
+    case ".js":
+      return { fillStyle: "#3d1f00", strokeStyle: "#f59e0b" };
+    default:
+      return { fillStyle: "#1a2040", strokeStyle: "#6366f1" };
+  }
+}
+function buildDirsDiagramLines(nodes, edges, canvasW, canvasH, rootDirName) {
+  const lines = [];
+  const totalFiles = nodes[0]?.totalFileCount ?? 0;
+  lines.push(
+    JSON.stringify({
+      width: canvasW,
+      height: canvasH,
+      background: "#0a0f1e",
+      metadata: {
+        name: `${rootDirName} - Architecture Map`,
+        diagramType: "code-map-dirs",
+        mode: "dirs",
+        generatedAt: Date.now(),
+        directoryCount: nodes.length,
+        fileCount: totalFiles
+      }
+    })
+  );
+  for (const node of nodes) {
+    const style = getDirNodeStyle(node.dominantExt);
+    const label = node.relativePath === "." ? rootDirName : node.name;
+    const sublabel = node.totalFileCount === 1 ? "1 file" : `${node.totalFileCount} files`;
+    lines.push(
+      JSON.stringify({
+        id: node.id,
+        type: "node",
+        position: { x: node.x, y: node.y },
+        size: { width: DIR_W, height: DIR_H },
+        shape: "rectangle",
+        zIndex: node.depth + 1,
+        constrainAspectRatio: false,
+        angle: 0,
+        style: {
+          ...style,
+          lineWidth: 1.5,
+          fillOpacity: 1,
+          strokeOpacity: 1,
+          cornerRadii: { topLeft: 12, topRight: 12, bottomRight: 12, bottomLeft: 12 }
+        },
+        text: {
+          content: `${label}
+${sublabel}`,
+          fontSize: 13,
+          fontFamily: "geist",
+          color: "#e2e8f0",
+          textAlign: "center",
+          verticalAlign: "middle"
+        },
+        metadata: {
+          dirPath: node.relativePath,
+          depth: node.depth,
+          dominantExt: node.dominantExt,
+          fileCount: node.fileCount,
+          totalFileCount: node.totalFileCount
+        }
+      })
+    );
+  }
+  let edgeCounter = 0;
+  for (const edge of edges) {
+    lines.push(
+      JSON.stringify({
+        id: `te_${edgeCounter++}`,
+        type: "edge",
+        source: edge.source,
+        target: edge.target,
+        zIndex: 0,
+        style: {
+          strokeStyle: "#1e3a5f",
+          lineWidth: 1.5,
+          arrowheadEnd: true,
+          strokeOpacity: 0.5
+        },
+        metadata: {}
+      })
+    );
+  }
+  return lines;
+}
+function runFilesMode(targetDir, analyzeOptions, outputPath, drawEdges) {
+  const files = analyzeCodebase(targetDir, analyzeOptions);
+  const dirCount = new Set(files.map((f) => f.dirPath)).size;
+  process.stderr.write(
+    `Found ${files.length} file${files.length === 1 ? "" : "s"} in ${dirCount} director${dirCount === 1 ? "y" : "ies"}.
+`
+  );
+  const { groups, canvasW, canvasH } = layoutGroups(files);
+  const lines = buildFilesDiagramLines(files, groups, canvasW, canvasH, (0, import_node_path2.basename)(targetDir), drawEdges);
+  writeOutput(lines.join("\n") + "\n", outputPath);
+}
+function runDirsMode(targetDir, analyzeOptions, outputPath, clusterDepth) {
+  const treeOptions = { ...analyzeOptions, maxDepth: clusterDepth };
+  const root = analyzeStructure(targetDir, treeOptions);
+  const { nodes, canvasW, canvasH, edges } = layoutTree(root);
+  process.stderr.write(
+    `Found ${nodes.length} director${nodes.length === 1 ? "y" : "ies"} (${root.totalFileCount} total files).
+`
+  );
+  const lines = buildDirsDiagramLines(nodes, edges, canvasW, canvasH, (0, import_node_path2.basename)(targetDir));
+  writeOutput(lines.join("\n") + "\n", outputPath);
+}
+function runSplitMode(targetDir, analyzeOptions, outputDir, drawEdges) {
+  (0, import_node_fs3.mkdirSync)(outputDir, { recursive: true });
+  const overviewPath = (0, import_node_path2.join)(outputDir, "overview.drawit");
+  const overviewOptions = { ...analyzeOptions, maxDepth: 2 };
+  const root = analyzeStructure(targetDir, overviewOptions);
+  const { nodes, canvasW, canvasH, edges } = layoutTree(root);
+  process.stderr.write(
+    `Overview: ${nodes.length} directories, ${root.totalFileCount} total files.
+`
+  );
+  const overviewLines = buildDirsDiagramLines(nodes, edges, canvasW, canvasH, (0, import_node_path2.basename)(targetDir));
+  writeOutput(overviewLines.join("\n") + "\n", overviewPath);
+  process.stderr.write(`  Generated: ${overviewPath}
+`);
+  let subdirEntries;
+  try {
+    subdirEntries = (0, import_node_fs3.readdirSync)(targetDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of subdirEntries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".")) continue;
+    if (analyzeOptions.excludePatterns.includes(entry.name)) continue;
+    const subdirPath = (0, import_node_path2.join)(targetDir, entry.name);
+    const subdirFiles = analyzeCodebase(subdirPath, analyzeOptions);
+    if (subdirFiles.length === 0) continue;
+    const { groups, canvasW: cW, canvasH: cH } = layoutGroups(subdirFiles);
+    const lines = buildFilesDiagramLines(subdirFiles, groups, cW, cH, entry.name, drawEdges);
+    const outPath = (0, import_node_path2.join)(outputDir, `${entry.name}.drawit`);
+    writeOutput(lines.join("\n") + "\n", outPath);
+    process.stderr.write(`  Generated: ${outPath} (${subdirFiles.length} files)
+`);
+  }
+}
+function registerMapCommand(program2) {
+  program2.command("map [path]").description(
+    "Analyze a codebase and generate a .drawit map (auto-scales: dirs mode for large repos)"
+  ).option("--output <file>", "Output file path (default: <dirname>-map.drawit)").option("--depth <n>", "Max directory depth to scan", "4").option("--include <pattern>", "File extensions to include", "**/*.{ts,tsx,js,jsx}").option("--exclude <patterns>", "Comma-separated names to exclude", DEFAULT_EXCLUDE).option("--no-edges", "Skip import dependency edges (files mode only)").option("--open", "Open generated file(s) in VS Code").option(
+    "--mode <auto|files|dirs>",
+    "Map mode: auto detects by file count, files=import graph, dirs=directory tree",
+    "auto"
+  ).option(
+    "--split",
+    "Generate one diagram per top-level subdir + an overview.drawit (outputs to <dirname>-map/ folder)"
+  ).option(
+    "--cluster-depth <n>",
+    "In dirs mode, max depth of directory nodes to show",
+    "4"
+  ).action((pathArg, opts) => {
+    try {
+      const targetDir = (0, import_node_path2.resolve)(pathArg ?? process.cwd());
+      if (!(0, import_node_fs3.existsSync)(targetDir) || !(0, import_node_fs3.statSync)(targetDir).isDirectory()) {
+        process.stderr.write(`Error: "${targetDir}" is not a directory.
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const maxDepth = parseInt(opts.depth, 10);
+      const clusterDepth = parseInt(opts.clusterDepth, 10);
+      if (isNaN(maxDepth) || maxDepth < 1) {
+        process.stderr.write(`Error: --depth must be a positive integer.
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const analyzeOptions = makeAnalyzeOptions(opts);
+      const dirName = (0, import_node_path2.basename)(targetDir);
+      process.stderr.write(`Scanning ${targetDir}...
+`);
+      if (opts.split) {
+        const outputDir = `${dirName}-map`;
+        process.stderr.write(`Split mode \u2192 ${outputDir}/
+`);
+        runSplitMode(targetDir, analyzeOptions, outputDir, opts.edges !== false);
+        process.stderr.write(`Done. Open overview: code "${(0, import_node_path2.join)(outputDir, "overview.drawit")}"
+`);
+        if (opts.open) tryOpenInVSCode((0, import_node_path2.join)(outputDir, "overview.drawit"));
+        process.exitCode = 0;
+        return;
+      }
+      let effectiveMode = opts.mode ?? "auto";
+      if (effectiveMode === "auto") {
+        const approxCount = quickCountFiles(targetDir, analyzeOptions);
+        effectiveMode = approxCount > AUTO_THRESHOLD ? "dirs" : "files";
+        process.stderr.write(
+          `Auto-selected mode: ${effectiveMode} (${approxCount > 1e3 ? "1000+" : approxCount} files found)
+`
+        );
+      }
+      const outputPath = opts.output ?? `${dirName}-map.drawit`;
+      if (effectiveMode === "dirs") {
+        runDirsMode(targetDir, analyzeOptions, outputPath, clusterDepth);
+      } else {
+        runFilesMode(targetDir, analyzeOptions, outputPath, opts.edges !== false);
+      }
+      process.stderr.write(`Generated: ${outputPath}  [${effectiveMode} mode]
+`);
+      if (opts.open) tryOpenInVSCode(outputPath);
+      process.exitCode = 0;
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/schema.ts
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
+var import_node_child_process2 = require("child_process");
+
+// src/utils/schema-parser.ts
+function parsePrismaSchema(content) {
+  const models = [];
+  const enums = /* @__PURE__ */ new Set();
+  const enumRegex = /^enum\s+(\w+)\s*\{[\s\S]*?\n\}/gm;
+  let enumMatch;
+  while ((enumMatch = enumRegex.exec(content)) !== null) {
+    enums.add(enumMatch[1]);
+  }
+  const modelRegex = /^model\s+(\w+)\s*\{([\s\S]*?)\n\}/gm;
+  let match;
+  while ((match = modelRegex.exec(content)) !== null) {
+    const modelName = match[1];
+    const block = match[2];
+    const fields = [];
+    const relations = [];
+    const lines = block.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@")) {
+        continue;
+      }
+      const parts = trimmed.split(/\s+/);
+      if (parts.length < 2) continue;
+      const fieldName = parts[0];
+      let typeStr = parts[1];
+      let isList = false;
+      let isRequired = true;
+      if (typeStr.endsWith("[]")) {
+        isList = true;
+        typeStr = typeStr.slice(0, -2);
+      } else if (typeStr.endsWith("?")) {
+        isRequired = false;
+        typeStr = typeStr.slice(0, -1);
+      }
+      const isId = parts.includes("@id");
+      const isPrimitive = /^(String|Int|Boolean|DateTime|Float|Json|Bytes|Decimal|BigInt)$/.test(typeStr);
+      const isRelation = !isPrimitive && /^[A-Z]/.test(typeStr) && !enums.has(typeStr);
+      fields.push({
+        name: fieldName,
+        type: typeStr,
+        isRequired,
+        isList,
+        isId,
+        isRelation
+      });
+      if (isRelation) {
+        relations.push({
+          fieldName,
+          targetModel: typeStr,
+          isList
+        });
+      }
+    }
+    models.push({
+      name: modelName,
+      fields,
+      relations
+    });
+  }
+  return models;
+}
+
+// src/commands/schema.ts
+var MODEL_W = 260;
+var MODEL_H_BASE = 36;
+var FIELD_H = 20;
+var MODELS_PER_COL = 3;
+var NODE_GAP_X2 = 60;
+var NODE_GAP_Y2 = 40;
+var CANVAS_PAD2 = 80;
+var MIN_CANVAS_W2 = 1e3;
+var MIN_CANVAS_H2 = 800;
+function tryOpenInVSCode2(path) {
+  try {
+    (0, import_node_child_process2.execSync)(`code "${path}"`, { stdio: "ignore" });
+  } catch {
+    process.stderr.write(
+      `Could not open in VS Code automatically.
+  Open manually: code "${path}"
+`
+    );
+  }
+}
+function assignLayout(models) {
+  const layoutModels = models.map((m) => ({
+    ...m,
+    x: 0,
+    y: 0,
+    w: MODEL_W,
+    h: MODEL_H_BASE + Math.min(m.fields.length, 8) * FIELD_H,
+    id: `m_${m.name}`
+  }));
+  const columns = [];
+  let currentCol = [];
+  for (const m of layoutModels) {
+    if (currentCol.length >= MODELS_PER_COL) {
+      columns.push(currentCol);
+      currentCol = [];
+    }
+    currentCol.push(m);
+  }
+  if (currentCol.length > 0) columns.push(currentCol);
+  let curX = CANVAS_PAD2;
+  let maxY = CANVAS_PAD2;
+  for (const col of columns) {
+    let curY = CANVAS_PAD2;
+    for (const m of col) {
+      m.x = curX;
+      m.y = curY;
+      curY += m.h + NODE_GAP_Y2;
+    }
+    maxY = Math.max(maxY, curY - NODE_GAP_Y2);
+    curX += MODEL_W + NODE_GAP_X2;
+  }
+  const canvasW = Math.max(MIN_CANVAS_W2, curX - NODE_GAP_X2 + CANVAS_PAD2);
+  const canvasH = Math.max(MIN_CANVAS_H2, maxY + CANVAS_PAD2);
+  return { layoutModels, canvasW, canvasH };
+}
+function buildDiagramLines(models, canvasW, canvasH, schemaName) {
+  const lines = [];
+  lines.push(
+    JSON.stringify({
+      width: canvasW,
+      height: canvasH,
+      background: "#0a0f1e",
+      metadata: {
+        name: schemaName,
+        diagramType: "schema",
+        generatedAt: Date.now(),
+        modelCount: models.length
+      }
+    })
+  );
+  const edgesOutput = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    for (const rel of model.relations) {
+      const targetModel = models.find((m) => m.name === rel.targetModel);
+      if (!targetModel) continue;
+      const sourceId = model.id;
+      const targetId = targetModel.id;
+      const relId = `rel_${model.name}_${targetModel.name}`;
+      const revRelId = `rel_${targetModel.name}_${model.name}`;
+      if (edgesOutput.has(revRelId)) continue;
+      edgesOutput.add(relId);
+      const targetRel = targetModel.relations.find((r) => r.targetModel === model.name);
+      const isOneToMany = rel.isList || targetRel && targetRel.isList;
+      lines.push(
+        JSON.stringify({
+          id: relId,
+          type: "edge",
+          source: sourceId,
+          target: targetId,
+          zIndex: 0,
+          label: { text: isOneToMany ? "1:N" : "1:1", fontSize: 10, color: "#94a3b8" },
+          style: {
+            strokeStyle: "#4c1d95",
+            lineWidth: 1.5,
+            arrowheadEnd: true,
+            strokeOpacity: 0.7
+          }
+        })
+      );
+    }
+    const maxLines = 8;
+    const fieldsToPrint = model.fields.slice(0, maxLines);
+    const hasMore = model.fields.length > maxLines;
+    const printedLines = fieldsToPrint.map((f) => {
+      let line = `${f.name}: ${f.type}${f.isList ? "[]" : ""}`;
+      if (!f.isRequired) line += "?";
+      if (f.isId) line += " @id";
+      return line;
+    });
+    if (hasMore) {
+      printedLines.push(`... +${model.fields.length - maxLines} more`);
+    }
+    const textContent = `${model.name}
+${"\u2500".repeat(model.name.length + 8)}
+${printedLines.join(
+      "\n"
+    )}`;
+    lines.push(
+      JSON.stringify({
+        id: model.id,
+        type: "node",
+        position: { x: model.x, y: model.y },
+        size: { width: model.w, height: model.h },
+        shape: "rectangle",
+        zIndex: 2,
+        style: {
+          fillStyle: "#1e1b4b",
+          strokeStyle: "#7c3aed",
+          lineWidth: 2,
+          fillOpacity: 1,
+          strokeOpacity: 1,
+          cornerRadii: { topLeft: 6, topRight: 6, bottomRight: 6, bottomLeft: 6 }
+        },
+        text: {
+          content: textContent,
+          fontSize: 12,
+          fontFamily: "monospace",
+          color: "#e2e8f0",
+          textAlign: "left",
+          verticalAlign: "top"
+        }
+      })
+    );
+  }
+  return lines;
+}
+function registerSchemaCommand(program2) {
+  program2.command("schema [file]").description("Generate an ER diagram from a Prisma schema").option("--output <path>", "Output file path (default: <filename>.drawit)").option("--open", "Open generated file in VS Code").action((fileArg, opts) => {
+    try {
+      let targetFile = fileArg;
+      if (!targetFile) {
+        const autoPath = (0, import_node_path3.resolve)(process.cwd(), "prisma/schema.prisma");
+        if ((0, import_node_fs4.existsSync)(autoPath)) {
+          targetFile = autoPath;
+        } else {
+          process.stderr.write(
+            `Error: Could not find prisma/schema.prisma and no file was provided.
+`
+          );
+          process.exitCode = 1;
+          return;
+        }
+      } else {
+        targetFile = (0, import_node_path3.resolve)(process.cwd(), targetFile);
+      }
+      if (!(0, import_node_fs4.existsSync)(targetFile)) {
+        process.stderr.write(`Error: file "${targetFile}" not found.
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const content = (0, import_node_fs4.readFileSync)(targetFile, "utf-8");
+      const models = parsePrismaSchema(content);
+      if (models.length === 0) {
+        process.stderr.write(`No models found in ${targetFile}.
+`);
+        process.exitCode = 0;
+        return;
+      }
+      const { layoutModels, canvasW, canvasH } = assignLayout(models);
+      const filenameWithoutExt = (0, import_node_path3.basename)(targetFile, ".prisma");
+      const lines = buildDiagramLines(layoutModels, canvasW, canvasH, filenameWithoutExt);
+      const outputPath = opts.output ?? `${filenameWithoutExt}.drawit`;
+      writeOutput(lines.join("\n") + "\n", outputPath);
+      process.stderr.write(`Generated ER diagram: ${outputPath}
+`);
+      if (opts.open) tryOpenInVSCode2(outputPath);
+      process.exitCode = 0;
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/deps.ts
+var import_node_fs6 = require("fs");
+var import_node_path5 = require("path");
+var import_node_child_process3 = require("child_process");
+
+// src/utils/deps-analyzer.ts
+var import_node_fs5 = require("fs");
+var import_node_path4 = require("path");
+function sanitizePackageId(name) {
+  return "p_" + name.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function analyzeDeps(rootDir, options) {
+  const packagePaths = [];
+  function walkDir2(current, depth) {
+    if (depth > options.maxDepth) return;
+    let entries;
+    try {
+      entries = (0, import_node_fs5.readdirSync)(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = (0, import_node_path4.join)(current, entry.name);
+      const relFromRoot = (0, import_node_path4.relative)(rootDir, fullPath);
+      if (isExcluded(entry.name, relFromRoot, options.excludePatterns)) continue;
+      if (entry.isDirectory()) {
+        walkDir2(fullPath, depth + 1);
+      } else if (entry.isFile() && entry.name === "package.json") {
+        packagePaths.push(fullPath);
+      }
+    }
+  }
+  walkDir2(rootDir, 0);
+  const rawPackages = [];
+  const workspaceNames = /* @__PURE__ */ new Set();
+  for (const pkgPath of packagePaths) {
+    try {
+      const content = (0, import_node_fs5.readFileSync)(pkgPath, "utf-8");
+      const json = JSON.parse(content);
+      if (json.name) {
+        workspaceNames.add(json.name);
+        rawPackages.push({ path: pkgPath, json });
+      }
+    } catch {
+    }
+  }
+  const nodes = [];
+  for (const pkg of rawPackages) {
+    const { path, json } = pkg;
+    const relDir = (0, import_node_path4.relative)(rootDir, (0, import_node_path4.dirname)(path));
+    const parts = relDir.split("/");
+    const groupDir = parts.length > 0 && parts[0] !== "" ? parts[0] : ".";
+    const deps = /* @__PURE__ */ new Set();
+    const allDeps = { ...json.dependencies || {} };
+    if (options.includeDev) {
+      Object.assign(allDeps, json.devDependencies || {});
+    }
+    for (const depName of Object.keys(allDeps)) {
+      if (options.workspaceOnly) {
+        if (workspaceNames.has(depName)) {
+          deps.add(depName);
+        }
+      } else {
+        deps.add(depName);
+      }
+    }
+    nodes.push({
+      id: sanitizePackageId(json.name),
+      name: json.name,
+      version: json.version || "0.0.0",
+      relativePath: relDir,
+      isWorkspace: true,
+      dependencies: Array.from(deps),
+      fileName: "package.json",
+      dirPath: groupDir,
+      ext: ".json",
+      x: 0,
+      y: 0
+    });
+  }
+  if (!options.workspaceOnly) {
+    const allKnownDeps = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      for (const d of node.dependencies) {
+        allKnownDeps.add(d);
+      }
+    }
+    for (const d of allKnownDeps) {
+      if (!workspaceNames.has(d)) {
+        nodes.push({
+          id: sanitizePackageId(d),
+          name: d,
+          version: "external",
+          relativePath: "node_modules/" + d,
+          isWorkspace: false,
+          dependencies: [],
+          fileName: "package.json",
+          dirPath: "external",
+          ext: ".json",
+          x: 0,
+          y: 0
+        });
+      }
+    }
+  }
+  return nodes;
+}
+
+// src/commands/deps.ts
+function tryOpenInVSCode3(path) {
+  try {
+    (0, import_node_child_process3.execSync)(`code "${path}"`, { stdio: "ignore" });
+  } catch {
+    process.stderr.write(
+      `Could not open in VS Code automatically.
+  Open manually: code "${path}"
+`
+    );
+  }
+}
+function buildDiagramLines2(nodes, canvasW, canvasH, workspaceName) {
+  const lines = [];
+  lines.push(
+    JSON.stringify({
+      width: canvasW,
+      height: canvasH,
+      background: "#0a0f1e",
+      metadata: {
+        name: `${workspaceName} - Dependencies`,
+        diagramType: "deps",
+        generatedAt: Date.now(),
+        packageCount: nodes.length
+      }
+    })
+  );
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (!groupMap.has(n.dirPath)) groupMap.set(n.dirPath, []);
+    groupMap.get(n.dirPath).push(n);
+  }
+  const groups = layoutGroups(nodes).groups;
+  for (const group of groups) {
+    lines.push(
+      JSON.stringify({
+        id: `grp_${group.dirId}`,
+        type: "node",
+        position: { x: group.x, y: group.y },
+        size: { width: group.w, height: group.h },
+        shape: "rectangle",
+        zIndex: 1,
+        style: {
+          fillStyle: "#0f2744",
+          strokeStyle: "#1e4080",
+          lineWidth: 1,
+          fillOpacity: 0.85,
+          strokeOpacity: 1,
+          cornerRadii: { topLeft: 8, topRight: 8, bottomRight: 8, bottomLeft: 8 }
+        },
+        text: {
+          content: group.label,
+          fontSize: 11,
+          fontFamily: "geist",
+          color: "#94a3b8",
+          textAlign: "left",
+          verticalAlign: "top"
+        }
+      })
+    );
+  }
+  for (const node of nodes) {
+    const textContent = `${node.name}
+v${node.version}`;
+    const fillStyle = node.isWorkspace ? "#1a2f52" : "#3d1f00";
+    const strokeStyle = node.isWorkspace ? "#3b82f6" : "#f59e0b";
+    const w = 220;
+    const h = 56;
+    const cx = node.x + 190 / 2;
+    const cy = node.y + 48 / 2;
+    lines.push(
+      JSON.stringify({
+        id: node.id,
+        type: "node",
+        position: { x: cx - w / 2, y: cy - h / 2 },
+        size: { width: w, height: h },
+        shape: "rectangle",
+        zIndex: 2,
+        style: {
+          fillStyle,
+          strokeStyle,
+          lineWidth: 1.5,
+          fillOpacity: 1,
+          strokeOpacity: 1,
+          cornerRadii: { topLeft: 6, topRight: 6, bottomRight: 6, bottomLeft: 6 }
+        },
+        text: {
+          content: textContent,
+          fontSize: 12,
+          fontFamily: "monospace",
+          color: "#e2e8f0",
+          textAlign: "center",
+          verticalAlign: "middle"
+        }
+      })
+    );
+  }
+  let edgeIndex = 0;
+  for (const node of nodes) {
+    for (const depName of node.dependencies) {
+      const targetNode = nodes.find((n) => n.name === depName);
+      if (targetNode) {
+        lines.push(
+          JSON.stringify({
+            id: `edge_dep_${++edgeIndex}`,
+            type: "edge",
+            source: node.id,
+            target: targetNode.id,
+            zIndex: 0,
+            style: {
+              strokeStyle: "#334155",
+              lineWidth: 1.5,
+              arrowheadEnd: true,
+              strokeOpacity: 0.8
+            }
+          })
+        );
+      }
+    }
+  }
+  return lines;
+}
+function registerDepsCommand(program2) {
+  program2.command("deps [path]").description("Generate a dependency graph of a workspace").option("--output <path>", "Output file path").option("--open", "Open generated file in VS Code").option("--no-workspace-only", "Include external npm packages").option("--include-dev", "Include devDependencies edges", false).option("--depth <n>", "Max dir depth to scan for package.json", "4").action((pathArg, opts) => {
+    try {
+      const targetDir = (0, import_node_path5.resolve)(pathArg ?? process.cwd());
+      if (!(0, import_node_fs6.existsSync)(targetDir) || !(0, import_node_fs6.statSync)(targetDir).isDirectory()) {
+        process.stderr.write(`Error: "${targetDir}" is not a directory.
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const maxDepth = parseInt(opts.depth, 10);
+      if (isNaN(maxDepth) || maxDepth < 1) {
+        process.stderr.write(`Error: --depth must be a positive integer.
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const options = {
+        workspaceOnly: opts.workspaceOnly !== false,
+        includeDev: !!opts.includeDev,
+        maxDepth,
+        excludePatterns: ["node_modules", "dist", "build", ".git", "out", ".turbo", "coverage"]
+      };
+      const nodes = analyzeDeps(targetDir, options);
+      if (nodes.length === 0) {
+        process.stderr.write(`No package.json files found in ${targetDir}.
+`);
+        process.exitCode = 0;
+        return;
+      }
+      const { canvasW, canvasH } = layoutGroups(nodes);
+      const workspaceName = (0, import_node_path5.basename)(targetDir);
+      const lines = buildDiagramLines2(nodes, canvasW, canvasH, workspaceName);
+      const outputPath = opts.output ?? `${workspaceName}-deps.drawit`;
+      writeOutput(lines.join("\n") + "\n", outputPath);
+      process.stderr.write(`Generated dependency graph: ${outputPath}
+`);
+      if (opts.open) tryOpenInVSCode3(outputPath);
+      process.exitCode = 0;
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/flow.ts
+var import_node_fs7 = require("fs");
+var import_node_child_process4 = require("child_process");
+var import_node_path6 = require("path");
+var NODE_W2 = 200;
+var NODE_H2 = 60;
+var DIAMOND_W = 180;
+var DIAMOND_H = 80;
+var STEP_GAP = 40;
+var CANVAS_W = 500;
+var CANVAS_PAD3 = 80;
+function tryOpenInVSCode4(path) {
+  try {
+    (0, import_node_child_process4.execSync)(`code "${path}"`, { stdio: "ignore" });
+  } catch {
+    process.stderr.write(
+      `Could not open in VS Code automatically.
+  Open manually: code "${path}"
+`
+    );
+  }
+}
+function determineNodeType(text, index, total, explicitType) {
+  if (explicitType === "start" || explicitType === "end" || explicitType === "decision" || explicitType === "process") {
+    return explicitType;
+  }
+  if (index === 0) return "start";
+  if (index === total - 1) return "end";
+  if (text.trim().endsWith("?")) return "decision";
+  return "process";
+}
+function getStyleForType(type) {
+  switch (type) {
+    case "start":
+      return { shape: "ellipse", fillStyle: "#065f46", strokeStyle: "#34d399", w: NODE_W2, h: NODE_H2 };
+    case "end":
+      return { shape: "ellipse", fillStyle: "#7f1d1d", strokeStyle: "#f87171", w: NODE_W2, h: NODE_H2 };
+    case "decision":
+      return { shape: "diamond", fillStyle: "#78350f", strokeStyle: "#fbbf24", w: DIAMOND_W, h: DIAMOND_H };
+    case "process":
+    default:
+      return { shape: "rectangle", fillStyle: "#1e3a5f", strokeStyle: "#3b82f6", w: NODE_W2, h: NODE_H2 };
+  }
+}
+function layoutSteps(rawSteps) {
+  const steps = [];
+  let currentY = CANVAS_PAD3;
+  for (let i = 0; i < rawSteps.length; i++) {
+    const raw = rawSteps[i];
+    const type = determineNodeType(raw.text, i, rawSteps.length, raw.type);
+    const { shape, fillStyle, strokeStyle, w, h } = getStyleForType(type);
+    steps.push({
+      text: raw.text,
+      type,
+      shape,
+      fillStyle,
+      strokeStyle,
+      w,
+      h,
+      x: (CANVAS_W - w) / 2,
+      y: currentY
+    });
+    currentY += h + STEP_GAP;
+  }
+  return steps;
+}
+function buildDiagramLines3(steps) {
+  const lines = [];
+  const canvasH = steps.length > 0 ? steps[steps.length - 1].y + steps[steps.length - 1].h + CANVAS_PAD3 : CANVAS_PAD3 * 2;
+  lines.push(
+    JSON.stringify({
+      width: CANVAS_W,
+      height: canvasH,
+      background: "#0a0f1e",
+      metadata: {
+        name: "Flowchart",
+        diagramType: "flow",
+        generatedAt: Date.now(),
+        stepCount: steps.length
+      }
+    })
+  );
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const id = `step_${i}`;
+    lines.push(
+      JSON.stringify({
+        id,
+        type: "node",
+        position: { x: step.x, y: step.y },
+        size: { width: step.w, height: step.h },
+        shape: step.shape,
+        zIndex: 2,
+        style: {
+          fillStyle: step.fillStyle,
+          strokeStyle: step.strokeStyle,
+          lineWidth: 2,
+          fillOpacity: 1,
+          strokeOpacity: 1,
+          cornerRadii: step.shape === "rectangle" ? { topLeft: 8, topRight: 8, bottomRight: 8, bottomLeft: 8 } : void 0
+        },
+        text: {
+          content: step.text,
+          fontSize: 14,
+          fontFamily: "sans-serif",
+          color: "#e2e8f0",
+          textAlign: "center",
+          verticalAlign: "middle"
+        }
+      })
+    );
+    if (i < steps.length - 1) {
+      lines.push(
+        JSON.stringify({
+          id: `edge_${i}_to_${i + 1}`,
+          type: "edge",
+          source: id,
+          target: `step_${i + 1}`,
+          zIndex: 1,
+          style: {
+            strokeStyle: "#94a3b8",
+            lineWidth: 2,
+            arrowheadEnd: true,
+            strokeOpacity: 0.8
+          }
+        })
+      );
+    }
+  }
+  return lines;
+}
+function registerFlowCommand(program2) {
+  program2.command("flow [steps...]").description("Generate a flowchart diagram from CLI arguments or stdin").option("--output <path>", "Output file path (default: flow.drawit)").option("--open", "Open generated file in VS Code").option("--stdin", "Read steps from standard input (one per line)").action((inlineArgs, opts) => {
+    try {
+      let rawSteps = [];
+      if (opts.stdin) {
+        const content = (0, import_node_fs7.readFileSync)(0, "utf-8");
+        const lines2 = content.split("\n").map((l) => l.trim()).filter(Boolean);
+        rawSteps = lines2.map((text) => ({ text }));
+      } else if (inlineArgs.length === 1 && inlineArgs[0].endsWith(".json")) {
+        const targetFile = (0, import_node_path6.resolve)(process.cwd(), inlineArgs[0]);
+        if (!(0, import_node_fs7.existsSync)(targetFile)) {
+          process.stderr.write(`Error: file "${targetFile}" not found.
+`);
+          process.exitCode = 1;
+          return;
+        }
+        const content = (0, import_node_fs7.readFileSync)(targetFile, "utf-8");
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed)) {
+          rawSteps = parsed;
+        } else {
+          process.stderr.write(`Error: JSON file must contain an array of steps.
+`);
+          process.exitCode = 1;
+          return;
+        }
+      } else {
+        rawSteps = inlineArgs.map((text) => ({ text }));
+      }
+      if (rawSteps.length === 0) {
+        process.stderr.write("Error: No steps provided. Use arguments, a JSON file, or --stdin.\n");
+        process.exitCode = 1;
+        return;
+      }
+      const steps = layoutSteps(rawSteps);
+      const lines = buildDiagramLines3(steps);
+      const outputPath = opts.output ?? "flow.drawit";
+      writeOutput(lines.join("\n") + "\n", outputPath);
+      process.stderr.write(`Generated flow diagram: ${outputPath}
+`);
+      if (opts.open) tryOpenInVSCode4(outputPath);
+      process.exitCode = 0;
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/routes.ts
+var import_node_fs8 = require("fs");
+var import_node_path7 = require("path");
+var import_node_child_process5 = require("child_process");
+function tryOpenInVSCode5(path) {
+  try {
+    (0, import_node_child_process5.execSync)(`code "${path}"`, { stdio: "ignore" });
+  } catch {
+    process.stderr.write(
+      `Could not open in VS Code automatically.
+  Open manually: code "${path}"
+`
+    );
+  }
+}
+function sanitizeId2(rPath) {
+  if (rPath === ".") return "r_root";
+  return "r_" + rPath.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function determineSegmentType(segment) {
+  if (segment.startsWith("(...)") || segment.startsWith("(..)")) return "intercept";
+  if (segment.startsWith("[...") && segment.endsWith("]")) return "catch-all";
+  if (segment.startsWith("[[...") && segment.endsWith("]]")) return "catch-all";
+  if (segment.startsWith("[") && segment.endsWith("]")) return "dynamic";
+  if (segment.startsWith("(") && segment.endsWith(")")) return "group";
+  if (segment.startsWith("@")) return "parallel";
+  return "static";
+}
+function buildSegmentNode(current, root, depth, parentId) {
+  const relPath = (0, import_node_path7.relative)(root, current) || ".";
+  const segment = depth === 0 ? (0, import_node_path7.basename)(current) : (0, import_node_path7.basename)(current);
+  if (segment === "__tests__" || segment === "__mocks__" || segment.startsWith(".")) return null;
+  let entries;
+  try {
+    entries = (0, import_node_fs8.readdirSync)(current, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let hasPage = false;
+  let hasRoute = false;
+  let hasLayout = false;
+  const childDirs = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    if (entry.isFile()) {
+      const ext = (0, import_node_path7.extname)(entry.name);
+      if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+        const withoutExt = entry.name.slice(0, -ext.length);
+        if (withoutExt === "page") hasPage = true;
+        if (withoutExt === "route") hasRoute = true;
+        if (withoutExt === "layout") hasLayout = true;
+      }
+    } else if (entry.isDirectory()) {
+      childDirs.push((0, import_node_path7.join)(current, entry.name));
+    }
+  }
+  const children = [];
+  const id = sanitizeId2(relPath);
+  for (const childDir of childDirs) {
+    const childNode = buildSegmentNode(childDir, root, depth + 1, id);
+    if (childNode) {
+      children.push(childNode);
+    }
+  }
+  if (depth > 0 && !hasPage && !hasRoute && !hasLayout && children.length === 0) {
+    return null;
+  }
+  let url = "";
+  const sType = determineSegmentType(segment);
+  if (sType === "dynamic") url = `:${segment.slice(1, -1)}`;
+  else if (sType === "catch-all") url = `*${segment.replace(/[[\]\.]/g, "")}`;
+  else if (sType === "group" || sType === "parallel" || sType === "intercept") url = "";
+  else url = segment;
+  return {
+    id,
+    segment,
+    url,
+    segmentType: sType,
+    hasPage,
+    hasRoute,
+    hasLayout,
+    depth,
+    children,
+    parentId,
+    x: 0,
+    y: 0
+  };
+}
+function getRouteStyle(node) {
+  if (node.hasRoute) return { fillStyle: "#1e1b4b", strokeStyle: "#7c3aed", dashed: false };
+  if (node.segmentType === "dynamic" || node.segmentType === "catch-all") return { fillStyle: "#3d1f00", strokeStyle: "#f59e0b", dashed: false };
+  if (node.segmentType === "group") return { fillStyle: "#0f2744", strokeStyle: "#334155", dashed: true };
+  if (node.hasLayout && !node.hasPage) return { fillStyle: "#14532d", strokeStyle: "#22c55e", dashed: false };
+  return { fillStyle: "#1e3a5f", strokeStyle: "#3b82f6", dashed: false };
+}
+function buildDiagramLines4(nodes, edges, canvasW, canvasH, rootDirName) {
+  const lines = [];
+  lines.push(
+    JSON.stringify({
+      width: canvasW,
+      height: canvasH,
+      background: "#0a0f1e",
+      metadata: {
+        name: `${rootDirName} - Routes`,
+        diagramType: "routes",
+        generatedAt: Date.now(),
+        routeCount: nodes.length
+      }
+    })
+  );
+  for (const node of nodes) {
+    const style = getRouteStyle(node);
+    const subLabels = [];
+    if (node.hasPage) subLabels.push("page");
+    if (node.hasLayout) subLabels.push("layout");
+    if (node.hasRoute) subLabels.push("api");
+    let content = node.url || node.segment;
+    if (node.segmentType === "group" || node.segmentType === "parallel") {
+      content = node.segment;
+    }
+    if (subLabels.length > 0) {
+      content += `
+[${subLabels.join(", ")}]`;
+    }
+    lines.push(
+      JSON.stringify({
+        id: node.id,
+        type: "node",
+        position: { x: node.x, y: node.y },
+        size: { width: DIR_W, height: DIR_H },
+        shape: "rectangle",
+        zIndex: node.depth + 1,
+        style: {
+          fillStyle: style.fillStyle,
+          strokeStyle: style.strokeStyle,
+          lineWidth: 1.5,
+          fillOpacity: 1,
+          strokeOpacity: 1,
+          lineDash: style.dashed ? [4, 4] : void 0,
+          cornerRadii: { topLeft: 12, topRight: 12, bottomRight: 12, bottomLeft: 12 }
+        },
+        text: {
+          content,
+          fontSize: 13,
+          fontFamily: "monospace",
+          color: "#e2e8f0",
+          textAlign: "center",
+          verticalAlign: "middle"
+        }
+      })
+    );
+  }
+  let edgeCounter = 0;
+  for (const edge of edges) {
+    lines.push(
+      JSON.stringify({
+        id: `re_${edgeCounter++}`,
+        type: "edge",
+        source: edge.source,
+        target: edge.target,
+        zIndex: 0,
+        style: {
+          strokeStyle: "#334155",
+          lineWidth: 1.5,
+          arrowheadEnd: true,
+          strokeOpacity: 0.8
+        }
+      })
+    );
+  }
+  return lines;
+}
+function registerRoutesCommand(program2) {
+  program2.command("routes [path]").description("Analyze a Next.js routes tree (app/ or pages/)").option("--output <path>", "Output file path (default: <dirname>-routes.drawit)").option("--open", "Open generated file in VS Code").action((pathArg, opts) => {
+    try {
+      let targetDir = (0, import_node_path7.resolve)(pathArg ?? process.cwd());
+      if (!pathArg) {
+        const appPath = (0, import_node_path7.join)(targetDir, "app");
+        const pagesPath = (0, import_node_path7.join)(targetDir, "pages");
+        if ((0, import_node_fs8.existsSync)(appPath)) {
+          targetDir = appPath;
+        } else if ((0, import_node_fs8.existsSync)(pagesPath)) {
+          targetDir = pagesPath;
+        }
+      }
+      if (!(0, import_node_fs8.existsSync)(targetDir) || !(0, import_node_fs8.statSync)(targetDir).isDirectory()) {
+        process.stderr.write(`Error: "${targetDir}" is not a directory.
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const rootNode = buildSegmentNode(targetDir, targetDir, 0, null);
+      if (!rootNode || rootNode.children.length === 0 && !rootNode.hasPage && !rootNode.hasRoute && !rootNode.hasLayout) {
+        process.stderr.write(`No routes or Next.js app structure found in ${targetDir}.
+`);
+        process.exitCode = 0;
+        return;
+      }
+      const { nodes, canvasW, canvasH, edges } = layoutTree(rootNode);
+      const dirname3 = (0, import_node_path7.basename)(targetDir === (0, import_node_path7.resolve)(process.cwd(), "app") ? (0, import_node_path7.resolve)(process.cwd()) : targetDir);
+      const lines = buildDiagramLines4(nodes, edges, canvasW, canvasH, dirname3);
+      const outputPath = opts.output ?? `${dirname3}-routes.drawit`;
+      writeOutput(lines.join("\n") + "\n", outputPath);
+      process.stderr.write(`Generated routes diagram: ${outputPath}
+`);
+      if (opts.open) tryOpenInVSCode5(outputPath);
+      process.exitCode = 0;
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli.ts
+function createProgram() {
+  const program2 = new import_commander.Command();
+  program2.name("drawit").description("CLI tool for validating, inspecting, and exporting DrawIt diagram files").version("0.1.0");
+  registerValidateCommand(program2);
+  registerInspectCommand(program2);
+  registerExportCommand(program2);
+  registerCreateCommand(program2);
+  registerMergeCommand(program2);
+  registerMapCommand(program2);
+  registerSchemaCommand(program2);
+  registerDepsCommand(program2);
+  registerFlowCommand(program2);
+  registerRoutesCommand(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
+program.parse(process.argv);