@miclivs/cadcli 0.1.2 → 0.2.0

package/README.md

@@ -6,7 +6,7 @@ Agent-friendly CAD inspection, search, viewing, and editing for DWG/DXF files.
 npm install -g @miclivs/cadcli
 ```
 
-Common inspection/search commands use a pure TypeScript parser by default. Native LibreDWG tools are only needed for high-fidelity `view` and jq-backed `edit`.
+Inspection, search, viewing, and editing use the pure TypeScript `acad-ts` backend. No native CAD tools are required.
 
 ## Why cadcli
 
@@ -17,7 +17,7 @@ cadcli info floorplan.dwg --json
 cadcli overview floorplan.dwg
 cadcli search floorplan.dwg "conference" --layer A-TEXT --json
 cadcli view floorplan.dwg -o preview.svg
-cadcli edit floorplan.dwg --jq '.OBJECTS[]' -o edited.dwg
+cadcli edit floorplan.dwg --set-text "Conference" --text-id 2A -o edited.dwg
 ```
 
 ## Workflow
@@ -42,8 +42,17 @@ cadcli entities <file>                   # entities, optionally filtered
 cadcli search <file> [query]             # search IDs, types, layers, text, raw fields
   --query "door" --type TEXT --layer A-TEXT --limit 10 --score --no-snippets
 
-cadcli view <file> [-o preview.svg]      # high-fidelity SVG preview
-cadcli edit <file> --jq <expr> -o out.dwg
+cadcli view <file> [-o preview.svg]      # SVG preview
+cadcli edit <file> --set-text <text> --text-id <id> -o out.dwg
+cadcli edit <file> --set-layer <layer> --layer-id <id> -o out.dwg
+cadcli edit <file> --set-color '#ff0000' --color-id <id> -o out.dwg
+cadcli edit <file> --move <id> --dx 10 --dy 0 -o out.dwg
+cadcli edit <file> --rotate <id> --angle 90 --origin 0,0 -o out.dwg
+cadcli edit <file> --scale <id> --factor 2 -o out.dwg
+cadcli edit <file> --copy <id> --dx 10 --dy 0 -o out.dwg
+cadcli edit <file> --delete <id> -o out.dwg
+cadcli edit <file> --add-line 0,0:10,0 --new-layer A-WALL -o out.dwg
+cadcli edit <file> --add-text "Label" --at 5,5 --height 2.5 -o out.dwg
 cadcli json <file> [-o drawing.json]     # normalized JSON
 cadcli svg <file> [-o sketch.svg]        # best-effort SVG from normalized JSON
 cadcli thumbnail <file> [-o thumb.png]   # embedded thumbnail when available
@@ -74,22 +83,24 @@ SEARCH HINTS
 
 ## Viewing vs SVG export
 
-`cadcli view` is the high-fidelity SVG path.
+`cadcli view` renders SVG through acad-ts directly from the CAD document.
 
-`cadcli svg` renders a lightweight SVG from cadcli’s normalized JSON model. It is useful for quick agent previews and debugging, but it is not a replacement for `view`.
+`cadcli svg` renders a lightweight SVG from cadcli’s normalized JSON model. It is useful for quick agent previews and debugging, while `view` preserves more of acad-ts’ CAD model semantics.
 
 ## Editing
 
-Editing is intentionally copy-first:
+Editing is intentionally copy-first and typed. You can update text, layers, color, linetype, lineweight, transparency, visibility, block attributes, transforms, copies, and deletion; you can also add point, line, circle, arc, text, mtext, and lightweight polyline entities.
 
 ```bash
-cadcli edit drawing.dwg --jq '.OBJECTS[]' -o edited.dwg
+cadcli edit drawing.dwg --set-text "New label" --text-id 2A -o edited.dwg
+cadcli edit drawing.dwg --set-attr ROOM=204 --insert-id 3F -o edited.dwg
+cadcli edit drawing.dwg --points '0,0;10,0;10,5' --closed --new-layer A-WALL -o edited.dwg
 ```
 
 In-place edits are refused unless you explicitly pass `--overwrite`:
 
 ```bash
-cadcli edit drawing.dwg --jq '.OBJECTS[]' --overwrite
+cadcli edit drawing.dwg --set-text "New label" --text-id 2A --overwrite
 ```
 
 ## SDK
