@miclivs/cadcli 0.1.1 → 0.2.0

package/dist/core/sqlite-search.js

@@ -0,0 +1,218 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join } from "node:path";
+import { getCacheDir } from "../store.js";
+import { loadDrawing } from "./drawing.js";
+import { entitySearchFields, searchMatchesFor, } from "./search.js";
+import { computeDrawingFingerprint } from "./search-cache.js";
+const require = createRequire(import.meta.url);
+const SEARCH_SCHEMA_VERSION = 1;
+function sqliteSearchDatabasePath(file, cacheDir) {
+    const root = cacheDir ?? getCacheDir();
+    const key = computeDrawingFingerprint(file);
+    return join(root, "search", `${basename(file)}-${key}.search.sqlite`);
+}
+async function openSqliteDatabase(path) {
+    try {
+        const Database = require("better-sqlite3");
+        return new Database(path);
+    }
+    catch {
+        return null;
+    }
+}
+function ensureSqliteSchema(db) {
+    db.exec(`
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS entities (
+      id INTEGER PRIMARY KEY,
+      entity_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      layer TEXT,
+      text TEXT NOT NULL,
+      entity_json TEXT NOT NULL
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      entity_id,
+      type,
+      layer,
+      text
+    );
+  `);
+}
+function sqliteCacheIsValid(db, fingerprint) {
+    const row = db
+        .prepare("SELECT value FROM meta WHERE key = ?")
+        .get("fingerprint");
+    const version = db
+        .prepare("SELECT value FROM meta WHERE key = ?")
+        .get("schema_version");
+    return (row?.value === fingerprint &&
+        version?.value === String(SEARCH_SCHEMA_VERSION));
+}
+function resetSqliteDatabase(path) {
+    for (const suffix of ["", "-wal", "-shm"]) {
+        const target = `${path}${suffix}`;
+        if (existsSync(target))
+            rmSync(target, { force: true });
+    }
+}
+function indexedEntities(doc) {
+    return doc.entities.map((entity, id) => ({
+        id,
+        entityId: entity.id,
+        type: entity.type,
+        layer: entity.layer,
+        text: entitySearchFields(entity).join(" "),
+        entity,
+    }));
+}
+function writeSqliteSearchDatabase(db, fingerprint, doc) {
+    ensureSqliteSchema(db);
+    const insertMeta = db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    const insertEntity = db.prepare(`
+    INSERT INTO entities (id, entity_id, type, layer, text, entity_json)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    const insertFts = db.prepare(`
+    INSERT INTO entities_fts (rowid, entity_id, type, layer, text)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+    db.exec("BEGIN");
+    try {
+        insertMeta.run("schema_version", String(SEARCH_SCHEMA_VERSION));
+        insertMeta.run("fingerprint", fingerprint);
+        for (const entity of indexedEntities(doc)) {
+            insertEntity.run(entity.id, entity.entityId, entity.type, entity.layer ?? null, entity.text, JSON.stringify(entity.entity));
+            insertFts.run(entity.id, entity.entityId, entity.type, entity.layer ?? "", entity.text);
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        db.close();
+        throw error;
+    }
+    return db;
+}
+async function openSqliteSearchDatabase(file, opts, loadOpts) {
+    const fingerprint = computeDrawingFingerprint(file);
+    const path = sqliteSearchDatabasePath(file, opts.cacheDir);
+    if (existsSync(path)) {
+        try {
+            const db = await openSqliteDatabase(path);
+            if (!db)
+                return null;
+            ensureSqliteSchema(db);
+            if (sqliteCacheIsValid(db, fingerprint))
+                return db;
+            db.close();
+        }
+        catch {
+            resetSqliteDatabase(path);
+        }
+    }
+    resetSqliteDatabase(path);
+    mkdirSync(dirname(path), { recursive: true });
+    const db = await openSqliteDatabase(path);
+    if (!db)
+        return null;
+    return writeSqliteSearchDatabase(db, fingerprint, await loadDrawing(file, loadOpts));
+}
+function matchesFilterSql(opts) {
+    const clauses = [];
+    if (opts.type)
+        clauses.push("lower(e.type) = lower(:type)");
+    if (opts.layer)
+        clauses.push("lower(e.layer) = lower(:layer)");
+    return clauses.length > 0 ? ` AND ${clauses.join(" AND ")}` : "";
+}
+function ftsQuery(query) {
+    return query
+        .split(/\s+/)
+        .map((term) => term.trim())
+        .filter(Boolean)
+        .map((term) => `"${term.replaceAll('"', '""')}"`)
+        .join(" OR ");
+}
+function parseEntity(json) {
+    try {
+        const value = JSON.parse(json);
+        if (!value ||
+            typeof value.id !== "string" ||
+            typeof value.type !== "string") {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function resultScore(score) {
+    return Math.round((Number(score) || 1) * 10) / 10;
+}
+function rowToResult(row, query) {
+    const entity = parseEntity(row.entity_json);
+    if (!entity)
+        return null;
+    return {
+        entityId: row.entity_id,
+        type: row.type,
+        layer: row.layer ?? undefined,
+        score: resultScore(row.score),
+        matches: searchMatchesFor(entity, query),
+        entity,
+    };
+}
+export async function searchWithSqlite(file, opts, loadOpts) {
+    const db = await openSqliteSearchDatabase(file, opts, loadOpts);
+    if (!db)
+        return null;
+    const query = opts.query?.trim();
+    const limit = opts.limit ?? 30;
+    const filter = matchesFilterSql(opts);
+    const params = {
+        query: query ? ftsQuery(query) : "",
+        limit,
+    };
+    if (opts.type)
+        params.type = opts.type;
+    if (opts.layer)
+        params.layer = opts.layer;
+    const rows = query
+        ? db
+            .prepare(`
+          SELECT e.id, e.entity_id, e.type, e.layer, e.text, e.entity_json,
+                 -bm25(entities_fts, 3.0, 2.0, 2.0, 1.0) AS score
+          FROM entities_fts
+          JOIN entities e ON e.id = entities_fts.rowid
+          WHERE entities_fts MATCH :query${filter}
+          ORDER BY bm25(entities_fts, 3.0, 2.0, 2.0, 1.0)
+          LIMIT :limit
+        `)
+            .all(params)
+        : db
+            .prepare(`
+          SELECT e.id, e.entity_id, e.type, e.layer, e.text, e.entity_json,
+                 1 AS score
+          FROM entities e
+          WHERE 1 = 1${filter}
+          ORDER BY e.id
+          LIMIT :limit
+        `)
+            .all(params);
+    db.close();
+    return rows
+        .map((row) => {
+        const result = rowToResult(row, query);
+        return result && opts.snippets === false
+            ? { ...result, matches: [] }
+            : result;
+    })
+        .filter((result) => Boolean(result));
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export type { LibreDwgEditResult, LibreDwgJsonResult, LibreDwgViewResult, } from "./core/libredwg.js";
+export type { AcadColor, AcadEditOperation, AcadEditResult, AcadPoint, } from "./core/acad-edit.js";
+export type { AcadSvgViewResult } from "./core/acad-view.js";
 export type { DrawingOverview, DrawingOverviewOptions, OverviewBlock, OverviewEntityType, OverviewLayer, OverviewText, } from "./core/overview.js";
 export type { DwgSearchOptions, DwgSearchResult } from "./core/search.js";
 export { Dwg } from "./sdk.js";

package/dist/main.js

@@ -28,7 +28,8 @@ Examples:
   $ cadcli entities drawing.dwg --type LINE --limit 20
   $ cadcli search drawing.dwg "conference" --layer A-TEXT
   $ cadcli view drawing.dwg -o drawing.svg
-  $ cadcli edit drawing.dwg --jq '.OBJECTS[]' -o edited.dwg
+  $ cadcli edit drawing.dwg --set-text "Office" --text-id 2A -o edited.dwg
+  $ cadcli edit drawing.dwg --add-line 0,0:10,0 --new-layer A-WALL -o edited.dwg
 
 Workflow: info → overview → search/entities → view/edit
 
@@ -41,8 +42,8 @@ Inspecting:
   search <file>        Search entities by text, type, layer, and raw fields
 
 Viewing and editing:
-  view <file>          Render a high-fidelity SVG preview
-  edit <file>          Edit DWG/DXF with jq-style expressions
+  view <file>          Render an SVG preview
+  edit <file>          Edit DWG/DXF with acad-ts operations
 
 Conversion:
   json <file>          Export normalized JSON
@@ -120,15 +121,89 @@ program
 });
 program
     .command("view <file>")
-    .description("Render a high-fidelity SVG preview")
+    .description("Render an SVG preview")
     .option("-o, --output <path>", "Output SVG file")
     .action(async (file, opts, cmd) => view(file, { ...cmd.optsWithGlobals(), ...opts }));
 program
     .command("edit <file>")
-    .description("Edit DWG/DXF with jq-style expressions")
-    .requiredOption("--jq <expression>", "dwgfilter jq expression")
-    .option("-o, --output <path>", "Output file; defaults to input with --overwrite")
+    .description("Edit DWG/DXF with acad-ts operations")
+    .option("--set-text <text>", "Set TEXT/MTEXT content")
+    .option("--text-id <id>", "Entity id/handle for --set-text")
+    .option("--set-layer <name>", "Move an entity to a layer")
+    .option("--layer-id <id>", "Entity id/handle for --set-layer")
+    .option("--set-color <color>", "Set entity color: bylayer, byblock, index, #rrggbb, or r,g,b")
+    .option("--color-id <id>", "Entity id/handle for --set-color")
+    .option("--set-linetype <name>", "Set entity line type")
+    .option("--linetype-id <id>", "Entity id/handle for --set-linetype")
+    .option("--set-lineweight <n>", "Set entity line weight enum value")
+    .option("--lineweight-id <id>", "Entity id/handle for --set-lineweight")
+    .option("--set-transparency <alpha>", "Set transparency alpha value")
+    .option("--transparency-id <id>", "Entity id/handle for --set-transparency")
+    .option("--hide <id>", "Hide an entity")
+    .option("--show <id>", "Show an entity")
+    .option("--move <id>", "Move an entity by --dx/--dy/--dz")
+    .option("--rotate <id>", "Rotate an entity around Z by --angle degrees")
+    .option("--scale <id>", "Scale an entity by --factor")
+    .option("--copy <id>", "Copy an entity, optionally offset by --dx/--dy/--dz")
+    .option("--match-properties <id>", "Copy visual properties from --source-id")
+    .option("--source-id <id>", "Source entity id for --match-properties")
+    .option("--set-attr <tag=value>", "Set a block insert attribute")
+    .option("--insert-id <id>", "Block insert id for --set-attr")
+    .option("--dx <n>", "X delta")
+    .option("--dy <n>", "Y delta")
+    .option("--dz <n>", "Z delta")
+    .option("--angle <degrees>", "Angle in degrees")
+    .option("--origin <x,y,z>", "Origin for rotate/scale")
+    .option("--factor <n>", "Scale factor")
+    .option("--add-point <x,y,z>", "Add a POINT")
+    .option("--add-line <from:to>", "Add a LINE, e.g. 0,0:10,0")
+    .option("--add-circle <center:radius>", "Add a CIRCLE, e.g. 5,5:2")
+    .option("--add-arc <center:radius:start:end>", "Add an ARC with degree angles")
+    .option("--add-text <text>", "Add TEXT at --at")
+    .option("--add-mtext <text>", "Add MTEXT at --at")
+    .option("--points <p1;p2[;p3]>", "Add an LWPOLYLINE from x,y points")
+    .option("--closed", "Close a polyline added with --points")
+    .option("--at <x,y,z>", "Insertion point for text")
+    .option("--height <n>", "Text height")
+    .option("--width <n>", "MText width")
+    .option("--new-layer <name>", "Layer for add-* entities")
+    .option("--new-color <color>", "Color for add-* entities")
+    .option("--delete <id>", "Delete an entity")
+    .option("-o, --output <path>", "Write edited copy to this file; required unless --overwrite")
     .option("--overwrite", "Allow editing the input file in place")
+    .addHelpText("after", `
+
+Examples:
+  Find ids first:
+    $ cadcli entities drawing.dwg --type TEXT --json
+    $ cadcli search drawing.dwg "office" --json
+
+  Update existing entities:
+    $ cadcli edit drawing.dwg --set-text "Office" --text-id 2A -o edited.dwg
+    $ cadcli edit drawing.dwg --set-color '#ff0000' --color-id 2A -o edited.dwg
+    $ cadcli edit drawing.dwg --move 2A --dx 10 --dy 0 -o edited.dwg
+    $ cadcli edit drawing.dwg --rotate 2A --angle 90 --origin 0,0 -o edited.dwg
+    $ cadcli edit drawing.dwg --copy 2A --dx 10 --dy 0 -o edited.dwg
+    $ cadcli edit drawing.dwg --delete 2A -o edited.dwg
+
+  Add new entities:
+    $ cadcli edit drawing.dwg --add-line 0,0:10,0 --new-layer A-WALL -o edited.dwg
+    $ cadcli edit drawing.dwg --add-circle 5,5:2 -o edited.dwg
+    $ cadcli edit drawing.dwg --add-text "Label" --at 5,5 --height 2.5 -o edited.dwg
+    $ cadcli edit drawing.dwg --points '0,0;10,0;10,5' --closed -o edited.dwg
+
+Formats:
+  points:       x,y or x,y,z
+  line:         from:to, e.g. 0,0:10,0
+  circle:       center:radius, e.g. 5,5:2
+  arc:          center:radius:startAngle:endAngle, e.g. 5,5:2:0:90
+  color:        bylayer, byblock, AutoCAD color index, #rrggbb, or r,g,b
+
+Safety:
+  cadcli refuses to modify the input file by default.
+  Use -o/--output to write an edited copy.
+  Use --overwrite only when you intentionally want to edit the input file in place.
+`)
     .action(async (file, opts, cmd) => edit(file, { ...cmd.optsWithGlobals(), ...opts }));
 program
     .command("json <file>")

package/dist/sdk.d.ts

@@ -1,5 +1,6 @@
+import { type AcadEditOperation, type AcadEditResult } from "./core/acad-edit.js";
+import { type AcadSvgViewResult } from "./core/acad-view.js";
 import { type LoadOptions } from "./core/drawing.js";
-import { type LibreDwgEditResult, type LibreDwgViewResult } from "./core/libredwg.js";
 import { type DrawingOverview, type DrawingOverviewOptions } from "./core/overview.js";
 import { type DwgSearchOptions, type DwgSearchResult } from "./core/search.js";
 import type { DwgBlock, DwgDocument, DwgEntity, DwgLayer, DwgSummary, EntityFilter, SvgResult, ThumbnailResult } from "./types.js";
@@ -16,15 +17,12 @@ export declare class Dwg {
     overview(opts?: DrawingOverviewOptions): Promise<DrawingOverview>;
     json(): Promise<DwgDocument>;
     svg(): Promise<SvgResult>;
-    view(opts?: {
-        toolDir?: string;
-    }): LibreDwgViewResult;
+    view(): AcadSvgViewResult;
     edit(opts: {
         output: string;
-        expression: string;
+        operations: AcadEditOperation[];
         overwrite?: boolean;
-        toolDir?: string;
-    }): LibreDwgEditResult;
+    }): AcadEditResult;
     thumbnail(): Promise<ThumbnailResult>;
     static open(file: string, opts?: LoadOptions): Dwg;
 }

package/dist/sdk.js

@@ -1,5 +1,6 @@
+import { editWithAcadTs, } from "./core/acad-edit.js";
+import { renderSvgWithAcadTs, } from "./core/acad-view.js";
 import { getBlocks, getEntities, getInfo, getLayers, getThumbnail, loadDrawing, toJson, toSvg, } from "./core/drawing.js";
-import { editWithLibreDwgFilter, renderSvgWithLibreDwg, } from "./core/libredwg.js";
 import { getOverview, } from "./core/overview.js";
 import { searchDrawing, } from "./core/search.js";
 export class Dwg {
@@ -36,16 +37,15 @@ export class Dwg {
     svg() {
         return toSvg(this.file, this.opts);
     }
-    view(opts = {}) {
-        return renderSvgWithLibreDwg(this.file, opts);
+    view() {
+        return renderSvgWithAcadTs(this.file);
     }
     edit(opts) {
-        return editWithLibreDwgFilter({
+        return editWithAcadTs({
             input: this.file,
             output: opts.output,
-            expression: opts.expression,
+            operations: opts.operations,
             overwrite: opts.overwrite,
-            toolDir: opts.toolDir,
         });
     }
     thumbnail() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miclivs/cadcli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Agent-friendly CAD inspection, search, viewing, and editing for DWG/DXF files.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,11 +17,13 @@
   "files": [
     "dist",
     "patches",
+    "scripts",
     "skills"
   ],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/apply-acad-ts-patch.mjs",
     "ci": "bun test --coverage && bun run build && bunx biome check src/",
     "dev": "bun run src/main.ts",
     "build:bun": "bun build --compile src/main.ts --outfile cadcli",
@@ -47,7 +49,6 @@
     "cad",
     "cli",
     "sdk",
-    "libredwg",
     "svg",
     "conversion",
     "pi-package"
@@ -67,9 +68,11 @@
     "@node-projects/acad-ts": "2.3.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
-    "minisearch": "^7.2.0",
     "nanoid": "^5.1.6"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.10.0"
+  },
   "patchedDependencies": {
     "@node-projects/acad-ts@2.3.0": "patches/@node-projects%2Facad-ts@2.3.0.patch"
   }

package/scripts/apply-acad-ts-patch.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const targets = [
+  join(root, "node_modules"),
+  dirname(dirname(root)),
+].map((nodeModulesRoot) =>
+  join(
+    nodeModulesRoot,
+    "@node-projects",
+    "acad-ts",
+    "dist",
+    "IO",
+    "DWG",
+    "DwgStreamReaders",
+    "DwgObjectReader.js",
+  ),
+);
+
+const copied = "new Uint8Array(this._memoryStream)";
+const reused = "this._memoryStream";
+
+for (const target of targets) {
+  let source;
+  try {
+    source = readFileSync(target, "utf8");
+  } catch {
+    continue;
+  }
+
+  const matches = source.split(copied).length - 1;
+  if (matches === 0) process.exit(0);
+
+  writeFileSync(target, source.replaceAll(copied, reused));
+  console.log(`cadcli: patched acad-ts DwgObjectReader (${matches} buffer copies removed)`);
+  process.exit(0);
+}

package/skills/cadcli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cadcli
-description: Inspect, search, summarize, preview, and safely edit DWG/DXF CAD drawings with the cadcli CLI. Use when the user asks about CAD files, floorplans, DWG/DXF contents, layers, blocks, entities, text, previews, or jq-backed CAD edits.
+description: Inspect, search, summarize, preview, and safely edit DWG/DXF CAD drawings with the cadcli CLI. Use when the user asks about CAD files, floorplans, DWG/DXF contents, layers, blocks, entities, text, previews, or CAD edits.
 ---
 
 # cadcli
@@ -15,7 +15,7 @@ cadcli entities <file> --limit 20 --json
 cadcli search <file> "query" --json
 ```
 
-For visual checks, prefer the high-fidelity native path when available:
+For visual checks, render an SVG preview:
 
 ```bash
 cadcli view <file> -o preview.svg
@@ -27,8 +27,25 @@ For lightweight previews from the normalized model:
 cadcli svg <file> -o preview.svg
 ```
 
-For edits, never overwrite by default. Write to a new file unless the user explicitly asks for in-place edits:
+For edits, find handles first, then write an edited copy. Never overwrite by default; use `--overwrite` only when the user explicitly asks for in-place edits:
 
 ```bash
-cadcli edit <file> --jq '<jq expression>' -o edited.dwg
+cadcli entities <file> --type TEXT --json
+cadcli search <file> "office" --json
+
+cadcli edit <file> --set-text 'New label' --text-id <id> -o edited.dwg
+cadcli edit <file> --set-layer A-TEXT --layer-id <id> -o edited.dwg
+cadcli edit <file> --set-color '#ff0000' --color-id <id> -o edited.dwg
+cadcli edit <file> --move <id> --dx 10 --dy 0 -o edited.dwg
+cadcli edit <file> --rotate <id> --angle 90 --origin 0,0 -o edited.dwg
+cadcli edit <file> --scale <id> --factor 2 -o edited.dwg
+cadcli edit <file> --copy <id> --dx 10 --dy 0 -o edited.dwg
+cadcli edit <file> --delete <id> -o edited.dwg
+
+cadcli edit <file> --add-line 0,0:10,0 --new-layer A-WALL -o edited.dwg
+cadcli edit <file> --add-circle 5,5:2 -o edited.dwg
+cadcli edit <file> --add-text 'Label' --at 5,5 --height 2.5 -o edited.dwg
+cadcli edit <file> --points '0,0;10,0;10,5' --closed -o edited.dwg
 ```
+
+Edit formats: points are `x,y` or `x,y,z`; line is `from:to`; circle is `center:radius`; arc is `center:radius:startAngle:endAngle`; color is `bylayer`, `byblock`, an AutoCAD color index, `#rrggbb`, or `r,g,b`.

package/dist/core/libredwg.d.ts

@@ -1,37 +0,0 @@
-export type LibreDwgToolName = "dwgread" | "dwgfilter";
-export interface LibreDwgEditResult {
-    input: string;
-    output: string;
-    expression: string;
-    backend: "LibreDWG";
-    tool: "dwgfilter";
-    stderr: string;
-}
-export interface LibreDwgViewResult {
-    input: string;
-    output?: string;
-    svg: string;
-    backend: "LibreDWG";
-    tool: "dwgread";
-    stderr: string;
-}
-export interface LibreDwgJsonResult {
-    input: string;
-    json: unknown;
-    backend: "LibreDWG";
-    tool: "dwgread";
-    stderr: string;
-}
-export declare function readJsonWithLibreDwg(file: string, opts?: {
-    toolDir?: string;
-}): LibreDwgJsonResult;
-export declare function renderSvgWithLibreDwg(file: string, opts?: {
-    toolDir?: string;
-}): LibreDwgViewResult;
-export declare function editWithLibreDwgFilter(opts: {
-    input: string;
-    output: string;
-    expression: string;
-    overwrite?: boolean;
-    toolDir?: string;
-}): LibreDwgEditResult;

package/dist/core/libredwg.js

@@ -1,86 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { copyFileSync, existsSync } from "node:fs";
-import { basename, delimiter, join } from "node:path";
-import { EXIT_ERROR, EXIT_UNAVAILABLE, EXIT_USER_ERROR, } from "../utils/exit-codes.js";
-import { DwgCliError } from "./errors.js";
-const WINDOWS_EXTENSIONS = [".exe", ".cmd", ".bat", ".com"];
-function candidateNames(tool) {
-    return [tool, ...WINDOWS_EXTENSIONS.map((ext) => `${tool}${ext}`)];
-}
-function findTool(tool, toolDir) {
-    const dirs = toolDir ? [toolDir] : (process.env.PATH ?? "").split(delimiter);
-    for (const dir of dirs.filter(Boolean)) {
-        for (const name of candidateNames(tool)) {
-            const candidate = join(dir, name);
-            if (existsSync(candidate))
-                return candidate;
-        }
-    }
-    return undefined;
-}
-function requireTool(tool, toolDir) {
-    const path = findTool(tool, toolDir);
-    if (path)
-        return path;
-    throw new DwgCliError(`LibreDWG tool not found: ${tool}. Install LibreDWG and make sure ${tool} is on PATH.`, "LIBREDWG_TOOL_NOT_FOUND", EXIT_UNAVAILABLE);
-}
-function preview(value) {
-    const trimmed = value.trim();
-    if (trimmed.length <= 500)
-        return trimmed;
-    return `${trimmed.slice(0, 500)}…`;
-}
-function runLibreDwgTool(tool, args, toolDir) {
-    const path = requireTool(tool, toolDir);
-    const result = spawnSync(path, args, { encoding: "utf-8" });
-    if (result.error) {
-        throw new DwgCliError(`Could not run ${tool}: ${result.error.message}`, "LIBREDWG_RUN_FAILED", EXIT_ERROR);
-    }
-    if (result.status !== 0) {
-        const details = preview(result.stderr || result.stdout);
-        throw new DwgCliError(`${tool} failed for ${basename(args.at(-1) ?? "input")}${details ? `: ${details}` : ""}`, "LIBREDWG_RUN_FAILED", EXIT_USER_ERROR);
-    }
-    return { stdout: result.stdout, stderr: result.stderr };
-}
-export function readJsonWithLibreDwg(file, opts = {}) {
-    const result = runLibreDwgTool("dwgread", ["-O", "JSON", file], opts.toolDir);
-    try {
-        return {
-            input: file,
-            json: JSON.parse(result.stdout),
-            backend: "LibreDWG",
-            tool: "dwgread",
-            stderr: result.stderr,
-        };
-    }
-    catch (error) {
-        const details = preview(result.stdout);
-        throw new DwgCliError(`dwgread produced invalid JSON for ${basename(file)}: ${error.message}${details ? `; stdout: ${details}` : ""}`, "LIBREDWG_INVALID_JSON", EXIT_USER_ERROR);
-    }
-}
-export function renderSvgWithLibreDwg(file, opts = {}) {
-    const result = runLibreDwgTool("dwgread", ["-O", "SVG", file], opts.toolDir);
-    return {
-        input: file,
-        svg: result.stdout,
-        backend: "LibreDWG",
-        tool: "dwgread",
-        stderr: result.stderr,
-    };
-}
-export function editWithLibreDwgFilter(opts) {
-    if (opts.input === opts.output && !opts.overwrite) {
-        throw new DwgCliError("Refusing to edit in place without --overwrite. Provide --output or pass --overwrite.", "EDIT_REQUIRES_OUTPUT_OR_OVERWRITE", EXIT_USER_ERROR);
-    }
-    if (opts.input !== opts.output)
-        copyFileSync(opts.input, opts.output);
-    const result = runLibreDwgTool("dwgfilter", ["-i", opts.expression, opts.output], opts.toolDir);
-    return {
-        input: opts.input,
-        output: opts.output,
-        expression: opts.expression,
-        backend: "LibreDWG",
-        tool: "dwgfilter",
-        stderr: result.stderr,
-    };
-}