@miclivs/cadcli 0.1.2 → 0.2.0

package/dist/core/acad-edit.js

@@ -0,0 +1,234 @@
+import { Arc, Circle, Color, Insert, Layer, Line, LineType, LineWeightType, LwPolyline, MText, Point, TextEntity, Transparency, XY, XYZ, } from "@node-projects/acad-ts";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { readAcadFile, writeAcadDocument } from "./acad.js";
+import { DwgCliError } from "./errors.js";
+import { writeOutput } from "./files.js";
+const degreesToRadians = (degrees) => (degrees * Math.PI) / 180;
+function xyz(point) {
+    return new XYZ(point.x, point.y, point.z ?? 0);
+}
+function xy(point) {
+    return new XY(point.x, point.y);
+}
+function handleMatches(handle, entityId) {
+    const expected = entityId.toLowerCase();
+    const text = String(handle ?? "").toLowerCase();
+    if (text === expected)
+        return true;
+    const numeric = Number(handle);
+    return (Number.isFinite(numeric) && numeric.toString(16).toLowerCase() === expected);
+}
+function modelEntities(doc) {
+    return [...(doc.modelSpace?.entities ?? [])];
+}
+function findEntity(doc, entityId) {
+    const entity = modelEntities(doc).find((item) => handleMatches(item.handle, entityId));
+    if (!entity) {
+        throw new DwgCliError(`Entity not found: ${entityId}`, "ENTITY_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    return entity;
+}
+function ensureLayer(doc, name) {
+    const existing = doc.layers?.tryGetValue(name);
+    if (existing)
+        return existing;
+    const layer = new Layer(name);
+    doc.layers?.add(layer);
+    return layer;
+}
+function ensureLineType(doc, name) {
+    const existing = doc.lineTypes?.tryGetValue(name);
+    if (existing)
+        return existing;
+    const lineType = new LineType(name);
+    doc.lineTypes?.add(lineType);
+    return lineType;
+}
+function acadColor(color) {
+    switch (color.mode) {
+        case "byLayer":
+            return Color.byLayer;
+        case "byBlock":
+            return Color.byBlock;
+        case "index":
+            return new Color(color.index);
+        case "rgb":
+            return new Color(color.r, color.g, color.b);
+    }
+}
+function lineWeight(weight) {
+    if (!Object.values(LineWeightType).includes(weight)) {
+        throw new DwgCliError(`Unsupported line weight: ${weight}`, "INVALID_LINE_WEIGHT", EXIT_USER_ERROR);
+    }
+    return weight;
+}
+function applyCommonOptions(doc, entity, options) {
+    if (options.layer)
+        entity.layer = ensureLayer(doc, options.layer);
+    if (options.color)
+        entity.color = acadColor(options.color);
+}
+function addEntity(doc, entity) {
+    if (!doc.modelSpace) {
+        throw new DwgCliError("Drawing has no model space to edit.", "MODEL_SPACE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    doc.modelSpace.entities.add(entity);
+}
+function deleteEntity(entity, entityId) {
+    const owner = entity.owner;
+    if (!owner?.entities?.remove) {
+        throw new DwgCliError(`Entity cannot be deleted: ${entityId}`, "ENTITY_NOT_DELETABLE", EXIT_USER_ERROR);
+    }
+    owner.entities.remove(entity);
+}
+function setAttribute(entity, tag, value, id) {
+    if (!(entity instanceof Insert)) {
+        throw new DwgCliError(`Entity is not a block insert: ${id}`, "ENTITY_NOT_INSERT", EXIT_USER_ERROR);
+    }
+    const attr = [...entity.attributes].find((item) => item.tag.toLowerCase() === tag.toLowerCase());
+    if (!attr) {
+        throw new DwgCliError(`Attribute not found on ${id}: ${tag}`, "ATTRIBUTE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    attr.value = value;
+}
+function applyOperation(doc, operation) {
+    switch (operation.kind) {
+        case "addPoint": {
+            const point = new Point(xyz(operation.at));
+            applyCommonOptions(doc, point, operation);
+            addEntity(doc, point);
+            return;
+        }
+        case "addLine": {
+            const line = new Line(xyz(operation.from), xyz(operation.to));
+            applyCommonOptions(doc, line, operation);
+            addEntity(doc, line);
+            return;
+        }
+        case "addCircle": {
+            const circle = new Circle();
+            circle.center = xyz(operation.center);
+            circle.radius = operation.radius;
+            applyCommonOptions(doc, circle, operation);
+            addEntity(doc, circle);
+            return;
+        }
+        case "addArc": {
+            const arc = new Arc(xyz(operation.center), operation.radius, degreesToRadians(operation.startAngleDegrees), degreesToRadians(operation.endAngleDegrees));
+            applyCommonOptions(doc, arc, operation);
+            addEntity(doc, arc);
+            return;
+        }
+        case "addText": {
+            const text = new TextEntity();
+            text.value = operation.text;
+            text.insertPoint = xyz(operation.at);
+            if (operation.height !== undefined)
+                text.height = operation.height;
+            if (operation.rotationDegrees !== undefined) {
+                text.rotation = degreesToRadians(operation.rotationDegrees);
+            }
+            applyCommonOptions(doc, text, operation);
+            addEntity(doc, text);
+            return;
+        }
+        case "addMText": {
+            const text = new MText();
+            text.value = operation.text;
+            text.insertPoint = xyz(operation.at);
+            if (operation.height !== undefined)
+                text.height = operation.height;
+            if (operation.width !== undefined)
+                text.rectangleWidth = operation.width;
+            if (operation.rotationDegrees !== undefined) {
+                text.rotation = degreesToRadians(operation.rotationDegrees);
+            }
+            applyCommonOptions(doc, text, operation);
+            addEntity(doc, text);
+            return;
+        }
+        case "addPolyline": {
+            const polyline = new LwPolyline(operation.points.map(xy));
+            polyline.isClosed = operation.closed ?? false;
+            applyCommonOptions(doc, polyline, operation);
+            addEntity(doc, polyline);
+            return;
+        }
+    }
+    const entity = findEntity(doc, operation.entityId);
+    switch (operation.kind) {
+        case "setText":
+            if (!(entity instanceof TextEntity || entity instanceof MText)) {
+                throw new DwgCliError(`Entity is not editable text: ${operation.entityId}`, "ENTITY_NOT_TEXT", EXIT_USER_ERROR);
+            }
+            entity.value = operation.text;
+            return;
+        case "setLayer":
+            entity.layer = ensureLayer(doc, operation.layer);
+            return;
+        case "setColor":
+            entity.color = acadColor(operation.color);
+            return;
+        case "setLineType":
+            entity.lineType = ensureLineType(doc, operation.lineType);
+            return;
+        case "setLineWeight":
+            entity.lineWeight = lineWeight(operation.weight);
+            return;
+        case "setTransparency":
+            entity.transparency = Transparency.fromAlphaValue(operation.alpha);
+            return;
+        case "setVisibility":
+            entity.isInvisible = !operation.visible;
+            return;
+        case "move":
+            entity.applyTranslation(new XYZ(operation.dx, operation.dy, operation.dz ?? 0));
+            return;
+        case "rotate": {
+            const origin = operation.origin ? xyz(operation.origin) : XYZ.zero;
+            entity.applyTranslation(new XYZ(-origin.x, -origin.y, -origin.z));
+            entity.applyRotation(XYZ.axisZ, degreesToRadians(operation.angleDegrees));
+            entity.applyTranslation(origin);
+            return;
+        }
+        case "scale":
+            entity.applyScaling(new XYZ(operation.factor, operation.factor, operation.factor), operation.origin ? xyz(operation.origin) : XYZ.zero);
+            return;
+        case "copy": {
+            const clone = entity.clone();
+            clone.applyTranslation(new XYZ(operation.dx ?? 0, operation.dy ?? 0, operation.dz ?? 0));
+            addEntity(doc, clone);
+            return;
+        }
+        case "matchProperties": {
+            const source = findEntity(doc, operation.sourceId);
+            entity.matchProperties(source);
+            return;
+        }
+        case "setAttribute":
+            setAttribute(entity, operation.tag, operation.value, operation.entityId);
+            return;
+        case "delete":
+            deleteEntity(entity, operation.entityId);
+            return;
+    }
+}
+export function editWithAcadTs(opts) {
+    if (opts.operations.length === 0) {
+        throw new DwgCliError("No acad-ts edit operation specified.", "MISSING_EDIT_OPERATION", EXIT_USER_ERROR);
+    }
+    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);
+    }
+    const { bytes, doc, format } = readAcadFile(opts.input);
+    for (const operation of opts.operations)
+        applyOperation(doc, operation);
+    writeOutput(opts.output, writeAcadDocument(doc, format, bytes.length));
+    return {
+        input: opts.input,
+        output: opts.output,
+        backend: "acad-ts",
+        operations: opts.operations,
+        changed: opts.operations.length,
+    };
+}

package/dist/core/acad-view.d.ts

@@ -0,0 +1,6 @@
+export interface AcadSvgViewResult {
+    input: string;
+    svg: string;
+    backend: "acad-ts";
+}
+export declare function renderSvgWithAcadTs(file: string): AcadSvgViewResult;

package/dist/core/acad-view.js

@@ -0,0 +1,22 @@
+import { Color } from "@node-projects/acad-ts";
+import { readAcadFile, writeAcadSvg } from "./acad.js";
+// acad-ts SvgWriter currently crashes when text resolves ByLayer/ByBlock
+// through an index that has no RGB entry. Normalize render-only colors here;
+// the source file is untouched because view reparses the document every time.
+function makeEntityColorsRenderable(doc) {
+    for (const entity of doc.modelSpace?.entities ?? []) {
+        const candidate = entity;
+        if (candidate.color?.isByLayer || candidate.color?.isByBlock) {
+            candidate.color = Color.black;
+        }
+    }
+}
+export function renderSvgWithAcadTs(file) {
+    const { doc } = readAcadFile(file);
+    makeEntityColorsRenderable(doc);
+    return {
+        input: file,
+        svg: writeAcadSvg(doc),
+        backend: "acad-ts",
+    };
+}

package/dist/core/acad.d.ts

@@ -0,0 +1,11 @@
+import { type CadDocument } from "@node-projects/acad-ts";
+import type { DwgFormat } from "../types.js";
+export interface AcadFile {
+    bytes: Uint8Array;
+    doc: CadDocument;
+    format: DwgFormat;
+}
+export declare function parseAcadDocument(bytes: Uint8Array, format: DwgFormat): CadDocument;
+export declare function readAcadFile(file: string): AcadFile;
+export declare function writeAcadDocument(doc: CadDocument, format: DwgFormat, originalBytes: number): Uint8Array;
+export declare function writeAcadSvg(doc: CadDocument): string;

package/dist/core/acad.js

@@ -0,0 +1,82 @@
+import { DwgReader, DwgWriter, DxfReader, DxfWriter, SvgWriter, } from "@node-projects/acad-ts";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { arrayBufferFor } from "./adapter.js";
+import { DwgCliError } from "./errors.js";
+import { readCadFile } from "./files.js";
+export function parseAcadDocument(bytes, format) {
+    try {
+        return format === "DWG"
+            ? DwgReader.readFromStream(arrayBufferFor(bytes))
+            : DxfReader.readFromStream(bytes);
+    }
+    catch (error) {
+        throw new DwgCliError(`Could not parse ${format}: ${error.message}`, "PARSE_FAILED", EXIT_USER_ERROR);
+    }
+}
+export function readAcadFile(file) {
+    const { bytes, format } = readCadFile(file);
+    return { bytes, format, doc: parseAcadDocument(bytes, format) };
+}
+function writeDwg(doc, originalBytes) {
+    let size = Math.max(1024 * 1024, originalBytes * 4);
+    const maxSize = 512 * 1024 * 1024;
+    while (size <= maxSize) {
+        const buffer = new ArrayBuffer(size);
+        const writer = new DwgWriter(buffer, doc);
+        writer.write();
+        if (writer.bytesWritten <= size) {
+            return new Uint8Array(buffer).slice(0, writer.bytesWritten);
+        }
+        size *= 2;
+    }
+    throw new DwgCliError("Could not write DWG: output exceeded the maximum supported buffer size.", "ACAD_WRITE_FAILED", EXIT_USER_ERROR);
+}
+function writeDxf(doc) {
+    let content = "";
+    DxfWriter.writeToStream({
+        write(value) {
+            content +=
+                typeof value === "string" ? value : new TextDecoder().decode(value);
+        },
+        flush() { },
+        close() { },
+    }, doc);
+    return new TextEncoder().encode(content);
+}
+export function writeAcadDocument(doc, format, originalBytes) {
+    try {
+        return format === "DWG" ? writeDwg(doc, originalBytes) : writeDxf(doc);
+    }
+    catch (error) {
+        if (error instanceof DwgCliError)
+            throw error;
+        throw new DwgCliError(`Could not write ${format}: ${error.message}`, "ACAD_WRITE_FAILED", EXIT_USER_ERROR);
+    }
+}
+function trimNullPadding(bytes) {
+    const end = bytes.indexOf(0);
+    return end === -1 ? bytes : bytes.slice(0, end);
+}
+function isOutputCapacityError(error) {
+    return /offset is out of bounds|too small|outside the bounds/i.test(error.message);
+}
+export function writeAcadSvg(doc) {
+    let size = 1024 * 1024;
+    const maxSize = 256 * 1024 * 1024;
+    while (size <= maxSize) {
+        const output = new Uint8Array(size);
+        try {
+            const writer = new SvgWriter(output, doc);
+            writer.write();
+            writer.dispose();
+            return new TextDecoder().decode(trimNullPadding(output));
+        }
+        catch (error) {
+            if (!isOutputCapacityError(error) || size >= maxSize) {
+                throw new DwgCliError(`Could not render SVG with acad-ts: ${error.message}`, "ACAD_SVG_FAILED", EXIT_USER_ERROR);
+            }
+            size *= 2;
+        }
+    }
+    throw new DwgCliError("Could not render SVG with acad-ts: output exceeded the maximum supported buffer size.", "ACAD_SVG_FAILED", EXIT_USER_ERROR);
+}

package/dist/core/adapter.d.ts

@@ -6,9 +6,3 @@ export declare class AcadTsReader implements DrawingReader {
     parse(_file: string, bytes: Uint8Array, format: DwgFormat): Promise<unknown>;
     thumbnail(): Promise<ThumbnailResult | null>;
 }
-export declare class NativeLibreDwgReader implements DrawingReader {
-    private readonly toolDir?;
-    constructor(toolDir?: string | undefined);
-    parse(file: string, _bytes: Uint8Array, _format: DwgFormat): Promise<unknown>;
-    thumbnail(): Promise<ThumbnailResult | null>;
-}

package/dist/core/adapter.js

@@ -1,7 +1,6 @@
 import { DwgReader, DxfReader } from "@node-projects/acad-ts";
 import { EXIT_UNAVAILABLE, EXIT_USER_ERROR } from "../utils/exit-codes.js";
 import { DwgCliError } from "./errors.js";
-import { readJsonWithLibreDwg } from "./libredwg.js";
 function asRecord(value) {
     return value && typeof value === "object"
         ? value
@@ -151,15 +150,3 @@ export class AcadTsReader {
         throw new DwgCliError("Thumbnail extraction is not available through acad-ts.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
     }
 }
-export class NativeLibreDwgReader {
-    toolDir;
-    constructor(toolDir) {
-        this.toolDir = toolDir;
-    }
-    async parse(file, _bytes, _format) {
-        return readJsonWithLibreDwg(file, { toolDir: this.toolDir }).json;
-    }
-    async thumbnail() {
-        throw new DwgCliError("Thumbnail extraction is not available through native LibreDWG.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
-    }
-}

package/dist/core/drawing.d.ts

@@ -1,7 +1,6 @@
 import type { DrawingReader, DwgBlock, DwgDocument, DwgEntity, DwgLayer, EntityFilter, SvgResult, ThumbnailResult } from "../types.js";
 export interface LoadOptions {
     reader?: DrawingReader;
-    toolDir?: string;
 }
 export declare function loadDrawing(file: string, opts?: LoadOptions): Promise<DwgDocument>;
 export declare function getInfo(file: string, opts?: LoadOptions): Promise<import("../types.js").DwgSummary>;

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.2",
+  "version": "0.2.0",
   "description": "Agent-friendly CAD inspection, search, viewing, and editing for DWG/DXF files.",
   "type": "module",
   "main": "dist/index.js",
@@ -49,7 +49,6 @@
     "cad",
     "cli",
     "sdk",
-    "libredwg",
     "svg",
     "conversion",
     "pi-package"

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`.