@@ -107,7 +118,7 @@ const preview = drawing.view();
 console.log(preview.svg);
 ```
 
-The public SDK is intentionally small: `Dwg` plus stable CAD/result types. Native tool details stay behind the SDK methods.
+The public SDK is intentionally small: `Dwg` plus stable CAD/result types.
 
 ## Cache
 
@@ -123,9 +134,7 @@ Set `CADCLI_CACHE_DIR` to override this location.
 
 ## Requirements
 
-Inspection, overview, layers, blocks, entities, search, JSON, and lightweight SVG export work through the default pure TypeScript parser.
-
-Install native LibreDWG tools for advanced workflows: `dwgread` for high-fidelity `view`, and `dwgfilter` for edits.
+Inspection, overview, layers, blocks, entities, search, JSON, SVG export, viewing, and editing work through the default pure TypeScript acad-ts backend.
 
 ## License
 

package/dist/commands/edit.d.ts

@@ -1,8 +1,48 @@
 import type { OutputOptions } from "../utils/output.js";
 export interface EditOptions extends OutputOptions {
-    jq?: string;
     output?: string;
     overwrite?: boolean;
-    toolDir?: string;
+    setText?: string;
+    textId?: string;
+    delete?: string;
+    move?: string;
+    dx?: string;
+    dy?: string;
+    dz?: string;
+    setLayer?: string;
+    layerId?: string;
+    setColor?: string;
+    colorId?: string;
+    setLinetype?: string;
+    linetypeId?: string;
+    setLineweight?: string;
+    lineweightId?: string;
+    setTransparency?: string;
+    transparencyId?: string;
+    hide?: string;
+    show?: string;
+    rotate?: string;
+    angle?: string;
+    origin?: string;
+    scale?: string;
+    factor?: string;
+    copy?: string;
+    matchProperties?: string;
+    sourceId?: string;
+    setAttr?: string;
+    insertId?: string;
+    addPoint?: string;
+    addLine?: string;
+    addCircle?: string;
+    addArc?: string;
+    addText?: string;
+    addMtext?: string;
+    at?: string;
+    height?: string;
+    width?: string;
+    closed?: boolean;
+    points?: string;
+    newLayer?: string;
+    newColor?: string;
 }
 export declare function edit(file: string, options: EditOptions): Promise<void>;

package/dist/commands/edit.js

@@ -1,21 +1,295 @@
-import { editWithLibreDwgFilter } from "../core/libredwg.js";
+import { editWithAcadTs, } from "../core/acad-edit.js";
 import { output, success } from "../utils/output.js";
 import { handleCommandError, userError } from "./shared.js";
+function numberOption(value, name) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw userError(`Invalid ${name}: ${value}`, "INVALID_NUMBER");
+    }
+    return parsed;
+}
+function pointOption(value, name) {
+    if (!value)
+        throw userError(`${name} requires x,y[,z].`, "INVALID_POINT");
+    const parts = value.split(",").map((part) => numberOption(part, name));
+    if (parts.length < 2 || parts.length > 3) {
+        throw userError(`${name} requires x,y[,z].`, "INVALID_POINT");
+    }
+    return { x: parts[0], y: parts[1], z: parts[2] };
+}
+function pointsOption(value, name) {
+    if (!value)
+        throw userError(`${name} requires x,y pairs.`, "INVALID_POINT");
+    const points = value.split(/[;|]/).map((part) => pointOption(part, name));
+    if (points.length < 2) {
+        throw userError(`${name} requires at least two points.`, "INVALID_POINT");
+    }
+    return points;
+}
+function colorOption(value, name) {
+    if (!value)
+        throw userError(`${name} requires a color.`, "INVALID_COLOR");
+    const normalized = value.toLowerCase();
+    if (normalized === "bylayer")
+        return { mode: "byLayer" };
+    if (normalized === "byblock")
+        return { mode: "byBlock" };
+    if (/^#?[0-9a-f]{6}$/i.test(value)) {
+        const hex = value.replace("#", "");
+        return {
+            mode: "rgb",
+            r: Number.parseInt(hex.slice(0, 2), 16),
+            g: Number.parseInt(hex.slice(2, 4), 16),
+            b: Number.parseInt(hex.slice(4, 6), 16),
+        };
+    }
+    if (value.includes(",")) {
+        const [r, g, b] = value.split(",").map((part) => numberOption(part, name));
+        return { mode: "rgb", r, g, b };
+    }
+    return { mode: "index", index: numberOption(value, name) };
+}
+function createOptions(options) {
+    return {
+        layer: options.newLayer,
+        color: options.newColor
+            ? colorOption(options.newColor, "--new-color")
+            : undefined,
+    };
+}
+function acadOperations(options) {
+    const operations = [];
+    if (options.setText !== undefined) {
+        if (!options.textId) {
+            throw userError("--set-text requires --text-id <id>.", "MISSING_TEXT_ID");
+        }
+        operations.push({
+            kind: "setText",
+            entityId: options.textId,
+            text: options.setText,
+        });
+    }
+    if (options.setLayer !== undefined) {
+        if (!options.layerId) {
+            throw userError("--set-layer requires --layer-id <id>.", "MISSING_LAYER_ID");
+        }
+        operations.push({
+            kind: "setLayer",
+            entityId: options.layerId,
+            layer: options.setLayer,
+        });
+    }
+    if (options.setColor !== undefined) {
+        if (!options.colorId) {
+            throw userError("--set-color requires --color-id <id>.", "MISSING_COLOR_ID");
+        }
+        operations.push({
+            kind: "setColor",
+            entityId: options.colorId,
+            color: colorOption(options.setColor, "--set-color"),
+        });
+    }
+    if (options.setLinetype !== undefined) {
+        if (!options.linetypeId) {
+            throw userError("--set-linetype requires --linetype-id <id>.", "MISSING_LINETYPE_ID");
+        }
+        operations.push({
+            kind: "setLineType",
+            entityId: options.linetypeId,
+            lineType: options.setLinetype,
+        });
+    }
+    if (options.setLineweight !== undefined) {
+        if (!options.lineweightId) {
+            throw userError("--set-lineweight requires --lineweight-id <id>.", "MISSING_LINEWEIGHT_ID");
+        }
+        operations.push({
+            kind: "setLineWeight",
+            entityId: options.lineweightId,
+            weight: numberOption(options.setLineweight, "--set-lineweight"),
+        });
+    }
+    if (options.setTransparency !== undefined) {
+        if (!options.transparencyId) {
+            throw userError("--set-transparency requires --transparency-id <id>.", "MISSING_TRANSPARENCY_ID");
+        }
+        operations.push({
+            kind: "setTransparency",
+            entityId: options.transparencyId,
+            alpha: numberOption(options.setTransparency, "--set-transparency"),
+        });
+    }
+    if (options.hide !== undefined) {
+        operations.push({
+            kind: "setVisibility",
+            entityId: options.hide,
+            visible: false,
+        });
+    }
+    if (options.show !== undefined) {
+        operations.push({
+            kind: "setVisibility",
+            entityId: options.show,
+            visible: true,
+        });
+    }
+    if (options.move !== undefined) {
+        operations.push({
+            kind: "move",
+            entityId: options.move,
+            dx: numberOption(options.dx ?? "0", "--dx"),
+            dy: numberOption(options.dy ?? "0", "--dy"),
+            dz: options.dz === undefined ? undefined : numberOption(options.dz, "--dz"),
+        });
+    }
+    if (options.rotate !== undefined) {
+        operations.push({
+            kind: "rotate",
+            entityId: options.rotate,
+            angleDegrees: numberOption(options.angle, "--angle"),
+            origin: options.origin
+                ? pointOption(options.origin, "--origin")
+                : undefined,
+        });
+    }
+    if (options.scale !== undefined) {
+        operations.push({
+            kind: "scale",
+            entityId: options.scale,
+            factor: numberOption(options.factor, "--factor"),
+            origin: options.origin
+                ? pointOption(options.origin, "--origin")
+                : undefined,
+        });
+    }
+    if (options.copy !== undefined) {
+        operations.push({
+            kind: "copy",
+            entityId: options.copy,
+            dx: options.dx === undefined ? undefined : numberOption(options.dx, "--dx"),
+            dy: options.dy === undefined ? undefined : numberOption(options.dy, "--dy"),
+            dz: options.dz === undefined ? undefined : numberOption(options.dz, "--dz"),
+        });
+    }
+    if (options.matchProperties !== undefined) {
+        if (!options.sourceId) {
+            throw userError("--match-properties requires --source-id <id>.", "MISSING_SOURCE_ID");
+        }
+        operations.push({
+            kind: "matchProperties",
+            entityId: options.matchProperties,
+            sourceId: options.sourceId,
+        });
+    }
+    if (options.setAttr !== undefined) {
+        if (!options.insertId) {
+            throw userError("--set-attr requires --insert-id <id>.", "MISSING_INSERT_ID");
+        }
+        const [tag, ...valueParts] = options.setAttr.split("=");
+        if (!tag || valueParts.length === 0) {
+            throw userError("--set-attr requires TAG=VALUE.", "INVALID_ATTRIBUTE_EDIT");
+        }
+        operations.push({
+            kind: "setAttribute",
+            entityId: options.insertId,
+            tag,
+            value: valueParts.join("="),
+        });
+    }
+    if (options.delete !== undefined) {
+        operations.push({ kind: "delete", entityId: options.delete });
+    }
+    const common = createOptions(options);
+    if (options.addPoint !== undefined) {
+        operations.push({
+            kind: "addPoint",
+            at: pointOption(options.addPoint, "--add-point"),
+            ...common,
+        });
+    }
+    if (options.addLine !== undefined) {
+        const [from, to] = options.addLine.split(":");
+        operations.push({
+            kind: "addLine",
+            from: pointOption(from, "--add-line"),
+            to: pointOption(to, "--add-line"),
+            ...common,
+        });
+    }
+    if (options.addCircle !== undefined) {
+        const [center, radius] = options.addCircle.split(":");
+        operations.push({
+            kind: "addCircle",
+            center: pointOption(center, "--add-circle"),
+            radius: numberOption(radius, "--add-circle radius"),
+            ...common,
+        });
+    }
+    if (options.addArc !== undefined) {
+        const [center, radius, start, end] = options.addArc.split(":");
+        operations.push({
+            kind: "addArc",
+            center: pointOption(center, "--add-arc"),
+            radius: numberOption(radius, "--add-arc radius"),
+            startAngleDegrees: numberOption(start, "--add-arc start angle"),
+            endAngleDegrees: numberOption(end, "--add-arc end angle"),
+            ...common,
+        });
+    }
+    if (options.addText !== undefined) {
+        operations.push({
+            kind: "addText",
+            text: options.addText,
+            at: pointOption(options.at, "--at"),
+            height: options.height
+                ? numberOption(options.height, "--height")
+                : undefined,
+            rotationDegrees: options.angle
+                ? numberOption(options.angle, "--angle")
+                : undefined,
+            ...common,
+        });
+    }
+    if (options.addMtext !== undefined) {
+        operations.push({
+            kind: "addMText",
+            text: options.addMtext,
+            at: pointOption(options.at, "--at"),
+            height: options.height
+                ? numberOption(options.height, "--height")
+                : undefined,
+            width: options.width ? numberOption(options.width, "--width") : undefined,
+            rotationDegrees: options.angle
+                ? numberOption(options.angle, "--angle")
+                : undefined,
+            ...common,
+        });
+    }
+    if (options.points !== undefined) {
+        operations.push({
+            kind: "addPolyline",
+            points: pointsOption(options.points, "--points"),
+            closed: options.closed,
+            ...common,
+        });
+    }
+    return operations;
+}
 export async function edit(file, options) {
     try {
-        if (!options.jq) {
-            throw userError("No edit expression specified. Use --jq <expression>.", "MISSING_EDIT_EXPRESSION");
+        const operations = acadOperations(options);
+        if (operations.length === 0) {
+            throw userError("No edit operation specified. Use --set-text, --set-layer, --move, --delete, or an add-* operation.", "MISSING_EDIT_OPERATION");
         }
-        const result = editWithLibreDwgFilter({
+        const result = editWithAcadTs({
             input: file,
             output: options.output ?? file,
-            expression: options.jq,
+            operations,
             overwrite: options.overwrite,
-            toolDir: options.toolDir,
         });
         output(options, {
             json: () => ({ success: true, ...result }),
-            human: () => success(`Edited ${result.output} with LibreDWG dwgfilter`),
+            human: () => success(`Edited ${result.output} with acad-ts`),
         });
     }
     catch (err) {

package/dist/commands/json.js

@@ -5,7 +5,6 @@ export async function json(file, options) {
     try {
         const doc = await toJson(file, {
             reader: options.reader,
-            toolDir: options.toolDir,
         });
         const content = `${stringifyJson(doc)}\n`;
         if (options.output) {

package/dist/commands/shared.d.ts

@@ -4,7 +4,6 @@ import type { DrawingReader } from "../types.js";
 import type { OutputOptions } from "../utils/output.js";
 export interface DrawingCommandOptions extends OutputOptions {
     reader?: DrawingReader;
-    toolDir?: string;
 }
 export interface OutputFileOptions extends OutputOptions {
     output?: string;

package/dist/commands/shared.js

@@ -6,7 +6,6 @@ import { error, output, success } from "../utils/output.js";
 export function drawingFor(file, options) {
     return Dwg.open(file, {
         reader: options.reader,
-        toolDir: options.toolDir,
     });
 }
 export function userError(message, code = "USER_ERROR") {

package/dist/commands/svg.js

@@ -4,7 +4,6 @@ export async function svg(file, options) {
     try {
         const result = await toSvg(file, {
             reader: options.reader,
-            toolDir: options.toolDir,
         });
         if (options.output) {
             writeCommandOutput(options, result.svg, () => ({

package/dist/commands/thumbnail.js

@@ -5,7 +5,6 @@ export async function thumbnail(file, options) {
     try {
         const result = await getThumbnail(file, {
             reader: options.reader,
-            toolDir: options.toolDir,
         });
         if (!options.output) {
             output(options, {

package/dist/commands/view.d.ts

@@ -1,6 +1,5 @@
 import type { OutputOptions } from "../utils/output.js";
 export interface ViewOptions extends OutputOptions {
     output?: string;
-    toolDir?: string;
 }
 export declare function view(file: string, options: ViewOptions): Promise<void>;

package/dist/commands/view.js

@@ -1,21 +1,19 @@
-import { renderSvgWithLibreDwg } from "../core/libredwg.js";
+import { renderSvgWithAcadTs } from "../core/acad-view.js";
 import { handleCommandError, writeCommandOutput } from "./shared.js";
 export async function view(file, options) {
     try {
-        const result = renderSvgWithLibreDwg(file, { toolDir: options.toolDir });
+        const result = renderSvgWithAcadTs(file);
         const svg = result.svg;
-        const tool = result.tool;
         if (options.output) {
             writeCommandOutput(options, svg, () => ({
                 success: true,
                 file: options.output,
-                backend: "LibreDWG",
-                tool,
-            }), `Wrote ${options.output} with ${tool}`);
+                backend: "acad-ts",
+            }), `Wrote ${options.output} with acad-ts`);
             return;
         }
         if (options.json) {
-            console.log(JSON.stringify({ backend: "LibreDWG", tool, svg }, null, 2));
+            console.log(JSON.stringify({ backend: "acad-ts", svg }, null, 2));
         }
         else {
             console.log(svg.trimEnd());

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

@@ -0,0 +1,142 @@
+export type AcadPoint = {
+    x: number;
+    y: number;
+    z?: number;
+};
+export type AcadColor = {
+    mode: "byLayer";
+} | {
+    mode: "byBlock";
+} | {
+    mode: "index";
+    index: number;
+} | {
+    mode: "rgb";
+    r: number;
+    g: number;
+    b: number;
+};
+export type AcadEditOperation = {
+    kind: "setText";
+    entityId: string;
+    text: string;
+} | {
+    kind: "setLayer";
+    entityId: string;
+    layer: string;
+} | {
+    kind: "setColor";
+    entityId: string;
+    color: AcadColor;
+} | {
+    kind: "setLineType";
+    entityId: string;
+    lineType: string;
+} | {
+    kind: "setLineWeight";
+    entityId: string;
+    weight: number;
+} | {
+    kind: "setTransparency";
+    entityId: string;
+    alpha: number;
+} | {
+    kind: "setVisibility";
+    entityId: string;
+    visible: boolean;
+} | {
+    kind: "move";
+    entityId: string;
+    dx: number;
+    dy: number;
+    dz?: number;
+} | {
+    kind: "rotate";
+    entityId: string;
+    angleDegrees: number;
+    origin?: AcadPoint;
+} | {
+    kind: "scale";
+    entityId: string;
+    factor: number;
+    origin?: AcadPoint;
+} | {
+    kind: "copy";
+    entityId: string;
+    dx?: number;
+    dy?: number;
+    dz?: number;
+} | {
+    kind: "matchProperties";
+    entityId: string;
+    sourceId: string;
+} | {
+    kind: "setAttribute";
+    entityId: string;
+    tag: string;
+    value: string;
+} | {
+    kind: "delete";
+    entityId: string;
+} | {
+    kind: "addPoint";
+    at: AcadPoint;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addLine";
+    from: AcadPoint;
+    to: AcadPoint;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addCircle";
+    center: AcadPoint;
+    radius: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addArc";
+    center: AcadPoint;
+    radius: number;
+    startAngleDegrees: number;
+    endAngleDegrees: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addText";
+    text: string;
+    at: AcadPoint;
+    height?: number;
+    rotationDegrees?: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addMText";
+    text: string;
+    at: AcadPoint;
+    height?: number;
+    width?: number;
+    rotationDegrees?: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addPolyline";
+    points: AcadPoint[];
+    closed?: boolean;
+    layer?: string;
+    color?: AcadColor;
+};
+export interface AcadEditResult {
+    input: string;
+    output: string;
+    backend: "acad-ts";
+    operations: AcadEditOperation[];
+    changed: number;
+}
+export declare function editWithAcadTs(opts: {
+    input: string;
+    output: string;
+    operations: AcadEditOperation[];
+    overwrite?: boolean;
+}): AcadEditResult;