@crafter/cli-tree 0.1.0

package/dist/chunk-pkfpaae1.js

@@ -0,0 +1,678 @@
+import {
+  createGrid,
+  encodeAnsi,
+  encodeHtml,
+  encodeString,
+  writeText
+} from "./chunk-q4se2rwe.js";
+
+// src/flow/yaml.ts
+function parseYaml(text) {
+  const lines = text.split(`
+`);
+  const cleaned = [];
+  for (let i = 0;i < lines.length; i++) {
+    const raw = lines[i];
+    const commentIdx = findCommentStart(raw);
+    const withoutComment = commentIdx >= 0 ? raw.slice(0, commentIdx) : raw;
+    const trimmed = withoutComment.trimEnd();
+    if (!trimmed.trim())
+      continue;
+    const indent = trimmed.length - trimmed.trimStart().length;
+    cleaned.push({ indent, content: trimmed.trim(), lineNum: i + 1 });
+  }
+  const result = parseBlock(cleaned, 0, 0);
+  return result.value;
+}
+function findCommentStart(line) {
+  let inString = null;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (inString) {
+      if (ch === inString && line[i - 1] !== "\\")
+        inString = null;
+    } else {
+      if (ch === '"' || ch === "'")
+        inString = ch;
+      else if (ch === "#" && (i === 0 || line[i - 1] === " " || line[i - 1] === "\t")) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function parseBlock(lines, startIdx, baseIndent) {
+  if (startIdx >= lines.length)
+    return { value: null, nextIdx: startIdx };
+  const first = lines[startIdx];
+  if (first.indent < baseIndent)
+    return { value: null, nextIdx: startIdx };
+  if (first.content.startsWith("- ") || first.content === "-") {
+    return parseList(lines, startIdx, first.indent);
+  }
+  if (first.content.includes(":")) {
+    return parseMap(lines, startIdx, first.indent);
+  }
+  return { value: parseScalar(first.content), nextIdx: startIdx + 1 };
+}
+function parseList(lines, startIdx, listIndent) {
+  const items = [];
+  let i = startIdx;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.indent < listIndent)
+      break;
+    if (line.indent > listIndent) {
+      i++;
+      continue;
+    }
+    if (!line.content.startsWith("- ") && line.content !== "-")
+      break;
+    const itemContent = line.content === "-" ? "" : line.content.slice(2);
+    if (!itemContent) {
+      const childIndent = listIndent + 2;
+      const next = parseBlock(lines, i + 1, childIndent);
+      items.push(next.value);
+      i = next.nextIdx;
+    } else if (itemContent.includes(":") && !isFlowScalar(itemContent)) {
+      const inlineIndent = listIndent + 2;
+      const synthetic = [
+        { indent: inlineIndent, content: itemContent, lineNum: line.lineNum },
+        ...lines.slice(i + 1)
+      ];
+      const mapResult = parseMap(synthetic, 0, inlineIndent);
+      items.push(mapResult.value);
+      i = i + 1 + (mapResult.nextIdx - 1);
+    } else {
+      items.push(parseScalar(itemContent));
+      i++;
+    }
+  }
+  return { value: items, nextIdx: i };
+}
+function parseMap(lines, startIdx, mapIndent) {
+  const map = {};
+  let i = startIdx;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.indent < mapIndent)
+      break;
+    if (line.indent > mapIndent) {
+      i++;
+      continue;
+    }
+    const colonIdx = findUnquotedColon(line.content);
+    if (colonIdx < 0)
+      break;
+    const key = line.content.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
+    const rest = line.content.slice(colonIdx + 1).trim();
+    if (!rest) {
+      const next = parseBlock(lines, i + 1, mapIndent + 1);
+      map[key] = next.value;
+      i = next.nextIdx;
+    } else if (rest.startsWith("[") && rest.endsWith("]")) {
+      map[key] = parseInlineList(rest);
+      i++;
+    } else if (rest.startsWith("{") && rest.endsWith("}")) {
+      map[key] = parseInlineMap(rest);
+      i++;
+    } else {
+      map[key] = parseScalar(rest);
+      i++;
+    }
+  }
+  return { value: map, nextIdx: i };
+}
+function findUnquotedColon(text) {
+  let inString = null;
+  let bracket = 0;
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === inString && text[i - 1] !== "\\")
+        inString = null;
+    } else {
+      if (ch === '"' || ch === "'")
+        inString = ch;
+      else if (ch === "[" || ch === "{")
+        bracket++;
+      else if (ch === "]" || ch === "}")
+        bracket--;
+      else if (ch === ":" && bracket === 0)
+        return i;
+    }
+  }
+  return -1;
+}
+function parseScalar(text) {
+  const trimmed = text.trim();
+  if (trimmed === "" || trimmed === "null" || trimmed === "~")
+    return null;
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\'/g, "'");
+  }
+  const num = Number(trimmed);
+  if (!Number.isNaN(num) && /^-?\d+(\.\d+)?$/.test(trimmed))
+    return num;
+  return trimmed;
+}
+function isFlowScalar(text) {
+  return text.startsWith("[") || text.startsWith("{") || text.startsWith('"') || text.startsWith("'");
+}
+function parseInlineList(text) {
+  const inner = text.slice(1, -1).trim();
+  if (!inner)
+    return [];
+  return splitTopLevel(inner, ",").map((item) => parseScalar(item.trim()));
+}
+function parseInlineMap(text) {
+  const inner = text.slice(1, -1).trim();
+  if (!inner)
+    return {};
+  const result = {};
+  for (const pair of splitTopLevel(inner, ",")) {
+    const colonIdx = findUnquotedColon(pair);
+    if (colonIdx < 0)
+      continue;
+    const key = pair.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
+    const val = pair.slice(colonIdx + 1).trim();
+    result[key] = parseScalar(val);
+  }
+  return result;
+}
+function splitTopLevel(text, sep) {
+  const parts = [];
+  let depth = 0;
+  let inString = null;
+  let current = "";
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === inString && text[i - 1] !== "\\")
+        inString = null;
+      current += ch;
+    } else {
+      if (ch === '"' || ch === "'") {
+        inString = ch;
+        current += ch;
+      } else if (ch === "[" || ch === "{") {
+        depth++;
+        current += ch;
+      } else if (ch === "]" || ch === "}") {
+        depth--;
+        current += ch;
+      } else if (ch === sep && depth === 0) {
+        parts.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+  }
+  if (current)
+    parts.push(current);
+  return parts;
+}
+
+// src/flow/parse.ts
+function parseWorkflow(yamlText) {
+  const raw = parseYaml(yamlText);
+  if (!isObject(raw)) {
+    throw new Error("Workflow YAML must be a map at the top level");
+  }
+  const name = asString(raw.name, "name");
+  const cli = asString(raw.cli, "cli");
+  const description = raw.description ? asString(raw.description, "description") : undefined;
+  const version = raw.version ? asString(raw.version, "version") : undefined;
+  const nodes = parseNodes(raw.nodes);
+  const edges = parseEdges(raw.edges, nodes);
+  const workflow = { name, cli, nodes, edges };
+  if (description)
+    workflow.description = description;
+  if (version)
+    workflow.version = version;
+  return workflow;
+}
+function parseNodes(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("'nodes' must be a list");
+  }
+  return raw.map((item, idx) => {
+    if (!isObject(item)) {
+      throw new Error(`nodes[${idx}] must be a map`);
+    }
+    const id = asString(item.id, `nodes[${idx}].id`);
+    const cmdRaw = item.command;
+    let command;
+    if (typeof cmdRaw === "string") {
+      command = cmdRaw.split(/\s+/).filter(Boolean);
+    } else if (Array.isArray(cmdRaw)) {
+      command = cmdRaw.map((c) => String(c));
+    } else {
+      throw new Error(`nodes[${idx}].command must be a string or list`);
+    }
+    const node = { id, command };
+    if (typeof item.label === "string")
+      node.label = item.label;
+    if (typeof item.description === "string")
+      node.description = item.description;
+    if (typeof item.optional === "boolean")
+      node.optional = item.optional;
+    return node;
+  });
+}
+function parseEdges(raw, nodes) {
+  if (!raw)
+    return inferSequentialEdges(nodes);
+  if (!Array.isArray(raw)) {
+    throw new Error("'edges' must be a list");
+  }
+  return raw.map((item, idx) => {
+    if (typeof item === "string") {
+      const parts = item.split("->").map((s) => s.trim());
+      if (parts.length !== 2) {
+        throw new Error(`edges[${idx}] string must be "from -> to"`);
+      }
+      return { from: parts[0], to: parts[1] };
+    }
+    if (!isObject(item)) {
+      throw new Error(`edges[${idx}] must be a map or string`);
+    }
+    const edge = {
+      from: asString(item.from, `edges[${idx}].from`),
+      to: asString(item.to, `edges[${idx}].to`)
+    };
+    if (typeof item.condition === "string")
+      edge.condition = item.condition;
+    if (typeof item.label === "string")
+      edge.label = item.label;
+    return edge;
+  });
+}
+function inferSequentialEdges(nodes) {
+  const edges = [];
+  for (let i = 0;i < nodes.length - 1; i++) {
+    edges.push({ from: nodes[i].id, to: nodes[i + 1].id });
+  }
+  return edges;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value, field) {
+  if (typeof value !== "string") {
+    throw new Error(`${field} must be a string`);
+  }
+  return value;
+}
+// src/flow/validate.ts
+function validateWorkflow(workflow, tree) {
+  const errors = [];
+  const nodeIds = new Set(workflow.nodes.map((n) => n.id));
+  if (nodeIds.size !== workflow.nodes.length) {
+    errors.push({ severity: "error", message: "Duplicate node IDs found" });
+  }
+  for (const node of workflow.nodes) {
+    if (node.command.length === 0) {
+      errors.push({ node: node.id, severity: "error", message: `Node "${node.id}" has empty command` });
+    }
+    if (node.command[0] !== workflow.cli) {
+      errors.push({
+        node: node.id,
+        severity: "warning",
+        message: `Node "${node.id}" command "${node.command[0]}" does not match workflow cli "${workflow.cli}"`
+      });
+    }
+  }
+  for (const edge of workflow.edges) {
+    if (!nodeIds.has(edge.from)) {
+      errors.push({
+        edge: { from: edge.from, to: edge.to },
+        severity: "error",
+        message: `Edge references unknown node "${edge.from}"`
+      });
+    }
+    if (!nodeIds.has(edge.to)) {
+      errors.push({
+        edge: { from: edge.from, to: edge.to },
+        severity: "error",
+        message: `Edge references unknown node "${edge.to}"`
+      });
+    }
+  }
+  if (hasCycle(workflow)) {
+    errors.push({ severity: "error", message: "Workflow contains a cycle — DAGs only" });
+  }
+  if (tree) {
+    for (const node of workflow.nodes) {
+      const subcommand = node.command.slice(1).filter((arg) => !arg.startsWith("-") && !arg.startsWith("$") && /^[a-z]/i.test(arg));
+      if (subcommand.length === 0) {
+        node.ref = tree;
+        continue;
+      }
+      const firstMatch = tree.subcommands?.find((s) => s.name === subcommand[0] || s.aliases?.includes(subcommand[0]));
+      if (!firstMatch) {
+        errors.push({
+          node: node.id,
+          severity: "warning",
+          message: `Command "${node.command.join(" ")}" not found in ${workflow.cli} tree`
+        });
+      } else {
+        node.ref = findInTree(tree, subcommand);
+      }
+    }
+  }
+  return {
+    valid: errors.filter((e) => e.severity === "error").length === 0,
+    errors
+  };
+}
+function hasCycle(workflow) {
+  const adj = new Map;
+  for (const node of workflow.nodes)
+    adj.set(node.id, []);
+  for (const edge of workflow.edges) {
+    adj.get(edge.from)?.push(edge.to);
+  }
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = new Map;
+  for (const node of workflow.nodes)
+    color.set(node.id, WHITE);
+  function visit(u) {
+    color.set(u, GRAY);
+    for (const v of adj.get(u) ?? []) {
+      const c = color.get(v);
+      if (c === GRAY)
+        return true;
+      if (c === WHITE && visit(v))
+        return true;
+    }
+    color.set(u, BLACK);
+    return false;
+  }
+  for (const node of workflow.nodes) {
+    if (color.get(node.id) === WHITE && visit(node.id))
+      return true;
+  }
+  return false;
+}
+function findInTree(tree, path) {
+  let current = tree;
+  for (const segment of path) {
+    const child = current?.subcommands?.find((s) => s.name === segment || s.aliases?.includes(segment));
+    if (!child)
+      return current;
+    current = child;
+  }
+  return current;
+}
+// src/flow/layout.ts
+function computeLayout(workflow, opts = {}) {
+  const boxPaddingX = opts.boxPaddingX ?? 2;
+  const colGap = opts.colGap ?? 4;
+  const rowGap = opts.rowGap ?? 2;
+  const minBoxWidth = opts.minBoxWidth ?? 8;
+  const ranks = computeRanks(workflow);
+  const byRank = groupByRank(workflow.nodes, ranks);
+  const maxRank = Math.max(0, ...Array.from(ranks.values()));
+  const allWidths = workflow.nodes.map((n) => boxWidthFor(n, boxPaddingX, minBoxWidth));
+  const uniformWidth = Math.max(...allWidths);
+  const maxPerRank = Math.max(1, ...Array.from(byRank.values()).map((v) => v.length));
+  const totalRowWidth = maxPerRank * uniformWidth + (maxPerRank - 1) * colGap;
+  const layoutNodes = [];
+  const boxHeight = 3;
+  let currentY = 0;
+  for (let r = 0;r <= maxRank; r++) {
+    const rankNodes = byRank.get(r) ?? [];
+    const count = rankNodes.length;
+    const rowWidth = count * uniformWidth + (count - 1) * colGap;
+    const startX = Math.floor((totalRowWidth - rowWidth) / 2);
+    for (let i = 0;i < rankNodes.length; i++) {
+      const node = rankNodes[i];
+      const x = startX + i * (uniformWidth + colGap);
+      layoutNodes.push({
+        id: node.id,
+        node,
+        col: i,
+        row: r,
+        width: uniformWidth,
+        height: boxHeight,
+        x,
+        y: currentY
+      });
+    }
+    currentY += boxHeight + rowGap;
+  }
+  const totalWidth = Math.max(0, ...layoutNodes.map((n) => n.x + n.width));
+  const totalHeight = Math.max(0, ...layoutNodes.map((n) => n.y + n.height));
+  const edges = workflow.edges.map((e) => ({
+    from: e.from,
+    to: e.to,
+    edge: e
+  }));
+  return { nodes: layoutNodes, edges, totalWidth, totalHeight };
+}
+function computeRanks(workflow) {
+  const ranks = new Map;
+  const inEdges = new Map;
+  for (const node of workflow.nodes) {
+    ranks.set(node.id, 0);
+    inEdges.set(node.id, []);
+  }
+  for (const edge of workflow.edges) {
+    inEdges.get(edge.to)?.push(edge.from);
+  }
+  const visiting = new Set;
+  function visit(id) {
+    if (visiting.has(id))
+      return ranks.get(id) ?? 0;
+    visiting.add(id);
+    const parents = inEdges.get(id) ?? [];
+    if (parents.length === 0) {
+      ranks.set(id, 0);
+    } else {
+      const maxParent = Math.max(...parents.map((p) => visit(p)));
+      ranks.set(id, maxParent + 1);
+    }
+    visiting.delete(id);
+    return ranks.get(id);
+  }
+  for (const node of workflow.nodes) {
+    visit(node.id);
+  }
+  return ranks;
+}
+function groupByRank(nodes, ranks) {
+  const byRank = new Map;
+  for (const node of nodes) {
+    const r = ranks.get(node.id) ?? 0;
+    if (!byRank.has(r))
+      byRank.set(r, []);
+    byRank.get(r).push(node);
+  }
+  return byRank;
+}
+function boxWidthFor(node, padding, minWidth) {
+  const label = node.label ?? node.id;
+  const contentWidth = label.length;
+  return Math.max(minWidth, contentWidth + padding * 2 + 2);
+}
+function findNode(layout, id) {
+  return layout.nodes.find((n) => n.id === id);
+}
+// src/flow/render.ts
+var BOX = {
+  topLeft: "┌",
+  topRight: "┐",
+  botLeft: "└",
+  botRight: "┘",
+  horiz: "─",
+  vert: "│",
+  arrowDown: "▼",
+  arrowRight: "►",
+  junctionDown: "┬",
+  junctionUp: "┴",
+  junctionLeft: "┤",
+  junctionRight: "├",
+  cross: "┼"
+};
+var COLOR = {
+  boxFrame: "gray",
+  label: "cyan",
+  optional: "yellow",
+  arrow: "gray",
+  title: "magenta",
+  description: "gray"
+};
+function renderFlow(workflow, opts = {}) {
+  const useColor = opts.color ?? true;
+  const showDescriptions = opts.showDescriptions ?? true;
+  const compact = opts.compact ?? false;
+  const layout = computeLayout(workflow);
+  const titleLines = buildTitle(workflow, showDescriptions && !compact);
+  const titleOffset = titleLines.length;
+  const flowHeight = layout.totalHeight;
+  const legendLines = compact ? [] : buildLegend(workflow);
+  const legendOffset = legendLines.length > 0 ? legendLines.length + 1 : 0;
+  const totalHeight = titleOffset + flowHeight + legendOffset + 1;
+  const totalWidth = Math.max(layout.totalWidth, maxLineLength(titleLines), maxLineLength(legendLines)) + 2;
+  const grid = createGrid(totalWidth);
+  for (let i = 0;i < totalHeight; i++)
+    grid.addRow();
+  let row = 0;
+  for (const line of titleLines) {
+    writeText(grid, 0, row, line.text, useColor ? line.color : null);
+    row++;
+  }
+  for (const node of layout.nodes) {
+    drawBox(grid, node, row + node.y, useColor);
+  }
+  for (const edge of layout.edges) {
+    const from = findNode(layout, edge.from);
+    const to = findNode(layout, edge.to);
+    if (!from || !to)
+      continue;
+    drawEdge(grid, from, to, row, useColor);
+  }
+  if (legendLines.length > 0) {
+    let legendRow = row + flowHeight + 1;
+    for (const line of legendLines) {
+      writeText(grid, 0, legendRow, line.text, useColor ? line.color : null);
+      legendRow++;
+    }
+  }
+  return grid;
+}
+function buildTitle(workflow, showDescription) {
+  const lines = [];
+  const title = `${workflow.cli} · ${workflow.name}`;
+  lines.push({ text: title, color: COLOR.title });
+  if (showDescription && workflow.description) {
+    lines.push({ text: workflow.description, color: COLOR.description });
+  }
+  lines.push({ text: "", color: null });
+  return lines;
+}
+function buildLegend(workflow) {
+  const hasOptional = workflow.nodes.some((n) => n.optional);
+  if (!hasOptional)
+    return [];
+  return [
+    { text: "  ─── required   ┈┈┈ optional", color: COLOR.description }
+  ];
+}
+function maxLineLength(lines) {
+  return lines.reduce((max, l) => Math.max(max, l.text.length), 0);
+}
+function drawBox(grid, node, rowOffset, useColor) {
+  const y = rowOffset;
+  const x = node.x;
+  const w = node.width;
+  const label = node.node.label ?? node.node.id;
+  const isOptional = node.node.optional;
+  const labelColor = useColor ? isOptional ? COLOR.optional : COLOR.label : null;
+  const frameColor = useColor ? COLOR.boxFrame : null;
+  const horizChar = isOptional ? "┈" : BOX.horiz;
+  const vertChar = isOptional ? "┊" : BOX.vert;
+  const tlChar = isOptional ? "┌" : BOX.topLeft;
+  const trChar = isOptional ? "┐" : BOX.topRight;
+  const blChar = isOptional ? "└" : BOX.botLeft;
+  const brChar = isOptional ? "┘" : BOX.botRight;
+  writeText(grid, x, y, tlChar, frameColor);
+  for (let i = 1;i < w - 1; i++) {
+    writeText(grid, x + i, y, horizChar, frameColor);
+  }
+  writeText(grid, x + w - 1, y, trChar, frameColor);
+  writeText(grid, x, y + 1, vertChar, frameColor);
+  const labelStart = x + Math.floor((w - label.length) / 2);
+  writeText(grid, labelStart, y + 1, label, labelColor);
+  writeText(grid, x + w - 1, y + 1, vertChar, frameColor);
+  writeText(grid, x, y + 2, blChar, frameColor);
+  for (let i = 1;i < w - 1; i++) {
+    writeText(grid, x + i, y + 2, horizChar, frameColor);
+  }
+  writeText(grid, x + w - 1, y + 2, brChar, frameColor);
+}
+function drawEdge(grid, from, to, rowOffset, useColor) {
+  const color = useColor ? COLOR.arrow : null;
+  const fromCenterX = from.x + Math.floor(from.width / 2);
+  const toCenterX = to.x + Math.floor(to.width / 2);
+  const fromBottomY = rowOffset + from.y + from.height - 1;
+  const toTopY = rowOffset + to.y;
+  if (to.row > from.row) {
+    if (fromCenterX === toCenterX) {
+      for (let y = fromBottomY + 1;y < toTopY - 1; y++) {
+        writeText(grid, fromCenterX, y, BOX.vert, color);
+      }
+      writeText(grid, fromCenterX, toTopY - 1, BOX.arrowDown, color);
+    } else {
+      const midY = fromBottomY + 1;
+      writeText(grid, fromCenterX, midY, BOX.vert, color);
+      const bendY = midY + 1;
+      const startX = Math.min(fromCenterX, toCenterX);
+      const endX = Math.max(fromCenterX, toCenterX);
+      for (let x = startX + 1;x < endX; x++) {
+        writeText(grid, x, bendY, BOX.horiz, color);
+      }
+      if (fromCenterX < toCenterX) {
+        writeText(grid, fromCenterX, bendY, "└", color);
+        writeText(grid, toCenterX, bendY, "┐", color);
+      } else {
+        writeText(grid, fromCenterX, bendY, "┘", color);
+        writeText(grid, toCenterX, bendY, "┌", color);
+      }
+      for (let y = bendY + 1;y < toTopY - 1; y++) {
+        writeText(grid, toCenterX, y, BOX.vert, color);
+      }
+      writeText(grid, toCenterX, toTopY - 1, BOX.arrowDown, color);
+    }
+  } else if (to.row === from.row) {
+    const y = rowOffset + from.y + Math.floor(from.height / 2);
+    const startX = from.x + from.width;
+    const endX = to.x;
+    for (let x = startX;x < endX - 1; x++) {
+      writeText(grid, x, y, BOX.horiz, color);
+    }
+    writeText(grid, endX - 1, y, BOX.arrowRight, color);
+  }
+}
+// src/flow/encode.ts
+function flowToAnsi(workflow, opts) {
+  return encodeAnsi(renderFlow(workflow, opts));
+}
+function flowToString(workflow, opts) {
+  return encodeString(renderFlow(workflow, opts));
+}
+function flowToHtml(workflow, opts) {
+  return encodeHtml(renderFlow(workflow, opts));
+}
+function printFlow(workflow, opts) {
+  console.log(flowToAnsi(workflow, opts));
+}
+export { parseYaml, parseWorkflow, validateWorkflow, computeLayout, renderFlow, flowToAnsi, flowToString, flowToHtml, printFlow };
+
+//# debugId=C94663974D261F8E64756E2164756E21