@bovinphang/frontend-craft 2.6.0 → 2.8.0

package/localized/zh-CN/skills/fec-drawio-studio/scripts/diagram-url.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import zlib from "node:zlib";
+import { parseArgs, readText } from "./studio-core.mjs";
+
+const args = parseArgs(process.argv.slice(2));
+const input = args._[0];
+if (!input) {
+  console.error(
+    "usage: node diagram-url.mjs <diagram-file> [--edit|--create] [--type xml|mermaid|csv] [--lightbox] [--dark true|false|auto] [--base-url URL] [--json|--shortcut]",
+  );
+  process.exit(2);
+}
+
+export function encodeDiagramXml(xml) {
+  const encoded = encodeURIComponent(xml);
+  return zlib.deflateRawSync(Buffer.from(encoded, "utf8")).toString("base64");
+}
+
+export function viewerUrl(xml, options = {}) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://viewer.diagrams.net/");
+  return `${baseUrl}?highlight=0000ff&edit=_blank#R${encodeDiagramXml(xml)}`;
+}
+
+export function editorUrl(xml, options = {}) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://app.diagrams.net/");
+  return `${baseUrl}?offline=1#R${encodeDiagramXml(xml)}`;
+}
+
+export function createUrl(content, options = {}) {
+  const type = normalizeType(options.type);
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://app.diagrams.net/");
+  const params = new URLSearchParams();
+  if (options.lightbox) {
+    params.set("lightbox", "1");
+    params.set("edit", "_blank");
+  } else {
+    params.set("grid", "0");
+    params.set("pv", "0");
+    params.set("edit", "_blank");
+  }
+  params.set("border", String(options.border ?? 10));
+  const dark = normalizeDark(options.dark);
+  if (dark === true) params.set("dark", "1");
+
+  const payload = encodeURIComponent(
+    JSON.stringify({
+      type,
+      compressed: true,
+      data: encodeDiagramXml(content),
+    }),
+  );
+  const query = params.toString();
+  return `${baseUrl}${query ? `?${query}` : ""}#create=${payload}`;
+}
+
+export function internetShortcut(url) {
+  return `[InternetShortcut]\r\nURL=${url}\r\n`;
+}
+
+function normalizeType(value = "xml") {
+  if (["xml", "mermaid", "csv"].includes(value)) return value;
+  throw new Error(`Unsupported diagram type "${value}". Expected xml, mermaid, or csv.`);
+}
+
+function normalizeDark(value = "auto") {
+  if (value === true || value === "true") return true;
+  if (value === false || value === "false") return false;
+  if (value === "auto" || value === undefined) return "auto";
+  throw new Error(`Unsupported dark mode "${value}". Expected true, false, or auto.`);
+}
+
+function normalizeBaseUrl(value) {
+  return String(value).replace(/[?#].*$/, "").replace(/\/?$/, "/");
+}
+
+try {
+  const content = readText(input);
+  const type = normalizeType(args.type ?? "xml");
+  if (type !== "xml" && !args.create) {
+    throw new Error("Mermaid and CSV inputs require --create because viewer/editor #R URLs only load XML.");
+  }
+  const options = {
+    baseUrl: args.baseUrl,
+    border: args.border,
+    dark: args.dark,
+    lightbox: Boolean(args.lightbox),
+    type,
+  };
+  const mode = args.create ? "create" : args.edit ? "edit" : "view";
+  const url = args.create ? createUrl(content, options) : args.edit ? editorUrl(content, options) : viewerUrl(content, options);
+  const shortcut = internetShortcut(url);
+  if (args.shortcut) {
+    process.stdout.write(shortcut);
+  } else if (args.json) {
+    process.stdout.write(`${JSON.stringify({ url, mode, type, windowsShortcut: shortcut }, null, 2)}\n`);
+  } else {
+    process.stdout.write(`${url}\n`);
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}

package/localized/zh-CN/skills/fec-drawio-studio/scripts/drawio-export.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { formatResult, parseArgs } from "./studio-core.mjs";
+
+const INSTALL_HINTS = [
+  "draw.io desktop CLI was not found.",
+  "Install draw.io desktop, then rerun the export.",
+  "Windows: winget install JGraph.Draw",
+  "macOS: brew install --cask drawio",
+  "Linux: install drawio from your package manager or snap install drawio",
+  "Manual download: https://github.com/jgraph/drawio-desktop/releases",
+];
+
+export function buildExportPlan(input, args = {}, env = process.env, platform = process.platform) {
+  const drawio = findDrawio(args.drawio, env, platform);
+  if (!drawio) {
+    return {
+      ok: false,
+      title: "Draw.io Export",
+      errors: [INSTALL_HINTS.join("\n")],
+      command: null,
+    };
+  }
+
+  const format = String(args.format ?? "png");
+  const output = String(args.output ?? defaultOutput(input, format));
+  const commandArgs = ["-x", "-f", format];
+  if (args.embed) commandArgs.push("-e");
+  if (args.scale) commandArgs.push("-s", String(args.scale));
+  if (args.width) commandArgs.push("--width", String(args.width));
+  if (args.border) commandArgs.push("--border", String(args.border));
+  if (args.crop) commandArgs.push("--crop");
+  if (args.page !== undefined) commandArgs.push("-p", String(args.page));
+  commandArgs.push("-o", output, input);
+
+  return {
+    ok: true,
+    title: "Draw.io Export",
+    drawio,
+    command: [drawio, ...commandArgs],
+    output,
+    format,
+    dryRun: Boolean(args.dryRun),
+    errors: [],
+  };
+}
+
+export function findDrawio(explicitPath, env = process.env, platform = process.platform) {
+  if (explicitPath) return existingFile(explicitPath);
+
+  for (const command of ["drawio", "draw.io"]) {
+    const found = findOnPath(command, env, platform);
+    if (found) return found;
+  }
+
+  for (const candidate of defaultCandidates(env, platform)) {
+    const found = existingFile(candidate);
+    if (found) return found;
+  }
+
+  return null;
+}
+
+function findOnPath(command, env, platform) {
+  const pathValue = env.PATH ?? env.Path ?? "";
+  const dirs = pathValue.split(path.delimiter).filter(Boolean);
+  const extensions = platform === "win32" ? pathExtensions(env) : [""];
+  for (const dir of dirs) {
+    for (const ext of extensions) {
+      const candidate = path.join(dir, command.endsWith(ext) ? command : `${command}${ext}`);
+      const found = existingFile(candidate);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function pathExtensions(env) {
+  const configured = env.PATHEXT ? env.PATHEXT.split(";").filter(Boolean) : [".EXE", ".CMD", ".BAT", ""];
+  return [...new Set(["", ...configured, ...configured.map((item) => item.toLowerCase())])];
+}
+
+function defaultCandidates(env, platform) {
+  if (platform === "win32") {
+    return [
+      path.join(env.ProgramFiles ?? "C:\\Program Files", "draw.io", "draw.io.exe"),
+      path.join(env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)", "draw.io", "draw.io.exe"),
+      path.join(env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local"), "Programs", "draw.io", "draw.io.exe"),
+    ];
+  }
+  if (platform === "darwin") {
+    return ["/Applications/draw.io.app/Contents/MacOS/draw.io"];
+  }
+  return ["/usr/bin/drawio", "/usr/local/bin/drawio", "/snap/bin/drawio"];
+}
+
+function existingFile(candidate) {
+  if (!candidate) return null;
+  const resolved = path.resolve(candidate);
+  return fs.existsSync(resolved) && fs.statSync(resolved).isFile() ? resolved : null;
+}
+
+function defaultOutput(input, format) {
+  return `${input.replace(/\.(drawio|xml)$/i, "")}.${format}`;
+}
+
+function printFailure(plan, args) {
+  const output = formatResult(plan, args.formatOutput ?? (args.json ? "json" : "markdown"));
+  process.stderr.write(output);
+}
+
+const args = parseArgs(process.argv.slice(2));
+const input = args._[0];
+if (!input) {
+  console.error("usage: node drawio-export.mjs <file.drawio> [--format png|svg|pdf] [--output file] [--scale 2] [--width 2000] [--border 20] [--dry-run] [--json]");
+  process.exit(2);
+}
+
+const plan = buildExportPlan(input, args);
+if (!plan.ok) {
+  printFailure(plan, args);
+  process.exit(1);
+}
+
+if (args.dryRun) {
+  process.stdout.write(formatResult(plan, args.formatOutput ?? (args.json ? "json" : "markdown")));
+  process.exit(0);
+}
+
+const result = spawnSync(plan.command[0], plan.command.slice(1), { stdio: "inherit" });
+process.exit(result.status ?? 1);

package/localized/zh-CN/skills/fec-drawio-studio/scripts/layout-graph.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { parseArgs, printOrWrite, readText, snap, writeText, xmlEscape } from "./studio-core.mjs";
+
+const DEFAULT_W = 140;
+const DEFAULT_H = 64;
+const NODE_STYLE = "rounded=1;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;";
+const EDGE_STYLE = "edgeStyle=orthogonalEdgeStyle;rounded=1;orthogonalLoop=1;jettySize=auto;html=1;";
+const PALETTE = [
+  ["#dae8fc", "#6c8ebf"], ["#d5e8d4", "#82b366"], ["#ffe6cc", "#d79b00"],
+  ["#e1d5e7", "#9673a6"], ["#fff2cc", "#d6b656"], ["#f8cecc", "#b85450"],
+];
+
+export function buildDot(graph) {
+  const direction = String(graph.direction ?? "TB").toUpperCase() === "LR" ? "LR" : "TB";
+  const lines = [`digraph G { rankdir=${direction}; splines=ortho; node [shape=box fixedsize=true];`];
+  for (const node of graph.nodes) {
+    lines.push(`"${escapeDot(node.id)}" [width=${Number(node.width ?? DEFAULT_W) / 72} height=${Number(node.height ?? DEFAULT_H) / 72}];`);
+  }
+  for (const edge of graph.edges ?? []) lines.push(`"${escapeDot(edge.source)}" -> "${escapeDot(edge.target)}";`);
+  lines.push("}");
+  return lines.join("\n");
+}
+
+export function runDot(dot) {
+  const proc = spawnSync("dot", ["-Tplain"], { input: dot, encoding: "utf8" });
+  if (proc.error?.code === "ENOENT") throw new Error("Graphviz `dot` not found on PATH");
+  if (proc.status !== 0) throw new Error(`Graphviz failed: ${proc.stderr.trim()}`);
+  const pos = new Map();
+  let height = 0;
+  for (const line of proc.stdout.split(/\r?\n/)) {
+    const parts = splitPlain(line);
+    if (parts[0] === "graph") height = Number(parts[3]);
+    if (parts[0] === "node") pos.set(parts[1], { x: Number(parts[2]), y: Number(parts[3]) });
+  }
+  return { height, pos };
+}
+
+export function graphToDrawio(graph, layout) {
+  const groups = [...new Set((graph.nodes ?? []).map((node) => node.group).filter(Boolean))];
+  const groupColor = (group) => PALETTE[Math.max(0, groups.indexOf(group)) % PALETTE.length];
+  const cells = [];
+  const manifest = { nodes: {}, edges: graph.edges ?? [] };
+  for (const node of graph.nodes ?? []) {
+    const p = layout.pos.get(node.id);
+    if (!p) continue;
+    const w = Number(node.width ?? DEFAULT_W);
+    const h = Number(node.height ?? DEFAULT_H);
+    const x = snap(p.x * 72 - w / 2 + 40);
+    const y = snap((layout.height - p.y) * 72 - h / 2 + 40);
+    const style = node.style ?? (node.group ? tintStyle(groupColor(node.group)) : NODE_STYLE);
+    manifest.nodes[node.id] = { x, y, width: w, height: h, group: node.group ?? null };
+    cells.push(`        <mxCell id="${xmlEscape(node.id)}" value="${xmlEscape(node.label ?? node.id)}" style="${xmlEscape(style)}" vertex="1" parent="1">
+          <mxGeometry x="${x}" y="${y}" width="${w}" height="${h}" as="geometry"/>
+        </mxCell>`);
+  }
+  let edgeIndex = 0;
+  for (const edge of graph.edges ?? []) {
+    cells.push(`        <mxCell id="edge_${edgeIndex++}" value="${xmlEscape(edge.label ?? "")}" style="${EDGE_STYLE}" edge="1" parent="1" source="${xmlEscape(edge.source)}" target="${xmlEscape(edge.target)}">
+          <mxGeometry relative="1" as="geometry"/>
+        </mxCell>`);
+  }
+  return {
+    manifest,
+    xml: `<mxfile host="drawio">
+  <diagram name="Page-1">
+    <mxGraphModel grid="1" gridSize="10" page="1" pageWidth="1100" pageHeight="850">
+      <root>
+        <mxCell id="0"/>
+        <mxCell id="1" parent="0"/>
+${cells.join("\n")}
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>
+`,
+  };
+}
+
+function tintStyle([fill, stroke]) {
+  return `rounded=1;whiteSpace=wrap;html=1;fillColor=${fill};strokeColor=${stroke};`;
+}
+
+function escapeDot(value) {
+  return String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+
+function splitPlain(line) {
+  return line.match(/"[^"]*"|\S+/g)?.map((part) => part.replace(/^"|"$/g, "")) ?? [];
+}
+
+const args = parseArgs(process.argv.slice(2));
+const input = args._[0];
+if (!input) {
+  console.error("usage: node layout-graph.mjs graph.json --output diagram.drawio [--manifest layout.json]");
+  process.exit(2);
+}
+try {
+  const graph = JSON.parse(readText(input));
+  const rendered = graphToDrawio(graph, runDot(buildDot(graph)));
+  printOrWrite(rendered.xml, args.output);
+  if (args.manifest) writeText(args.manifest, `${JSON.stringify(rendered.manifest, null, 2)}\n`);
+  if (!args.output) process.stderr.write(`rendered ${graph.nodes.length} nodes\n`);
+} catch (error) {
+  console.error(`error: ${error.message}`);
+  process.exit(1);
+}

package/localized/zh-CN/skills/fec-drawio-studio/scripts/png-embed-fix.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { parseArgs } from "./studio-core.mjs";
+
+const IEND = Buffer.from([0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82]);
+const IEND_TAIL = IEND.subarray(4);
+
+export function repairPngBuffer(buffer) {
+  if (buffer.subarray(-12).equals(IEND)) return { buffer, changed: false, reason: "already-valid" };
+  if (buffer.subarray(-4).equals(IEND.subarray(0, 4))) {
+    return { buffer: Buffer.concat([buffer, IEND_TAIL]), changed: true, reason: "appended-iend-tail" };
+  }
+  return { buffer, changed: false, reason: "not-truncated-iend" };
+}
+
+const args = parseArgs(process.argv.slice(2));
+const input = args._[0];
+if (!input) {
+  console.error("usage: node png-embed-fix.mjs <file.png> [--json]");
+  process.exit(2);
+}
+
+const repaired = repairPngBuffer(fs.readFileSync(input));
+if (repaired.changed) fs.writeFileSync(input, repaired.buffer);
+const result = { file: input, changed: repaired.changed, reason: repaired.reason };
+process.stdout.write(args.json ? `${JSON.stringify(result, null, 2)}\n` : `${input}: ${repaired.reason}\n`);

package/localized/zh-CN/skills/fec-drawio-studio/scripts/scan-go-packages.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { parseArgs, printOrWrite, reduceTransitive, toPosix, walkFiles } from "./studio-core.mjs";
+
+export function scanGoPackages(root) {
+  const absRoot = path.resolve(root);
+  const mod = fs.existsSync(path.join(absRoot, "go.mod")) ? fs.readFileSync(path.join(absRoot, "go.mod"), "utf8").match(/^module\s+(.+)$/m)?.[1] : "";
+  const files = walkFiles(absRoot, (file) => file.endsWith(".go") && !file.endsWith("_test.go"));
+  const packageDirs = [...new Set(files.map((file) => path.dirname(file)))].sort();
+  const dirToId = new Map(packageDirs.map((dir) => [dir, mod ? `${mod}/${toPosix(path.relative(absRoot, dir))}`.replace(/\/$/, "") : toPosix(path.relative(absRoot, dir) || ".")]));
+  const nodes = [...dirToId.entries()].map(([dir, id]) => ({ id, label: path.basename(dir), group: toPosix(path.dirname(path.relative(absRoot, dir))).replace(".", "") || undefined }));
+  const ids = new Set(nodes.map((node) => node.id));
+  const edges = [];
+  for (const file of files) {
+    const source = dirToId.get(path.dirname(file));
+    const text = fs.readFileSync(file, "utf8");
+    for (const spec of extractGoImports(text)) if (ids.has(spec)) edges.push({ source, target: spec });
+  }
+  return { direction: "LR", nodes, edges: reduceTransitive(nodes, edges) };
+}
+
+function extractGoImports(text) {
+  const out = [];
+  for (const match of text.matchAll(/import\s+(?:[._A-Za-z]\w*\s+)?(?:"([^"]+)"|\(([\s\S]*?)\))/g)) {
+    if (match[1]) out.push(match[1]);
+    if (match[2]) for (const line of match[2].split(/\r?\n/)) {
+      const item = line.match(/"([^"]+)"/)?.[1];
+      if (item) out.push(item);
+    }
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+printOrWrite(`${JSON.stringify(scanGoPackages(args._[0] ?? "."), null, 2)}\n`, args.output);

package/localized/zh-CN/skills/fec-drawio-studio/scripts/scan-js-modules.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs, printOrWrite, reduceTransitive, toPosix, walkFiles } from "./studio-core.mjs";
+
+const JS_EXTS = [".js", ".jsx", ".mjs", ".cjs"];
+const IMPORT_RE = /\bimport\s+(?:[^'"]+?\s+from\s+)?['"]([^'"]+)['"]|\bexport\s+[^'"]*?\s+from\s+['"]([^'"]+)['"]|\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+export function scanJavaScriptModules(root, extensions = JS_EXTS) {
+  return scanModules(root, extensions);
+}
+
+export function scanModules(root, extensions) {
+  const absRoot = path.resolve(root);
+  const files = walkFiles(absRoot, (file) => extensions.includes(path.extname(file)));
+  const byBase = new Map();
+  const nodes = files.map((file) => {
+    const id = toPosix(path.relative(absRoot, file)).replace(/\.[^.]+$/, "");
+    byBase.set(path.resolve(file), id);
+    return { id, label: id.split("/").pop(), group: id.includes("/") ? id.split("/").slice(0, -1).join("/") : undefined };
+  });
+  const edges = [];
+  for (const file of files) {
+    const source = byBase.get(path.resolve(file));
+    const text = fs.readFileSync(file, "utf8");
+    for (const match of text.matchAll(IMPORT_RE)) {
+      const spec = match[1] ?? match[2] ?? match[3] ?? match[4];
+      if (!spec?.startsWith(".")) continue;
+      const target = resolveRelative(file, spec, extensions, byBase);
+      if (target) edges.push({ source, target });
+    }
+  }
+  return { direction: "LR", nodes, edges: reduceTransitive(nodes, edges) };
+}
+
+function resolveRelative(fromFile, spec, extensions, byBase) {
+  const base = path.resolve(path.dirname(fromFile), spec);
+  const candidates = [base, ...extensions.map((ext) => base + ext), ...extensions.map((ext) => path.join(base, `index${ext}`))];
+  for (const candidate of candidates) {
+    const id = byBase.get(path.resolve(candidate));
+    if (id) return id;
+  }
+  return null;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const args = parseArgs(process.argv.slice(2));
+  const root = args._[0] ?? ".";
+  const graph = scanJavaScriptModules(root);
+  printOrWrite(`${JSON.stringify(graph, null, 2)}\n`, args.output);
+}

package/localized/zh-CN/skills/fec-drawio-studio/scripts/scan-python-classes.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { parseArgs, printOrWrite, reduceTransitive, toPosix, walkFiles } from "./studio-core.mjs";
+
+export function scanPythonClasses(root) {
+  const absRoot = path.resolve(root);
+  const files = walkFiles(absRoot, (file) => file.endsWith(".py"));
+  const classes = [];
+  for (const file of files) {
+    const moduleId = toPosix(path.relative(absRoot, file)).replace(/\/__init__\.py$/, "").replace(/\.py$/, "").replaceAll("/", ".");
+    const text = fs.readFileSync(file, "utf8");
+    for (const match of text.matchAll(/^\s*class\s+([A-Za-z_]\w*)\s*(?:\(([^)]*)\))?:/gm)) {
+      const id = `${moduleId}.${match[1]}`.replace(/^\./, "");
+      classes.push({ id, name: match[1], bases: (match[2] ?? "").split(",").map((item) => item.trim().split(".").pop()).filter(Boolean), moduleId });
+    }
+  }
+  const byName = new Map(classes.map((cls) => [cls.name, cls.id]));
+  const nodes = classes.map((cls) => ({ id: cls.id, label: cls.name, group: cls.moduleId }));
+  const edges = [];
+  for (const cls of classes) {
+    for (const base of cls.bases) {
+      if (byName.has(base)) edges.push({ source: cls.id, target: byName.get(base) });
+    }
+  }
+  return { direction: "TB", nodes, edges: reduceTransitive(nodes, edges) };
+}
+
+const args = parseArgs(process.argv.slice(2));
+printOrWrite(`${JSON.stringify(scanPythonClasses(args._[0] ?? "."), null, 2)}\n`, args.output);

package/localized/zh-CN/skills/fec-drawio-studio/scripts/scan-python-modules.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { parseArgs, printOrWrite, reduceTransitive, toPosix, walkFiles } from "./studio-core.mjs";
+
+export function scanPythonModules(root) {
+  const absRoot = path.resolve(root);
+  const files = walkFiles(absRoot, (file) => file.endsWith(".py"));
+  const moduleByFile = new Map();
+  const nodes = files.map((file) => {
+    const rel = toPosix(path.relative(absRoot, file));
+    const id = rel.replace(/\/__init__\.py$/, "").replace(/\.py$/, "").replaceAll("/", ".");
+    moduleByFile.set(file, id || path.basename(absRoot));
+    return { id: id || path.basename(absRoot), label: path.basename(id || absRoot), group: id.includes(".") ? id.split(".").slice(0, -1).join(".") : undefined };
+  });
+  const ids = new Set(nodes.map((node) => node.id));
+  const edges = [];
+  for (const file of files) {
+    const source = moduleByFile.get(file);
+    const text = fs.readFileSync(file, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+      const importMatch = line.match(/^\s*import\s+(.+)/);
+      if (importMatch) {
+        for (const item of importMatch[1].split(",")) addEdge(source, item.trim().split(/\s+as\s+/)[0], ids, edges);
+      }
+      const fromMatch = line.match(/^\s*from\s+([.\w]+)\s+import\s+(.+)/);
+      if (fromMatch) addEdge(source, resolveFromImport(source, fromMatch[1]), ids, edges);
+    }
+  }
+  return { direction: "LR", nodes, edges: reduceTransitive(nodes, edges) };
+}
+
+function addEdge(source, target, ids, edges) {
+  if (!target) return;
+  const parts = target.split(".");
+  while (parts.length) {
+    const candidate = parts.join(".");
+    if (ids.has(candidate)) {
+      edges.push({ source, target: candidate });
+      return;
+    }
+    parts.pop();
+  }
+}
+
+function resolveFromImport(source, spec) {
+  if (!spec.startsWith(".")) return spec;
+  const dots = spec.match(/^\.+/)?.[0].length ?? 0;
+  const suffix = spec.slice(dots);
+  const base = source.split(".").slice(0, Math.max(0, source.split(".").length - dots));
+  return [...base, suffix].filter(Boolean).join(".");
+}
+
+const args = parseArgs(process.argv.slice(2));
+printOrWrite(`${JSON.stringify(scanPythonModules(args._[0] ?? "."), null, 2)}\n`, args.output);

package/localized/zh-CN/skills/fec-drawio-studio/scripts/scan-rust-modules.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { parseArgs, printOrWrite, reduceTransitive, toPosix, walkFiles } from "./studio-core.mjs";
+
+export function scanRustModules(root) {
+  const srcRoot = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
+  const absRoot = path.resolve(srcRoot);
+  const files = walkFiles(absRoot, (file) => file.endsWith(".rs"));
+  const fileToId = new Map();
+  const nodes = files.map((file) => {
+    let id = toPosix(path.relative(absRoot, file)).replace(/\.rs$/, "").replace(/\/mod$/, "").replace(/^(lib|main)$/, "crate").replaceAll("/", "::");
+    fileToId.set(file, id);
+    return { id, label: id.split("::").pop(), group: id.includes("::") ? id.split("::").slice(0, -1).join("::") : undefined };
+  });
+  const ids = new Set(nodes.map((node) => node.id));
+  const edges = [];
+  for (const file of files) {
+    const source = fileToId.get(file);
+    const text = fs.readFileSync(file, "utf8");
+    for (const match of text.matchAll(/\buse\s+(crate|self|super)::([^;{]+)[;{]/g)) {
+      const target = match[2].split("::").filter(Boolean)[0];
+      const candidates = [...ids].filter((id) => id === target || id.endsWith(`::${target}`));
+      if (candidates[0]) edges.push({ source, target: candidates[0] });
+    }
+    for (const match of text.matchAll(/\bmod\s+([A-Za-z_]\w*)\s*;/g)) {
+      const candidates = [...ids].filter((id) => id === match[1] || id.endsWith(`::${match[1]}`));
+      if (candidates[0]) edges.push({ source, target: candidates[0] });
+    }
+  }
+  return { direction: "LR", nodes, edges: reduceTransitive(nodes, edges) };
+}
+
+const args = parseArgs(process.argv.slice(2));
+printOrWrite(`${JSON.stringify(scanRustModules(args._[0] ?? "."), null, 2)}\n`, args.output);

package/localized/zh-CN/skills/fec-drawio-studio/scripts/scan-ts-modules.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { parseArgs, printOrWrite } from "./studio-core.mjs";
+import { scanModules } from "./scan-js-modules.mjs";
+
+const args = parseArgs(process.argv.slice(2));
+const graph = scanModules(args._[0] ?? ".", [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+printOrWrite(`${JSON.stringify(graph, null, 2)}\n`, args.output);