@bill_nee/dwg-reader 1.1.0 → 1.2.0

package/README.md

@@ -1,11 +1,13 @@
 # @bill_nee/dwg-reader
 
-DSH (DeepSeek Harness) 插件：可直接读取 AutoCAD DWG 格式图纸，无需安装 AutoCAD。
+DSH（DeepSeek Harness）插件：可直接读取 AutoCAD DWG 格式图纸，无需安装 AutoCAD。
 
 基于 [libredwg-web](https://github.com/mlightcad/libredwg-web) 0.8.2 WASM 编译，在浏览器/Node 环境中解析 DWG 文件，返回图层、实体、版本、编码、图幅等信息，并可导出 SVG 预览。
 
 ## 安装
 
+在 DSH 工作台或终端执行：
+
 ```powershell
 dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0
 ```
@@ -14,11 +16,84 @@ dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0
 
 ## 主要能力
 
-- 读取 DWG（AutoCAD R14~R2018 等常见版本）
-- 返回图层列表、实体类型与数量、图纸版本（ACADVER）、代码页、图幅
-- 导出 SVG 预览到指定路径
-- 对无效/损坏文件给出明确错误
+| 能力 | 说明 |
+|------|------|
+| 读取 DWG | 支持 AutoCAD R14~R2018 等常见版本（AC1015~AC1032） |
+| 图层信息 | 返回所有图层名称、颜色、冻结/关闭/锁定状态 |
+| 实体统计 | 返回实体总数及按类型（LINE/TEXT/INSERT/HATCH/DIMENSION 等）分类统计 |
+| 图纸版本 | 返回 ACADVER、版本号、版本描述（如 r2018/AC1032/AutoCAD Release 2018） |
+| 代码页 | 返回 DWG 代码页（如 CP_ANSI_936） |
+| 图幅信息 | 返回 EXTMIN/EXTMAX 边界框 |
+| 导出 SVG | 可将 DWG 内容导出为 SVG 预览文件到指定路径 |
+| 错误处理 | 对无效/损坏/非 DWG 文件给出明确错误提示 |
+
+## 使用示例
+
+在 DSH 工作台调用 `read_dwg` 工具：
+
+```json
+{
+  "file_path": "E:\\2026 工程资料\\16 天喔蜜饯工厂\\03 CAD DESIGN\\02 HVAC DESIGN PLAN.dwg",
+  "entities": true,
+  "entity_limit": 50,
+  "export_svg": true,
+  "svg_output_path": "F:\\HAYNESS 工作区1\\hvac-plan.svg"
+}
+```
+
+返回示例：
+
+```json
+{
+  "file_path": "E:\\...\\02 HVAC DESIGN PLAN.dwg",
+  "file_size": 123456,
+  "version": { "type": "r2018", "hdr": "AC1032", "description": "AutoCAD Release 2018", "version": 33 },
+  "codepage": 39,
+  "codepageName": "CP_ANSI_936",
+  "layer_count": 126,
+  "entity_count": 1514,
+  "unknown_entity_count": 0,
+  "extents": { "min": { "x": 0, "y": 0, "z": 0 }, "max": { "x": 266000, "y": 286000, "z": 0 } },
+  "layers": [ { "name": "HEPA BOX", "colorIndex": 5, ... }, ... ],
+  "entities": [
+    { "type": "INSERT", "handle": "...", "layer": "HEPA BOX", "blockName": "...", ... },
+    ...
+  ],
+  "svg_path": "F:\\HAYNESS 工作区1\\hvac-plan.svg"
+}
+```
+
+## 测试实例
+
+已对真实工程图纸进行验证：
+
+- **天喔蜜饯工厂暖通图纸**（r2018/AC1032）：1514 个实体，126 个图层，其中高效送风口（HEPA BOX 图层）108 个，方形散流器 18 个，射流空调 5 个。
+- **植本清源空调设备图**（r2007/AC1021）：1762 个实体，14 个图层。
+- **无效/损坏文件**：返回明确错误，不崩溃。
+
+## 文件结构
+
+```
+dwg-reader-plugin/
+├── lib/index.js          # 插件入口，注册 read_dwg 工具
+├── cordis.patch.yml      # DSH bundle 插件清单
+├── package.json          # npm 包清单
+├── LICENSE               # GPL-3.0-only
+├── README.md             # 本文件
+├── icon.svg              # 插件图标
+├── locale/en.json        # 英文元数据
+├── locale/zh.json        # 中文元数据
+└── vendor/libredwg-web/  # libredwg-web 0.8.2 WASM 库（已 vendored）
+    ├── lib/              # JS 封装层
+    └── wasm/             # libredwg-web.wasm（WebAssembly 解析核心）
+```
 
 ## 许可
 
 GPL-3.0-only。依赖 libredwg-web 同样为 GPL，公开分发请保留 LICENSE 并提供对应源码。
+
+## 安装路径
+
+- npm 公开包：`@bill_nee/dwg-reader@1.1.0`
+- 安装命令：`dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0`
+- GitHub 源码：https://github.com/NIDEXIANG/dwg-reader-plugin-20261029

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;
 
@@ -272,14 +275,38 @@ function buildReadDwgTool(ctx) {
 
         const limit = Math.min(Math.max(1, args.entity_limit || 200), MAX_ENTITY_DETAIL);
         const detailEntities = args.entities ? database.entities.slice(0, limit) : [];
-        const entities = detailEntities.map((entity) => ({
-          type: entity.type || "UNKNOWN",
-          handle: entity.handle != null ? entity.handle : null,
-          layer: entity.layer != null ? entity.layer : null,
-          colorIndex: typeof entity.colorIndex === "number" ? entity.colorIndex : null,
-          lineType: entity.lineType != null ? entity.lineType : null,
-          isInPaperSpace: !!entity.isInPaperSpace,
-        }));
+        const entities = detailEntities.map((entity) => {
+          const base = {
+            type: entity.type || "UNKNOWN",
+            handle: entity.handle != null ? entity.handle : null,
+            layer: entity.layer != null ? entity.layer : null,
+            colorIndex: typeof entity.colorIndex === "number" ? entity.colorIndex : null,
+            lineType: entity.lineType != null ? entity.lineType : null,
+            isInPaperSpace: !!entity.isInPaperSpace,
+          };
+          if (entity.type === "INSERT") {
+            base.blockName = entity.name != null ? String(entity.name) : null;
+            base.insertionPoint = entity.insertionPoint
+              ? { x: entity.insertionPoint.x, y: entity.insertionPoint.y, z: entity.insertionPoint.z }
+              : null;
+            base.rotation = typeof entity.rotation === "number" ? entity.rotation : null;
+            base.scale = entity.scale
+              ? { x: entity.scale.x, y: entity.scale.y, z: entity.scale.z }
+              : null;
+            base.attribs = Array.isArray(entity.attribs)
+              ? entity.attribs.map((a) => ({
+                  tag: a.tag != null ? String(a.tag) : null,
+                  text: a.text != null ? String(a.text) : null,
+                  prompt: a.prompt != null ? String(a.prompt) : null,
+                  value: a.value != null ? String(a.value) : null,
+                  insertionPoint: a.insertionPoint
+                    ? { x: a.insertionPoint.x, y: a.insertionPoint.y, z: a.insertionPoint.z }
+                    : null,
+                }))
+              : [];
+          }
+          return base;
+        });
 
         let svgPath = null;
         if (args.export_svg) {
@@ -347,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,12 +1,12 @@
 {
   "name": "@bill_nee/dwg-reader",
-  "version": "1.1.0",
-  "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": {
     "type": "git",
-    "url": "https://github.com/dwg-reader-plugin/dwg-reader"
+    "url": "https://github.com/NIDEXIANG/dwg-reader-plugin-20261029.git"
   },
   "keywords": ["dwg", "dwg-reader", "autocad", "cad", "dsh-plugin", "libredwg", "wasm"],
   "type": "module",
@@ -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()