@hugobatist/smartcode 0.1.0

package/dist/index.js

@@ -0,0 +1,1167 @@
+// src/diagram/service.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var log = {
+  info: (...args) => console.error(pc.blue("[smartcode]"), ...args),
+  warn: (...args) => console.error(pc.yellow("[smartcode]"), ...args),
+  error: (...args) => console.error(pc.red("[smartcode]"), ...args),
+  debug: (...args) => {
+    if (process.env["DEBUG"]) console.error(pc.dim("[smartcode]"), ...args);
+  }
+};
+
+// src/diagram/annotations.ts
+var ANNOTATION_START = "%% --- ANNOTATIONS (auto-managed by SmartCode) ---";
+var ANNOTATION_START_LEGACY = "%% --- ANNOTATIONS (auto-managed by SmartB Diagrams) ---";
+var ANNOTATION_END = "%% --- END ANNOTATIONS ---";
+function isAnnotationStart(line) {
+  return line === ANNOTATION_START || line === ANNOTATION_START_LEGACY;
+}
+var FLAG_REGEX = /^%%\s*@flag\s+(\S+)\s+"([^"]*)"$/;
+var STATUS_REGEX = /^%%\s*@status\s+(\S+)\s+(\S+)$/;
+var BREAKPOINT_REGEX = /^%%\s*@breakpoint\s+(\S+)$/;
+var RISK_REGEX = /^%%\s*@risk\s+(\S+)\s+(high|medium|low)\s+"([^"]*)"$/;
+var GHOST_REGEX = /^%%\s*@ghost\s+(\S+)\s+(\S+)\s+"([^"]*)"$/;
+var VALID_STATUSES = ["ok", "problem", "in-progress", "discarded"];
+function parseAllAnnotations(content) {
+  const flags = /* @__PURE__ */ new Map();
+  const statuses = /* @__PURE__ */ new Map();
+  const breakpoints = /* @__PURE__ */ new Set();
+  const risks = /* @__PURE__ */ new Map();
+  const ghosts = [];
+  const lines = content.split("\n");
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (isAnnotationStart(trimmed)) {
+      inBlock = true;
+      continue;
+    }
+    if (trimmed === ANNOTATION_END) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock || trimmed === "") continue;
+    let match = FLAG_REGEX.exec(trimmed);
+    if (match) {
+      flags.set(match[1], { nodeId: match[1], message: match[2] });
+      continue;
+    }
+    match = STATUS_REGEX.exec(trimmed);
+    if (match) {
+      const statusValue = match[2];
+      if (VALID_STATUSES.includes(statusValue)) {
+        statuses.set(match[1], statusValue);
+      } else {
+        log.debug(`Skipping invalid status value: ${statusValue}`);
+      }
+      continue;
+    }
+    match = BREAKPOINT_REGEX.exec(trimmed);
+    if (match) {
+      breakpoints.add(match[1]);
+      continue;
+    }
+    match = RISK_REGEX.exec(trimmed);
+    if (match) {
+      risks.set(match[1], { nodeId: match[1], level: match[2], reason: match[3] });
+      continue;
+    }
+    match = GHOST_REGEX.exec(trimmed);
+    if (match) {
+      ghosts.push({ fromNodeId: match[1], toNodeId: match[2], label: match[3] });
+      continue;
+    }
+    log.debug(`Skipping unrecognized annotation line: ${trimmed}`);
+  }
+  return { flags, statuses, breakpoints, risks, ghosts };
+}
+function parseFlags(content) {
+  return parseAllAnnotations(content).flags;
+}
+function parseStatuses(content) {
+  return parseAllAnnotations(content).statuses;
+}
+function stripAnnotations(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (isAnnotationStart(trimmed)) {
+      inBlock = true;
+      continue;
+    }
+    if (trimmed === ANNOTATION_END) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock) {
+      result.push(line);
+    }
+  }
+  while (result.length > 0 && result[result.length - 1].trim() === "") {
+    result.pop();
+  }
+  return result.join("\n") + "\n";
+}
+function injectAnnotations(content, flags, statuses, breakpoints, risks, ghosts) {
+  const clean = stripAnnotations(content);
+  const hasFlags = flags.size > 0;
+  const hasStatuses = statuses !== void 0 && statuses.size > 0;
+  const hasBreakpoints = breakpoints !== void 0 && breakpoints.size > 0;
+  const hasRisks = risks !== void 0 && risks.size > 0;
+  const hasGhosts = ghosts !== void 0 && ghosts.length > 0;
+  if (!hasFlags && !hasStatuses && !hasBreakpoints && !hasRisks && !hasGhosts) {
+    return clean;
+  }
+  const lines = [
+    "",
+    ANNOTATION_START
+  ];
+  for (const [nodeId, flag] of flags) {
+    const escapedMessage = flag.message.replace(/"/g, "''");
+    lines.push(`%% @flag ${nodeId} "${escapedMessage}"`);
+  }
+  if (hasStatuses) {
+    for (const [nodeId, status] of statuses) {
+      lines.push(`%% @status ${nodeId} ${status}`);
+    }
+  }
+  if (hasBreakpoints) {
+    for (const nodeId of breakpoints) {
+      lines.push(`%% @breakpoint ${nodeId}`);
+    }
+  }
+  if (hasRisks) {
+    for (const [nodeId, risk] of risks) {
+      const escapedReason = risk.reason.replace(/"/g, "''");
+      lines.push(`%% @risk ${nodeId} ${risk.level} "${escapedReason}"`);
+    }
+  }
+  if (hasGhosts) {
+    for (const ghost of ghosts) {
+      const escapedLabel = ghost.label.replace(/"/g, "''");
+      lines.push(`%% @ghost ${ghost.fromNodeId} ${ghost.toNodeId} "${escapedLabel}"`);
+    }
+  }
+  lines.push(ANNOTATION_END);
+  lines.push("");
+  return clean.trimEnd() + "\n" + lines.join("\n");
+}
+
+// src/diagram/constants.ts
+var KNOWN_DIAGRAM_TYPES = [
+  "flowchart",
+  "graph",
+  "sequenceDiagram",
+  "classDiagram",
+  "stateDiagram",
+  "erDiagram",
+  "gantt",
+  "pie",
+  "gitgraph",
+  "mindmap",
+  "timeline"
+];
+var SUBGRAPH_START = /^\s*subgraph\s+([^\s\[]+)(?:\s*\["([^"]+)"\])?/;
+var SUBGRAPH_END = /^\s*end\s*$/;
+
+// src/diagram/parser.ts
+function parseDiagramType(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("%%")) continue;
+    for (const diagramType of KNOWN_DIAGRAM_TYPES) {
+      if (trimmed === diagramType || trimmed.startsWith(diagramType + " ")) {
+        return diagramType;
+      }
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function parseDiagramContent(rawContent) {
+  const mermaidContent = stripAnnotations(rawContent);
+  const flags = parseFlags(rawContent);
+  const diagramType = parseDiagramType(mermaidContent);
+  return { mermaidContent, flags, diagramType };
+}
+
+// src/diagram/validator.ts
+function validateMermaidSyntax(content) {
+  const errors = [];
+  const trimmedContent = content.trim();
+  if (trimmedContent === "") {
+    return { valid: false, errors: [{ message: "Empty diagram content" }] };
+  }
+  const diagramType = parseDiagramType(content);
+  if (!diagramType) {
+    const firstLine = trimmedContent.split("\n")[0]?.trim() ?? "";
+    errors.push({
+      message: `Unknown diagram type. First line: "${firstLine}". Expected one of: ${KNOWN_DIAGRAM_TYPES.join(", ")}`,
+      line: 1
+    });
+    return { valid: false, errors, diagramType: void 0 };
+  }
+  const bracketErrors = checkBracketMatching(content);
+  errors.push(...bracketErrors);
+  const danglingErrors = checkDanglingArrows(content);
+  errors.push(...danglingErrors);
+  return {
+    valid: errors.length === 0,
+    errors,
+    diagramType
+  };
+}
+function checkBracketMatching(content) {
+  const errors = [];
+  const lines = content.split("\n");
+  const pairs = [["[", "]"], ["(", ")"], ["{", "}"]];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (line.trim().startsWith("%%")) continue;
+    for (const [open, close] of pairs) {
+      let depth = 0;
+      for (const char of line) {
+        if (char === open) depth++;
+        if (char === close) depth--;
+        if (depth < 0) {
+          errors.push({
+            message: `Unexpected closing '${close}' without matching '${open}'`,
+            line: lineNum
+          });
+          break;
+        }
+      }
+      if (depth > 0) {
+        errors.push({
+          message: `Unclosed '${open}' -- missing '${close}'`,
+          line: lineNum
+        });
+      }
+    }
+  }
+  return errors;
+}
+function checkDanglingArrows(content) {
+  const errors = [];
+  const lines = content.split("\n");
+  const danglingArrowPattern = /-->\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("%%")) continue;
+    if (danglingArrowPattern.test(trimmed)) {
+      errors.push({
+        message: `Dangling arrow -- line ends with '-->' but no target node`,
+        line: lineNum
+      });
+    }
+  }
+  return errors;
+}
+
+// src/diagram/graph-types.ts
+var SHAPE_PATTERNS = [
+  { open: "([", close: "])", shape: "stadium" },
+  { open: "[[", close: "]]", shape: "subroutine" },
+  { open: "[(", close: ")]", shape: "cylinder" },
+  { open: "((", close: "))", shape: "circle" },
+  { open: "{{", close: "}}", shape: "hexagon" },
+  { open: "[/", close: "\\]", shape: "trapezoid" },
+  { open: "[\\", close: "/]", shape: "trapezoid-alt" },
+  { open: "[/", close: "/]", shape: "parallelogram" },
+  { open: "[\\", close: "\\]", shape: "parallelogram-alt" },
+  { open: ">", close: "]", shape: "asymmetric" },
+  { open: "{", close: "}", shape: "diamond" },
+  { open: "(", close: ")", shape: "rounded" },
+  { open: "[", close: "]", shape: "rect" }
+];
+var EDGE_SYNTAX = {
+  arrow: "-->",
+  open: "---",
+  dotted: "-.->",
+  thick: "==>",
+  invisible: "~~~"
+};
+
+// src/diagram/graph-edge-parser.ts
+var EDGE_OPS = [
+  // Bidirectional variants (must come before unidirectional)
+  { pattern: /\s*<==>\s*/, type: "thick", bidirectional: true },
+  { pattern: /\s*<-\.->\s*/, type: "dotted", bidirectional: true },
+  { pattern: /\s*<-->\s*/, type: "arrow", bidirectional: true },
+  // Labeled edges: pipe syntax  -->|"label"|  or  -->|label|
+  { pattern: /\s*-->\|"([^"]*)"\|\s*/, type: "arrow", bidirectional: false },
+  { pattern: /\s*-->\|([^|]*)\|\s*/, type: "arrow", bidirectional: false },
+  // Labeled edges: inline syntax  -- "label" -->
+  { pattern: /\s*--\s*"([^"]*)"\s*-->\s*/, type: "arrow", bidirectional: false },
+  // Unlabeled operators (order: longest first)
+  { pattern: /\s*~~~\s*/, type: "invisible", bidirectional: false },
+  { pattern: /\s*==>\s*/, type: "thick", bidirectional: false },
+  { pattern: /\s*-\.->\s*/, type: "dotted", bidirectional: false },
+  { pattern: /\s*---\s*/, type: "open", bidirectional: false },
+  { pattern: /\s*-->\s*/, type: "arrow", bidirectional: false }
+];
+function stripInlineClass(ref) {
+  const classIdx = ref.indexOf(":::");
+  if (classIdx === -1) return { id: ref };
+  return {
+    id: ref.substring(0, classIdx),
+    className: ref.substring(classIdx + 3)
+  };
+}
+function parseNodeShape(definition) {
+  const trimmed = definition.trim();
+  if (!trimmed) return null;
+  const { id: withShape, className } = stripInlineClass(trimmed);
+  for (const sp of SHAPE_PATTERNS) {
+    const openIdx = withShape.indexOf(sp.open);
+    if (openIdx === -1) continue;
+    const nodeId = withShape.substring(0, openIdx).trim();
+    if (!nodeId || !/^[\w][\w\d_-]*$/.test(nodeId)) continue;
+    const afterOpen = withShape.substring(openIdx + sp.open.length);
+    if (!afterOpen.endsWith(sp.close)) continue;
+    const labelRaw = afterOpen.substring(0, afterOpen.length - sp.close.length);
+    let label = labelRaw;
+    if (label.startsWith('"') && label.endsWith('"')) {
+      label = label.substring(1, label.length - 1);
+    }
+    return { id: nodeId, label, shape: sp.shape, className };
+  }
+  return null;
+}
+function extractNodeSegments(line) {
+  let work = line;
+  for (const op of EDGE_OPS) {
+    work = work.replace(op.pattern, " \0 ");
+  }
+  return work.split("\0").map((s) => s.trim()).filter(Boolean);
+}
+function parseEdgesFromLine(line) {
+  const result = [];
+  let remaining = line;
+  let lastNode = null;
+  while (remaining.trim()) {
+    let earliest = null;
+    for (const op of EDGE_OPS) {
+      const match = op.pattern.exec(remaining);
+      if (match && (earliest === null || match.index < earliest.index)) {
+        earliest = {
+          index: match.index,
+          matchLen: match[0].length,
+          type: op.type,
+          bidirectional: op.bidirectional,
+          label: match[1]
+        };
+      }
+    }
+    if (!earliest) break;
+    const beforeOp = remaining.substring(0, earliest.index).trim();
+    remaining = remaining.substring(earliest.index + earliest.matchLen);
+    if (lastNode === null) {
+      lastNode = extractNodeId(beforeOp);
+      if (!lastNode) break;
+    }
+    const afterTrimmed = remaining.trim();
+    const nextNodeId = extractNodeId(afterTrimmed, "left");
+    if (!nextNodeId) break;
+    result.push({
+      from: lastNode,
+      to: nextNodeId,
+      type: earliest.type,
+      label: earliest.label,
+      bidirectional: earliest.bidirectional
+    });
+    lastNode = nextNodeId;
+    remaining = advancePastNode(remaining.trim(), nextNodeId);
+  }
+  return result;
+}
+function extractNodeId(text, direction = "right") {
+  if (!text.trim()) return null;
+  const { id } = stripInlineClass(text.trim());
+  const shaped = parseNodeShape(text.trim());
+  if (shaped) return shaped.id;
+  if (direction === "left") {
+    const match2 = /^([\w][\w\d_-]*)/.exec(id);
+    return match2 ? match2[1] : null;
+  }
+  const match = /([\w][\w\d_-]*)$/.exec(id);
+  return match ? match[1] : null;
+}
+function advancePastNode(text, nodeId) {
+  const { id: cleanText } = stripInlineClass(text);
+  for (const sp of SHAPE_PATTERNS) {
+    const expectedStart = nodeId + sp.open;
+    if (cleanText.startsWith(expectedStart)) {
+      const closeIdx = cleanText.indexOf(sp.close, expectedStart.length);
+      if (closeIdx !== -1) {
+        const afterClose = closeIdx + sp.close.length;
+        const afterWithClass = text.substring(afterClose);
+        const classMatch = /^:::\S+/.exec(afterWithClass);
+        return classMatch ? afterWithClass.substring(classMatch[0].length) : afterWithClass;
+      }
+    }
+  }
+  const safeId = regexSafe(nodeId);
+  const simplePattern = new RegExp(`^${safeId}(?::::\\S+)?`);
+  const simpleMatch = simplePattern.exec(text);
+  if (simpleMatch) {
+    return text.substring(simpleMatch[0].length);
+  }
+  return text.substring(nodeId.length);
+}
+function regexSafe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/diagram/graph-parser.ts
+function parseMermaidToGraph(rawContent, filePath) {
+  const flags = parseFlags(rawContent);
+  const statuses = parseStatuses(rawContent);
+  const mermaidContent = stripAnnotations(rawContent);
+  const lines = mermaidContent.split("\n");
+  let diagramType = "flowchart";
+  let direction = "TB";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("%%")) continue;
+    const dirMatch = /^(flowchart|graph)\s+(TB|TD|BT|LR|RL)/.exec(trimmed);
+    if (dirMatch) {
+      diagramType = dirMatch[1];
+      const rawDir = dirMatch[2];
+      direction = rawDir === "TD" ? "TB" : rawDir;
+    }
+    break;
+  }
+  const classDefs = /* @__PURE__ */ new Map();
+  const nodeStyles = /* @__PURE__ */ new Map();
+  const linkStyles = /* @__PURE__ */ new Map();
+  const classAssignments = /* @__PURE__ */ new Map();
+  const directiveLineIndices = /* @__PURE__ */ new Set();
+  parseStyleDirectives(
+    lines,
+    classDefs,
+    nodeStyles,
+    linkStyles,
+    classAssignments,
+    directiveLineIndices
+  );
+  const subgraphs = /* @__PURE__ */ new Map();
+  const lineToSubgraph = /* @__PURE__ */ new Map();
+  const subgraphLineIndices = /* @__PURE__ */ new Set();
+  parseSubgraphStructure(lines, subgraphs, lineToSubgraph, subgraphLineIndices);
+  const nodes = /* @__PURE__ */ new Map();
+  parseNodeDefinitions(
+    lines,
+    nodes,
+    classAssignments,
+    lineToSubgraph,
+    directiveLineIndices,
+    subgraphLineIndices
+  );
+  const edges = [];
+  parseEdgeDefinitions(
+    lines,
+    edges,
+    nodes,
+    subgraphs,
+    lineToSubgraph,
+    directiveLineIndices,
+    subgraphLineIndices
+  );
+  for (const [nodeId, flag] of flags) {
+    const node = nodes.get(nodeId);
+    if (node) node.flag = flag;
+  }
+  for (const [nodeId, status] of statuses) {
+    const node = nodes.get(nodeId);
+    if (node) node.status = status;
+  }
+  const validation = validateMermaidSyntax(mermaidContent);
+  return {
+    diagramType,
+    direction,
+    nodes,
+    edges,
+    subgraphs,
+    classDefs,
+    nodeStyles,
+    linkStyles,
+    classAssignments,
+    filePath,
+    flags,
+    statuses,
+    validation
+  };
+}
+function parseStyleDirectives(lines, classDefs, nodeStyles, linkStyles, classAssignments, directiveLineIndices) {
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const classDefMatch = /^classDef\s+(\S+)\s+(.+);?\s*$/.exec(trimmed);
+    if (classDefMatch) {
+      const name = classDefMatch[1];
+      classDefs.set(name, classDefMatch[2].replace(/;\s*$/, ""));
+      directiveLineIndices.add(i);
+      continue;
+    }
+    const styleMatch = /^style\s+(\S+)\s+(.+);?\s*$/.exec(trimmed);
+    if (styleMatch) {
+      nodeStyles.set(styleMatch[1], styleMatch[2].replace(/;\s*$/, ""));
+      directiveLineIndices.add(i);
+      continue;
+    }
+    const linkStyleMatch = /^linkStyle\s+(\d+)\s+(.+);?\s*$/.exec(trimmed);
+    if (linkStyleMatch) {
+      linkStyles.set(
+        parseInt(linkStyleMatch[1], 10),
+        linkStyleMatch[2].replace(/;\s*$/, "")
+      );
+      directiveLineIndices.add(i);
+      continue;
+    }
+    const classDirectiveMatch = /^class\s+(.+?)\s+(\S+);?\s*$/.exec(trimmed);
+    if (classDirectiveMatch) {
+      const className = classDirectiveMatch[2].replace(/;\s*$/, "");
+      const nodeIds = classDirectiveMatch[1].split(",").map((s) => s.trim());
+      for (const nid of nodeIds) {
+        classAssignments.set(nid, className);
+      }
+      directiveLineIndices.add(i);
+      continue;
+    }
+  }
+}
+function parseSubgraphStructure(lines, subgraphs, lineToSubgraph, subgraphLineIndices) {
+  const subgraphStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const startMatch = SUBGRAPH_START.exec(line);
+    if (startMatch) {
+      const id = startMatch[1];
+      const label = startMatch[2] || id;
+      const parentId = subgraphStack.length > 0 ? subgraphStack[subgraphStack.length - 1] : null;
+      const sg = {
+        id,
+        label,
+        parentId,
+        nodeIds: [],
+        childSubgraphIds: []
+      };
+      subgraphs.set(id, sg);
+      if (parentId) {
+        const parent = subgraphs.get(parentId);
+        if (parent) parent.childSubgraphIds.push(id);
+      }
+      subgraphStack.push(id);
+      subgraphLineIndices.add(i);
+      continue;
+    }
+    if (SUBGRAPH_END.test(line) && subgraphStack.length > 0) {
+      subgraphStack.pop();
+      subgraphLineIndices.add(i);
+      continue;
+    }
+    if (subgraphStack.length > 0) {
+      lineToSubgraph.set(i, subgraphStack[subgraphStack.length - 1]);
+    }
+  }
+}
+var DIRECTION_LINE = /^(flowchart|graph)\s+(TB|TD|BT|LR|RL)/;
+function isSkippableLine(trimmed, lineIdx, directiveIndices, subgraphIndices) {
+  if (directiveIndices.has(lineIdx)) return true;
+  if (subgraphIndices.has(lineIdx)) return true;
+  if (!trimmed || trimmed.startsWith("%%")) return true;
+  if (DIRECTION_LINE.test(trimmed)) return true;
+  return false;
+}
+function parseNodeDefinitions(lines, nodes, classAssignments, lineToSubgraph, directiveLineIndices, subgraphLineIndices) {
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (isSkippableLine(trimmed, i, directiveLineIndices, subgraphLineIndices)) continue;
+    const nodeSegments = extractNodeSegments(trimmed);
+    for (const segment of nodeSegments) {
+      const parsed = parseNodeShape(segment);
+      if (parsed && !nodes.has(parsed.id)) {
+        const subgraphId = lineToSubgraph.get(i);
+        const cssClass = parsed.className || classAssignments.get(parsed.id);
+        nodes.set(parsed.id, {
+          id: parsed.id,
+          label: parsed.label,
+          shape: parsed.shape,
+          subgraphId,
+          cssClass
+        });
+        if (parsed.className) {
+          classAssignments.set(parsed.id, parsed.className);
+        }
+      } else if (!parsed) {
+        const { id: bareId, className } = stripInlineClass(segment.trim());
+        if (className && /^[\w][\w\d_-]*$/.test(bareId)) {
+          classAssignments.set(bareId, className);
+          if (!nodes.has(bareId)) {
+            nodes.set(bareId, {
+              id: bareId,
+              label: bareId,
+              shape: "rect",
+              subgraphId: lineToSubgraph.get(i),
+              cssClass: className
+            });
+          } else {
+            nodes.get(bareId).cssClass = className;
+          }
+        }
+      }
+    }
+  }
+}
+function parseEdgeDefinitions(lines, edges, nodes, subgraphs, lineToSubgraph, directiveLineIndices, subgraphLineIndices) {
+  const edgeIdCounts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (isSkippableLine(trimmed, i, directiveLineIndices, subgraphLineIndices)) continue;
+    const lineEdges = parseEdgesFromLine(trimmed);
+    for (const edgeInfo of lineEdges) {
+      const { id: fromId } = stripInlineClass(edgeInfo.from);
+      const { id: toId } = stripInlineClass(edgeInfo.to);
+      ensureNode(nodes, fromId, lineToSubgraph.get(i));
+      ensureNode(nodes, toId, lineToSubgraph.get(i));
+      const sgId = lineToSubgraph.get(i);
+      if (sgId) {
+        const sg = subgraphs.get(sgId);
+        if (sg) {
+          if (!sg.nodeIds.includes(fromId) && !subgraphs.has(fromId)) {
+            sg.nodeIds.push(fromId);
+          }
+          if (!sg.nodeIds.includes(toId) && !subgraphs.has(toId)) {
+            sg.nodeIds.push(toId);
+          }
+        }
+      }
+      const baseId = `${fromId}->${toId}`;
+      const count = edgeIdCounts.get(baseId) || 0;
+      const edgeId = count === 0 ? baseId : `${baseId}#${count}`;
+      edgeIdCounts.set(baseId, count + 1);
+      edges.push({
+        id: edgeId,
+        from: fromId,
+        to: toId,
+        type: edgeInfo.type,
+        label: edgeInfo.label,
+        bidirectional: edgeInfo.bidirectional || void 0
+      });
+    }
+  }
+}
+function ensureNode(nodes, id, subgraphId) {
+  if (nodes.has(id)) return;
+  nodes.set(id, { id, label: id, shape: "rect", subgraphId });
+}
+
+// src/utils/paths.ts
+import path from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function resolveProjectPath(projectRoot, filePath) {
+  const resolvedRoot = path.resolve(projectRoot);
+  const resolved = path.resolve(resolvedRoot, filePath);
+  if (!resolved.startsWith(resolvedRoot + path.sep) && resolved !== resolvedRoot) {
+    throw new Error(`Path traversal detected: ${filePath}`);
+  }
+  return resolved;
+}
+
+// src/project/discovery.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "test",
+  "dist",
+  ".planning",
+  ".smartcode"
+]);
+async function discoverMmdFiles(directory) {
+  const entries = await readdir(directory, { recursive: true, withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".mmd")) continue;
+    const parentPath = entry.parentPath ?? "";
+    const relativePath = parentPath ? join(parentPath, entry.name).slice(directory.length + 1) : entry.name;
+    const segments = relativePath.split("/");
+    const excluded = segments.some((seg) => EXCLUDED_DIRS.has(seg));
+    if (!excluded) {
+      files.push(relativePath);
+    }
+  }
+  return files.sort();
+}
+
+// src/diagram/service.ts
+var DiagramService = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /** Per-file write locks to serialize concurrent write operations */
+  writeLocks = /* @__PURE__ */ new Map();
+  /**
+   * Serialize write operations on a given file path.
+   * Each call waits for the previous write on the same file to finish before running.
+   * Cleans up lock entry when no further writes are queued.
+   */
+  async withWriteLock(filePath, fn) {
+    const prev = this.writeLocks.get(filePath) ?? Promise.resolve();
+    const current = prev.then(fn, fn);
+    const settled = current.then(() => {
+    }, () => {
+    });
+    this.writeLocks.set(filePath, settled);
+    const result = await current;
+    if (this.writeLocks.get(filePath) === settled) {
+      this.writeLocks.delete(filePath);
+    }
+    return result;
+  }
+  /**
+   * Read a .mmd file and parse all annotations + mermaid content in one pass.
+   */
+  async readAllAnnotations(filePath) {
+    const resolved = this.resolvePath(filePath);
+    const raw = await readFile(resolved, "utf-8");
+    const { mermaidContent } = parseDiagramContent(raw);
+    const { flags, statuses, breakpoints, risks, ghosts } = parseAllAnnotations(raw);
+    return { raw, mermaidContent, flags, statuses, breakpoints, risks, ghosts };
+  }
+  /**
+   * Read-modify-write cycle for annotation mutations.
+   * Acquires the write lock, reads all annotations, calls modifyFn to mutate them,
+   * then writes the result back.
+   */
+  async modifyAnnotation(filePath, modifyFn) {
+    return this.withWriteLock(filePath, async () => {
+      const data = await this.readAllAnnotations(filePath);
+      modifyFn(data);
+      await this._writeDiagramInternal(
+        filePath,
+        data.mermaidContent,
+        data.flags,
+        data.statuses,
+        data.breakpoints,
+        data.risks,
+        data.ghosts
+      );
+    });
+  }
+  /**
+   * Read and parse a .mmd file.
+   * Resolves path with traversal protection, parses content, and validates syntax.
+   */
+  async readDiagram(filePath) {
+    const resolved = this.resolvePath(filePath);
+    const raw = await readFile(resolved, "utf-8");
+    const { mermaidContent, diagramType } = parseDiagramContent(raw);
+    const { flags, statuses, breakpoints, risks, ghosts } = parseAllAnnotations(raw);
+    const validation = validateMermaidSyntax(mermaidContent);
+    if (diagramType && !validation.diagramType) {
+      validation.diagramType = diagramType;
+    }
+    return { raw, mermaidContent, flags, statuses, breakpoints, risks, ghosts, validation, filePath };
+  }
+  /**
+   * Read a .mmd file and parse it into a structured GraphModel.
+   */
+  async readGraph(filePath) {
+    const resolved = this.resolvePath(filePath);
+    const raw = await readFile(resolved, "utf-8");
+    return parseMermaidToGraph(raw, filePath);
+  }
+  /**
+   * Write a .mmd file. If flags or statuses are provided, injects annotation block.
+   * Creates parent directories if they don't exist.
+   */
+  async writeDiagram(filePath, content, flags, statuses, breakpoints, risks, ghosts) {
+    return this.withWriteLock(
+      filePath,
+      () => this._writeDiagramInternal(filePath, content, flags, statuses, breakpoints, risks, ghosts)
+    );
+  }
+  /**
+   * Write diagram content while preserving existing developer-owned annotations (flags, breakpoints).
+   * Reads existing annotations first, merges caller-provided statuses/risks/ghosts on top, preserves flags
+   * and breakpoints unconditionally, then writes the merged result atomically under the write lock.
+   *
+   * Merge semantics:
+   * - `content`: always replaces the Mermaid diagram body
+   * - `statuses`: if provided, replaces all statuses; if undefined, preserves existing
+   * - `risks`: if provided, replaces all risks; if undefined, preserves existing
+   * - `ghosts`: if provided, replaces all ghosts; if undefined, preserves existing
+   * - `flags`: always preserved from the file (developer-owned, never touched by MCP)
+   * - `breakpoints`: always preserved from the file (developer-owned, never touched by MCP)
+   */
+  async writeDiagramPreserving(filePath, content, statuses, risks, ghosts) {
+    return this.withWriteLock(filePath, async () => {
+      let existingFlags = /* @__PURE__ */ new Map();
+      let existingBreakpoints = /* @__PURE__ */ new Set();
+      let existingStatuses = /* @__PURE__ */ new Map();
+      let existingRisks = /* @__PURE__ */ new Map();
+      let existingGhosts = [];
+      try {
+        const data = await this.readAllAnnotations(filePath);
+        existingFlags = data.flags;
+        existingBreakpoints = data.breakpoints;
+        existingStatuses = data.statuses;
+        existingRisks = data.risks;
+        existingGhosts = data.ghosts;
+      } catch {
+      }
+      await this._writeDiagramInternal(
+        filePath,
+        content,
+        existingFlags,
+        // always preserve
+        statuses ?? existingStatuses,
+        // replace if provided, else preserve
+        existingBreakpoints,
+        // always preserve
+        risks ?? existingRisks,
+        // replace if provided, else preserve
+        ghosts ?? existingGhosts
+        // replace if provided, else preserve
+      );
+    });
+  }
+  /**
+   * Write raw content to a .mmd file under the write lock.
+   * Does NOT process annotations -- writes content as-is.
+   * Used by /save endpoint which receives pre-formatted content from the editor.
+   */
+  async writeRaw(filePath, content) {
+    return this.withWriteLock(filePath, async () => {
+      const resolved = this.resolvePath(filePath);
+      await mkdir(dirname(resolved), { recursive: true });
+      await writeFile(resolved, content, "utf-8");
+    });
+  }
+  /**
+   * Internal write without acquiring the lock.
+   * Used by methods that already hold the write lock for the same file.
+   */
+  async _writeDiagramInternal(filePath, content, flags, statuses, breakpoints, risks, ghosts) {
+    const resolved = this.resolvePath(filePath);
+    let output = content;
+    if (flags || statuses || breakpoints || risks || ghosts && ghosts.length > 0) {
+      output = injectAnnotations(content, flags ?? /* @__PURE__ */ new Map(), statuses, breakpoints, risks, ghosts);
+    }
+    await mkdir(dirname(resolved), { recursive: true });
+    await writeFile(resolved, output, "utf-8");
+  }
+  /** Get all flags from a .mmd file as an array. */
+  async getFlags(filePath) {
+    const diagram = await this.readDiagram(filePath);
+    return Array.from(diagram.flags.values());
+  }
+  /** Set (add or update) a flag on a specific node. */
+  async setFlag(filePath, nodeId, message) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.flags.set(nodeId, { nodeId, message });
+    });
+  }
+  /** Remove a flag from a specific node. */
+  async removeFlag(filePath, nodeId) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.flags.delete(nodeId);
+    });
+  }
+  /** Get all statuses from a .mmd file. */
+  async getStatuses(filePath) {
+    const diagram = await this.readDiagram(filePath);
+    return diagram.statuses;
+  }
+  /** Set (add or update) a status on a specific node. */
+  async setStatus(filePath, nodeId, status) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.statuses.set(nodeId, status);
+    });
+  }
+  /** Remove a status from a specific node. */
+  async removeStatus(filePath, nodeId) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.statuses.delete(nodeId);
+    });
+  }
+  /** Get all breakpoints from a .mmd file. */
+  async getBreakpoints(filePath) {
+    const resolved = this.resolvePath(filePath);
+    const raw = await readFile(resolved, "utf-8");
+    return parseAllAnnotations(raw).breakpoints;
+  }
+  /** Set (add) a breakpoint on a specific node. */
+  async setBreakpoint(filePath, nodeId) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.breakpoints.add(nodeId);
+    });
+  }
+  /** Remove a breakpoint from a specific node. */
+  async removeBreakpoint(filePath, nodeId) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.breakpoints.delete(nodeId);
+    });
+  }
+  /** Get all risk annotations from a .mmd file. */
+  async getRisks(filePath) {
+    const resolved = this.resolvePath(filePath);
+    const raw = await readFile(resolved, "utf-8");
+    return parseAllAnnotations(raw).risks;
+  }
+  /** Set (add or update) a risk annotation on a specific node. */
+  async setRisk(filePath, nodeId, level, reason) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.risks.set(nodeId, { nodeId, level, reason });
+    });
+  }
+  /** Remove a risk annotation from a specific node. */
+  async removeRisk(filePath, nodeId) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.risks.delete(nodeId);
+    });
+  }
+  /** Get all ghost path annotations from a .mmd file. */
+  async getGhosts(filePath) {
+    const resolved = this.resolvePath(filePath);
+    const raw = await readFile(resolved, "utf-8");
+    return parseAllAnnotations(raw).ghosts;
+  }
+  /** Add a ghost path annotation to a .mmd file. */
+  async addGhost(filePath, fromNodeId, toNodeId, label) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.ghosts.push({ fromNodeId, toNodeId, label });
+    });
+  }
+  /** Remove a specific ghost path annotation (by from+to+label exact match). */
+  async removeGhost(filePath, fromNodeId, toNodeId) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.ghosts = data.ghosts.filter(
+        (g) => !(g.fromNodeId === fromNodeId && g.toNodeId === toNodeId)
+      );
+    });
+  }
+  /** Clear all ghost path annotations from a .mmd file. */
+  async clearGhosts(filePath) {
+    return this.modifyAnnotation(filePath, (data) => {
+      data.ghosts = [];
+    });
+  }
+  /** Validate the Mermaid syntax of a .mmd file. */
+  async validate(filePath) {
+    const diagram = await this.readDiagram(filePath);
+    return diagram.validation;
+  }
+  /** List all .mmd files in the project root. */
+  async listFiles() {
+    return discoverMmdFiles(this.projectRoot);
+  }
+  /**
+   * Resolve a relative file path against the project root.
+   * Single chokepoint for path security -- rejects path traversal.
+   */
+  resolvePath(filePath) {
+    return resolveProjectPath(this.projectRoot, filePath);
+  }
+};
+
+// src/diagram/graph-serializer.ts
+var SHAPE_BRACKETS = /* @__PURE__ */ new Map();
+for (const sp of SHAPE_PATTERNS) {
+  if (!SHAPE_BRACKETS.has(sp.shape)) {
+    SHAPE_BRACKETS.set(sp.shape, { open: sp.open, close: sp.close });
+  }
+}
+function serializeGraphToMermaid(graph) {
+  const lines = [];
+  lines.push(`${graph.diagramType} ${graph.direction}`);
+  for (const [name, styles] of graph.classDefs) {
+    lines.push(`    classDef ${name} ${styles}`);
+  }
+  const emittedNodes = /* @__PURE__ */ new Set();
+  const rootSubgraphs = [];
+  for (const sg of graph.subgraphs.values()) {
+    if (sg.parentId === null) {
+      rootSubgraphs.push(sg);
+    }
+  }
+  for (const sg of rootSubgraphs) {
+    emitSubgraph(graph, sg, lines, emittedNodes, 1);
+  }
+  for (const [id, node] of graph.nodes) {
+    if (emittedNodes.has(id)) continue;
+    lines.push(`    ${serializeNode(id, node.label, node.shape)}`);
+  }
+  for (const edge of graph.edges) {
+    const arrow = serializeEdgeOperator(edge.type, edge.bidirectional, edge.label);
+    lines.push(`    ${edge.from} ${arrow} ${edge.to}`);
+  }
+  for (const [nodeId, styles] of graph.nodeStyles) {
+    lines.push(`    style ${nodeId} ${styles}`);
+  }
+  const sortedLinkStyles = [...graph.linkStyles.entries()].sort((a, b) => a[0] - b[0]);
+  for (const [idx, styles] of sortedLinkStyles) {
+    lines.push(`    linkStyle ${idx} ${styles}`);
+  }
+  const classGroups = /* @__PURE__ */ new Map();
+  for (const [nodeId, className] of graph.classAssignments) {
+    if (!classGroups.has(className)) {
+      classGroups.set(className, []);
+    }
+    classGroups.get(className).push(nodeId);
+  }
+  for (const [className, nodeIds] of classGroups) {
+    lines.push(`    class ${nodeIds.join(",")} ${className}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function emitSubgraph(graph, sg, lines, emittedNodes, depth) {
+  const indent = "    ".repeat(depth);
+  if (sg.label !== sg.id) {
+    lines.push(`${indent}subgraph ${sg.id}["${sg.label}"]`);
+  } else {
+    lines.push(`${indent}subgraph ${sg.id}`);
+  }
+  for (const childId of sg.childSubgraphIds) {
+    const child = graph.subgraphs.get(childId);
+    if (child) {
+      emitSubgraph(graph, child, lines, emittedNodes, depth + 1);
+    }
+  }
+  for (const nodeId of sg.nodeIds) {
+    const node = graph.nodes.get(nodeId);
+    if (node) {
+      lines.push(`${indent}    ${serializeNode(nodeId, node.label, node.shape)}`);
+      emittedNodes.add(nodeId);
+    }
+  }
+  for (const [id, node] of graph.nodes) {
+    if (node.subgraphId === sg.id && !emittedNodes.has(id)) {
+      lines.push(`${indent}    ${serializeNode(id, node.label, node.shape)}`);
+      emittedNodes.add(id);
+    }
+  }
+  lines.push(`${indent}end`);
+}
+function serializeNode(id, label, shape) {
+  if (label === id && shape === "rect") {
+    return id;
+  }
+  const brackets = SHAPE_BRACKETS.get(shape);
+  if (!brackets) {
+    return `${id}["${label}"]`;
+  }
+  return `${id}${brackets.open}"${label}"${brackets.close}`;
+}
+function serializeEdgeOperator(type, bidirectional, label) {
+  const baseSyntax = EDGE_SYNTAX[type] ?? "-->";
+  if (bidirectional) {
+    return `<${baseSyntax}`;
+  }
+  if (label) {
+    return `${baseSyntax}|"${label}"|`;
+  }
+  return baseSyntax;
+}
+function serializeGraphModel(graph) {
+  return {
+    diagramType: graph.diagramType,
+    direction: graph.direction,
+    nodes: Object.fromEntries(graph.nodes),
+    edges: graph.edges,
+    subgraphs: Object.fromEntries(graph.subgraphs),
+    classDefs: Object.fromEntries(graph.classDefs),
+    nodeStyles: Object.fromEntries(graph.nodeStyles),
+    linkStyles: Object.fromEntries(graph.linkStyles),
+    classAssignments: Object.fromEntries(graph.classAssignments),
+    filePath: graph.filePath,
+    flags: Object.fromEntries(graph.flags),
+    statuses: Object.fromEntries(graph.statuses)
+  };
+}
+
+// src/project/manager.ts
+import { statSync } from "fs";
+var ProjectManager = class {
+  projects = /* @__PURE__ */ new Map();
+  /**
+   * Register a project directory and return its DiagramService.
+   * If the directory is already registered, returns the existing service.
+   * Throws if the directory does not exist.
+   */
+  addProject(rootDir) {
+    const existing = this.projects.get(rootDir);
+    if (existing) {
+      return existing;
+    }
+    const stat = statSync(rootDir);
+    if (!stat.isDirectory()) {
+      throw new Error(`Not a directory: ${rootDir}`);
+    }
+    const service = new DiagramService(rootDir);
+    this.projects.set(rootDir, service);
+    return service;
+  }
+  /**
+   * Remove a project from management.
+   * Returns true if it was registered, false otherwise.
+   */
+  removeProject(rootDir) {
+    return this.projects.delete(rootDir);
+  }
+  /**
+   * Get the DiagramService for a registered project directory.
+   * Returns undefined if the directory is not registered.
+   */
+  getProject(rootDir) {
+    return this.projects.get(rootDir);
+  }
+  /**
+   * List all registered project root directories.
+   */
+  listProjects() {
+    return Array.from(this.projects.keys());
+  }
+  /**
+   * Discover .mmd files across all registered projects.
+   * Returns a map of rootDir to file lists.
+   */
+  async discoverAll() {
+    const results = /* @__PURE__ */ new Map();
+    for (const [rootDir, service] of this.projects) {
+      const files = await service.listFiles();
+      results.set(rootDir, files);
+    }
+    return results;
+  }
+};
+export {
+  DiagramService,
+  ProjectManager,
+  discoverMmdFiles,
+  injectAnnotations,
+  parseAllAnnotations,
+  parseDiagramContent,
+  parseDiagramType,
+  parseFlags,
+  parseMermaidToGraph,
+  serializeGraphModel,
+  serializeGraphToMermaid,
+  stripAnnotations,
+  validateMermaidSyntax
+};
+//# sourceMappingURL=index.js.map