@bill_nee/dwg-reader 1.1.1 → 1.2.0

package/lib/index.js

@@ -1,9 +1,12 @@
 import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
 import { LibreDwg, Dwg_File_Type, DwgCodePage } from "../vendor/libredwg-web/lib/index.js";
 
 const WASM_DIR = fileURLToPath(new URL("../vendor/libredwg-web/wasm", import.meta.url));
 const MAX_DWG_BYTES = 512 * 1024 * 1024; // 512 MB 上限，超大图纸会先于 WASM 内存耗尽给出明确报错
 const MAX_ENTITY_DETAIL = 2000;
+const PYTHON_EXE = "D:\\dsh-home\\dsh-runtimes\\dsh-primary-runtime\\dependencies\\python\\python.exe";
+const DXF_SCRIPT = fileURLToPath(new URL("../scripts/read_dxf.py", import.meta.url));
 
 let libreDwgPromise;
 
@@ -371,9 +374,202 @@ function buildReadDwgTool(ctx) {
   };
 }
 
+function buildReadDxfTool(ctx) {
+  return {
+    name: "read_dxf",
+    description:
+      "读取 DXF 图纸文件（基于 Python ezdxf 桥接，无需安装 AutoCAD）。" +
+      "返回 DXF 版本、图层表、块数量、实体统计（按类型计数）与可选实体明细。",
+    parameters: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        file_path: {
+          type: "string",
+          description: "DXF 文件路径（绝对路径或相对当前工作目录）。",
+        },
+        entities: {
+          type: "boolean",
+          description: "是否返回实体明细列表（默认 false，只返回统计）。",
+        },
+        entity_limit: {
+          type: "integer",
+          description: `实体明细最多返回条数（默认 200，上限 ${MAX_ENTITY_DETAIL}）。`,
+        },
+      },
+      required: ["file_path"],
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          path: { type: "string", description: "解析后的文件路径。" },
+          fileName: { type: "string", description: "文件名。" },
+          fileSizeBytes: { type: "integer", description: "文件字节数。" },
+          format: { type: "string", description: "文件格式（固定为 dxf）。" },
+          dxfVersion: { type: "string", description: "DXF 版本代号（如 R2010）。" },
+          header: { type: "object", additionalProperties: true, description: "图头关键变量。" },
+          layerCount: { type: "integer", description: "图层数量。" },
+          layers: {
+            type: "array",
+            items: { type: "object", additionalProperties: true },
+            description: "图层表（名称/颜色/线型/开关状态）。",
+          },
+          blockCount: { type: "integer", description: "块定义数量。" },
+          entityCount: { type: "integer", description: "实体总数。" },
+          entityTypeCounts: {
+            type: "object",
+            additionalProperties: true,
+            description: "按实体类型统计数量（如 { LINE: 120, TEXT: 8 }）。",
+          },
+          entities: {
+            type: "array",
+            items: { type: "object", additionalProperties: true },
+            description: "实体明细（仅当 entities=true 时非空）。",
+          },
+          entitiesTruncated: { type: "boolean", description: "实体明细是否被截断。" },
+          error: { type: "string", description: "错误信息；成功时为 null。" },
+        },
+      },
+      render: (args, value) => {
+        const lines = [];
+        lines.push(`<path>${value.path}</path>`);
+        lines.push(`<type>dxf</type>`);
+        if (value.error) {
+          lines.push(`<content>读取 DXF 失败：${value.error}</content>`);
+          return [{ type: "text", text: lines.join("\n") }];
+        }
+        const sizeMb = (value.fileSizeBytes / 1024 / 1024).toFixed(2);
+        lines.push(`<content>已解析 DXF：${value.fileName}（${sizeMb} MB）`);
+        lines.push(`版本：${value.dxfVersion}`);
+        lines.push(`图层：${value.layerCount} 个${value.layers.length ? " — " + value.layers.map((l) => l.name).join(", ") : ""}`);
+        lines.push(`块定义：${value.blockCount} 个；实体：${value.entityCount} 个`);
+        const typeLines = Object.entries(value.entityTypeCounts)
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 20)
+          .map(([t, n]) => `${t} ${n}`)
+          .join("，");
+        if (typeLines) lines.push(`实体构成：${typeLines}${Object.keys(value.entityTypeCounts).length > 20 ? "，…" : ""}`);
+        if (value.header && value.header.$ACADVER) lines.push(`图版：${value.header.$ACADVER}`);
+        if (value.entities && value.entities.length) {
+          lines.push(`实体明细（${value.entities.length}${value.entitiesTruncated ? "，已截断" : ""}）：`);
+          const shown = value.entities.slice(0, 50);
+          for (const [i, e] of shown.entries()) {
+            lines.push(
+              `  ${i + 1}. ${e.type} handle=${e.handle} layer=${e.layer}` +
+                (e.colorIndex != null ? ` color=${e.colorIndex}` : "") +
+                (e.lineType != null ? ` linetype=${e.lineType}` : "")
+            );
+          }
+          if (value.entities.length > shown.length) lines.push(`  …（其余 ${value.entities.length - shown.length} 条未显示）`);
+        }
+        lines.push(`</content>`);
+        return [{ type: "text", text: lines.join("\n") }];
+      },
+      presentationMeta: () => null,
+    },
+    isConcurrencySafe: () => false,
+    presentCall: (args) => ({
+      card: "generic",
+      title: `读取 DXF ${args.file_path || "(未指定路径)"}`,
+      kind: "read",
+      locations: [{ path: args.file_path || "" }],
+    }),
+    presentResult: (args, result) => {
+      if (result && result.isError) return undefined;
+      return {
+        card: "generic",
+        title: `DXF 解析完成：${args.file_path || ""}`,
+        kind: "read",
+        locations: [{ path: args.file_path || "" }],
+      };
+    },
+    async execute(args, exec) {
+      if (typeof args !== "object" || args === null) {
+        throw new Error('invalid arguments: expected an object with a "file_path" string');
+      }
+      if (typeof args.file_path !== "string" || !args.file_path.trim()) {
+        throw new Error('invalid arguments: "file_path" must be a non-empty string');
+      }
+      if (args.entities !== undefined && typeof args.entities !== "boolean") {
+        throw new Error('invalid arguments: "entities" must be a boolean');
+      }
+      if (args.entity_limit !== undefined && (typeof args.entity_limit !== "number" || !Number.isInteger(args.entity_limit))) {
+        throw new Error('invalid arguments: "entity_limit" must be an integer');
+      }
+
+      const resolveOptions = await sessionResolveOptions(ctx, exec);
+      const target = await ctx.fs.resolve(args.file_path.trim(), resolveOptions);
+      const info = await ctx.fs.stat(target, exec.signal);
+      const displayPath = ctx.fs.processPath(target);
+      if (!info) {
+        ctx.emit("fs/observed", target, { kind: "absent" }, exec);
+        throw new Error(`cannot read "${displayPath}": not found`);
+      }
+      if (info.type !== "file") {
+        throw new Error(`cannot read "${displayPath}": not a regular file`);
+      }
+
+      const pythonArgs = [
+        DXF_SCRIPT,
+        args.file_path.trim(),
+        String(args.entity_limit || 200),
+        String(args.entities === true),
+      ];
+
+      const result = await new Promise((resolve, reject) => {
+        const proc = spawn(PYTHON_EXE, pythonArgs, { stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (d) => (stdout += d.toString()));
+        proc.stderr.on("data", (d) => (stderr += d.toString()));
+        proc.on("close", (code) => {
+          if (code !== 0) {
+            reject(new Error(`Python 进程退出码 ${code}: ${stderr || stdout}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(stdout));
+          } catch (err) {
+            reject(new Error(`DXF 结果解析失败: ${err.message}; stdout=${stdout.slice(0, 200)}`));
+          }
+        });
+        proc.on("error", (err) => reject(new Error(`无法启动 Python 进程: ${err.message}`)));
+      });
+
+      if (result.error) {
+        throw new Error(`cannot read "${displayPath}": ${result.error}`);
+      }
+
+      ctx.emit("fs/observed", target, { kind: "present", version: info.version }, exec);
+
+      return toJson({
+        path: displayPath,
+        fileName: displayPath.split(/[\\/]/).pop(),
+        fileSizeBytes: result.fileSizeBytes ?? info.size !== undefined ? info.size : 0,
+        format: result.format ?? "dxf",
+        dxfVersion: result.dxfVersion ?? "",
+        header: result.header ?? {},
+        layerCount: result.layerCount ?? 0,
+        layers: result.layers ?? [],
+        blockCount: result.blockCount ?? 0,
+        entityCount: result.entityCount ?? 0,
+        entityTypeCounts: result.entityTypeCounts ?? {},
+        entities: result.entities ?? [],
+        entitiesTruncated: !!result.entitiesTruncated,
+      });
+    },
+  };
+}
+
 export const inject = ["tools", "fs", "workingDirectory"];
 
 export function apply(ctx, config) {
-  const dispose = ctx.tools.register(buildReadDwgTool(ctx));
-  return () => dispose();
+  const disposeDwg = ctx.tools.register(buildReadDwgTool(ctx));
+  const disposeDxf = ctx.tools.register(buildReadDxfTool(ctx));
+  return () => {
+    disposeDwg();
+    disposeDxf();
+  };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bill_nee/dwg-reader",
-  "version": "1.1.1",
-  "description": "直接读取 AutoCAD DWG 图纸的 DSH 插件（基于 libredwg-web 0.8.2 WASM，GPL-3.0）。",
+  "version": "1.2.0",
+  "description": "直接读取 AutoCAD DWG/DXF 图纸的 DSH 插件（DWG 基于 libredwg-web 0.8.2 WASM，DXF 基于 Python ezdxf 桥接，GPL-3.0）。",
   "license": "GPL-3.0-only",
   "author": "MEB 工程造价项目助手 <meb@example.com>",
   "repository": {
@@ -21,6 +21,7 @@
   "files": [
     "lib/index.js",
     "vendor",
+    "scripts/*.py",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",

package/scripts/read_dxf.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""读取 DXF 文件并输出 JSON（供 DSH dwg-reader 插件调用）。"""
+import sys
+import json
+import os
+
+try:
+    import ezdxf
+except ImportError as exc:
+    print(json.dumps({"error": f"ezdxf 未安装: {exc}"}))
+    sys.exit(1)
+
+DXF_PATH = sys.argv[1] if len(sys.argv) > 1 else None
+ENTITY_LIMIT = int(sys.argv[2]) if len(sys.argv) > 2 else 200
+WANT_ENTITIES = sys.argv[3] == "true" if len(sys.argv) > 3 else False
+
+
+def point_to_list(p):
+    if p is None:
+        return None
+    return [float(p.x), float(p.y), float(p.z)]
+
+
+def main():
+    if not DXF_PATH or not os.path.exists(DXF_PATH):
+        print(json.dumps({"error": f"文件不存在: {DXF_PATH}"}))
+        sys.exit(1)
+
+    try:
+        doc = ezdxf.readfile(DXF_PATH)
+    except Exception as exc:
+        print(json.dumps({"error": f"无法读取 DXF: {exc}"}))
+        sys.exit(1)
+
+    # 图层
+    layers = []
+    for layer in doc.layers:
+        layers.append({
+            "name": layer.dxf.name,
+            "colorIndex": layer.dxf.color,
+            "lineType": layer.dxf.linetype,
+            "frozen": bool(layer.is_frozen()),
+            "off": bool(layer.is_off()),
+            "locked": bool(layer.is_locked()),
+        })
+
+    # 块记录
+    block_count = len(list(doc.blocks))
+
+    # 实体统计
+    msp = doc.modelspace()
+    entities = list(msp)
+    entity_type_counts = {}
+    entity_details = []
+    for ent in entities:
+        etype = ent.dxftype() or "UNKNOWN"
+        entity_type_counts[etype] = entity_type_counts.get(etype, 0) + 1
+        if WANT_ENTITIES and len(entity_details) < ENTITY_LIMIT:
+            detail = {
+                "type": etype,
+                "handle": ent.dxf.handle if hasattr(ent.dxf, 'handle') else None,
+                "layer": ent.dxf.layer if hasattr(ent.dxf, 'layer') else None,
+                "colorIndex": ent.dxf.color if hasattr(ent.dxf, 'color') else None,
+                "lineType": ent.dxf.linetype if hasattr(ent.dxf, 'linetype') else None,
+            }
+            if etype == "INSERT":
+                detail["blockName"] = ent.dxf.name if hasattr(ent.dxf, 'name') else None
+                detail["insertionPoint"] = point_to_list(ent.dxf.insert) if hasattr(ent.dxf, 'insert') else None
+            entity_details.append(detail)
+
+    # 图头
+    header = {}
+    try:
+        header_vars = doc.header
+        for key in ("$ACADVER", "$DWGCODEPAGE", "$INSUNITS", "$EXTMIN", "$EXTMAX", "$TDCREATE", "$TDUPDATE", "$CLAYER"):
+            if key in header_vars:
+                val = header_vars[key]
+                if key == "$EXTMIN" or key == "$EXTMAX":
+                    header[key] = point_to_list(val) if val else None
+                else:
+                    header[key] = str(val)
+    except Exception:
+        pass
+
+    result = {
+        "path": os.path.abspath(DXF_PATH),
+        "fileName": os.path.basename(DXF_PATH),
+        "fileSizeBytes": os.path.getsize(DXF_PATH),
+        "format": "dxf",
+        "dxfVersion": doc.dxfversion,
+        "header": header,
+        "layerCount": len(layers),
+        "layers": layers,
+        "blockCount": block_count,
+        "entityCount": len(entities),
+        "entityTypeCounts": entity_type_counts,
+        "entities": entity_details,
+        "entitiesTruncated": WANT_ENTITIES and len(entities) > ENTITY_LIMIT,
+    }
+    print(json.dumps(result, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()