@miclivs/cadcli 0.1.0

package/dist/main.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import chalk from "chalk";
+import { Command } from "commander";
+import { blocks } from "./commands/blocks.js";
+import { edit } from "./commands/edit.js";
+import { entities } from "./commands/entities.js";
+import { info } from "./commands/info.js";
+import { json } from "./commands/json.js";
+import { layers } from "./commands/layers.js";
+import { overview } from "./commands/overview.js";
+import { search } from "./commands/search.js";
+import { svg } from "./commands/svg.js";
+import { thumbnail } from "./commands/thumbnail.js";
+import { view } from "./commands/view.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+const program = new Command();
+function showHelp() {
+    console.log(`Usage: cadcli [options] [command]
+
+Agent-friendly CAD inspection, search, viewing, and editing.
+
+Examples:
+  $ cadcli info drawing.dwg              Summarize a drawing
+  $ cadcli overview drawing.dwg          Show search vocabulary
+  $ cadcli layers drawing.dwg --json     List layers for scripts/agents
+  $ 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
+
+Workflow: info → overview → search/entities → view/edit
+
+Inspecting:
+  info <file>          Drawing metadata and counts
+  overview <file>      Search vocabulary by layer/type/block/text
+  layers <file>        List layers
+  blocks <file>        List blocks
+  entities <file>      List/filter entities
+  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
+
+Conversion:
+  json <file>          Export normalized JSON
+  svg <file>           Render best-effort SVG from normalized JSON
+  thumbnail <file>     Extract embedded thumbnail when available
+
+Options:
+  --json               Output as JSON
+  -q, --quiet          Suppress non-essential output
+  --no-color           Disable color
+  -v, --version        Show version
+  -h, --help           Show this help
+
+Docs: https://github.com/Michaelliv/cadcli`);
+}
+program
+    .name("cadcli")
+    .description("Agent-friendly CAD inspection, search, viewing, and editing.")
+    .version(`cadcli ${version}`, "-v, --version")
+    .option("--json", "Output as JSON")
+    .option("-q, --quiet", "Suppress output")
+    .option("--no-color", "Disable color")
+    .showSuggestionAfterError(true)
+    .helpCommand(false)
+    .addHelpText("before", () => {
+    showHelp();
+    process.exit(0);
+});
+program.hook("preAction", (cmd) => {
+    if (cmd.optsWithGlobals().color === false)
+        chalk.level = 0;
+});
+program
+    .command("info <file>")
+    .description("Show drawing metadata and summary")
+    .action(async (file, _opts, cmd) => info(file, cmd.optsWithGlobals()));
+program
+    .command("overview <file>")
+    .description("Show search vocabulary by layer/type/block/text")
+    .option("--keywords <n>", "Max keywords/hints returned")
+    .option("--samples <n>", "Max text samples returned")
+    .action(async (file, opts, cmd) => overview(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("layers <file>")
+    .description("List layers")
+    .option("--total", "Return layer count")
+    .action(async (file, opts, cmd) => layers(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("blocks <file>")
+    .description("List blocks")
+    .option("--total", "Return block count")
+    .action(async (file, opts, cmd) => blocks(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("entities <file>")
+    .description("List/filter entities")
+    .option("--type <name>", "Filter by entity type")
+    .option("--layer <name>", "Filter by layer")
+    .option("--limit <n>", "Limit entities returned")
+    .option("--total", "Return entity count")
+    .action(async (file, opts, cmd) => entities(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("search <file> [query...]")
+    .description("Search entities by text, type, layer, and raw fields")
+    .option("--query <text>", "Search query")
+    .option("--type <name>", "Filter by entity type")
+    .option("--layer <name>", "Filter by layer")
+    .option("--limit <n>", "Limit results")
+    .option("--total", "Return result count")
+    .option("--score", "Include relevance scores")
+    .option("--no-snippets", "Omit matched snippets")
+    .action(async (file, queryWords, opts, cmd) => {
+    const root = { ...cmd.optsWithGlobals(), ...opts };
+    root.query = root.query || queryWords.join(" ");
+    await search(file, root);
+});
+program
+    .command("view <file>")
+    .description("Render a high-fidelity 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")
+    .option("--overwrite", "Allow editing the input file in place")
+    .action(async (file, opts, cmd) => edit(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("json <file>")
+    .description("Export normalized JSON")
+    .option("-o, --output <path>", "Output file")
+    .action(async (file, opts, cmd) => json(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("svg <file>")
+    .description("Render best-effort SVG from normalized JSON")
+    .option("-o, --output <path>", "Output file")
+    .action(async (file, opts, cmd) => svg(file, { ...cmd.optsWithGlobals(), ...opts }));
+program
+    .command("thumbnail <file>")
+    .description("Extract embedded thumbnail when available")
+    .option("-o, --output <path>", "Output file")
+    .action(async (file, opts, cmd) => thumbnail(file, { ...cmd.optsWithGlobals(), ...opts }));
+program.parseAsync(process.argv).catch((err) => {
+    console.error("Fatal error:", err.message);
+    process.exit(1);
+});

package/dist/sdk.d.ts

@@ -0,0 +1,30 @@
+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";
+export declare class Dwg {
+    readonly file: string;
+    private readonly opts;
+    constructor(file: string, opts?: LoadOptions);
+    document(): Promise<DwgDocument>;
+    info(): Promise<DwgSummary>;
+    layers(): Promise<DwgLayer[]>;
+    blocks(): Promise<DwgBlock[]>;
+    entities(filter?: EntityFilter): Promise<DwgEntity[]>;
+    search(opts?: DwgSearchOptions): Promise<DwgSearchResult[]>;
+    overview(opts?: DrawingOverviewOptions): Promise<DrawingOverview>;
+    json(): Promise<DwgDocument>;
+    svg(): Promise<SvgResult>;
+    view(opts?: {
+        toolDir?: string;
+    }): LibreDwgViewResult;
+    edit(opts: {
+        output: string;
+        expression: string;
+        overwrite?: boolean;
+        toolDir?: string;
+    }): LibreDwgEditResult;
+    thumbnail(): Promise<ThumbnailResult>;
+    static open(file: string, opts?: LoadOptions): Dwg;
+}

package/dist/sdk.js

@@ -0,0 +1,57 @@
+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 {
+    file;
+    opts;
+    constructor(file, opts = {}) {
+        this.file = file;
+        this.opts = opts;
+    }
+    document() {
+        return loadDrawing(this.file, this.opts);
+    }
+    info() {
+        return getInfo(this.file, this.opts);
+    }
+    layers() {
+        return getLayers(this.file, this.opts);
+    }
+    blocks() {
+        return getBlocks(this.file, this.opts);
+    }
+    entities(filter) {
+        return getEntities(this.file, filter, this.opts);
+    }
+    search(opts) {
+        return searchDrawing(this.file, opts, this.opts);
+    }
+    overview(opts) {
+        return getOverview(this.file, opts, this.opts);
+    }
+    json() {
+        return toJson(this.file, this.opts);
+    }
+    svg() {
+        return toSvg(this.file, this.opts);
+    }
+    view(opts = {}) {
+        return renderSvgWithLibreDwg(this.file, opts);
+    }
+    edit(opts) {
+        return editWithLibreDwgFilter({
+            input: this.file,
+            output: opts.output,
+            expression: opts.expression,
+            overwrite: opts.overwrite,
+            toolDir: opts.toolDir,
+        });
+    }
+    thumbnail() {
+        return getThumbnail(this.file, this.opts);
+    }
+    static open(file, opts) {
+        return new Dwg(file, opts);
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,6 @@
+export interface CacheDirOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    home?: string;
+}
+export declare function getCacheDir(options?: CacheDirOptions): string;

package/dist/store.js

@@ -0,0 +1,17 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+const APP_NAME = "cadcli";
+export function getCacheDir(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const home = options.home ?? homedir();
+    if (env.CADCLI_CACHE_DIR)
+        return env.CADCLI_CACHE_DIR;
+    if (platform === "darwin") {
+        return join(home, "Library", "Caches", APP_NAME);
+    }
+    if (platform === "win32") {
+        return join(env.LOCALAPPDATA ?? join(home, "AppData", "Local"), APP_NAME, "Cache");
+    }
+    return join(env.XDG_CACHE_HOME ?? join(home, ".cache"), APP_NAME);
+}

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+export type DwgFormat = "DWG" | "DXF";
+export interface DwgBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export interface DwgEntity {
+    id: string;
+    type: string;
+    layer?: string;
+    color?: string | number;
+    data: Record<string, unknown>;
+}
+export interface DwgLayer {
+    name: string;
+    entityCount: number;
+    frozen?: boolean;
+    locked?: boolean;
+    color?: string | number;
+}
+export interface DwgBlock {
+    name: string;
+    entityCount: number;
+}
+export interface DwgSummary {
+    file: string;
+    format: DwgFormat;
+    version?: string;
+    counts: {
+        entities: number;
+        layers: number;
+        blocks: number;
+        unsupported: number;
+    };
+    bounds?: DwgBounds;
+}
+export interface DwgDocument {
+    summary: DwgSummary;
+    layers: DwgLayer[];
+    blocks: DwgBlock[];
+    entities: DwgEntity[];
+    unsupported: DwgEntity[];
+    raw: unknown;
+}
+export interface EntityFilter {
+    type?: string;
+    layer?: string;
+    limit?: number;
+}
+export interface SvgResult {
+    svg: string;
+    unsupported: number;
+    rendered: number;
+    bounds: DwgBounds;
+}
+export interface ThumbnailResult {
+    data: Uint8Array;
+    mimeType: string;
+    extension: string;
+}
+export interface DrawingReader {
+    parse(file: string, bytes: Uint8Array, format: DwgFormat): Promise<unknown>;
+    thumbnail?(file: string, bytes: Uint8Array, format: DwgFormat): Promise<ThumbnailResult | null>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/exit-codes.d.ts

@@ -0,0 +1,5 @@
+export declare const EXIT_SUCCESS = 0;
+export declare const EXIT_ERROR = 1;
+export declare const EXIT_USER_ERROR = 2;
+export declare const EXIT_NOT_FOUND = 3;
+export declare const EXIT_UNAVAILABLE = 4;

package/dist/utils/exit-codes.js

@@ -0,0 +1,5 @@
+export const EXIT_SUCCESS = 0;
+export const EXIT_ERROR = 1;
+export const EXIT_USER_ERROR = 2;
+export const EXIT_NOT_FOUND = 3;
+export const EXIT_UNAVAILABLE = 4;

package/dist/utils/output.d.ts

@@ -0,0 +1,19 @@
+export interface OutputOptions {
+    json?: boolean;
+    quiet?: boolean;
+}
+export declare const success: (msg: string) => void;
+export declare const info: (msg: string) => void;
+export declare const warn: (msg: string) => void;
+export declare const error: (msg: string) => void;
+export declare const bold: (s: string) => string;
+export declare const dim: (s: string) => string;
+export declare const cmd: (s: string) => string;
+export declare const hint: (msg: string) => void;
+export declare function stringifyJson(data: unknown): string;
+export declare function jsonOutput(data: unknown): void;
+export declare function output(options: OutputOptions, handlers: {
+    json?: () => unknown;
+    quiet?: () => void;
+    human: () => void;
+}): void;

package/dist/utils/output.js

@@ -0,0 +1,26 @@
+import chalk from "chalk";
+export const success = (msg) => console.log(chalk.green("✓"), msg);
+export const info = (msg) => console.error(chalk.blue("ℹ"), msg);
+export const warn = (msg) => console.error(chalk.yellow("⚠"), msg);
+export const error = (msg) => console.error(chalk.red("✗"), msg);
+export const bold = (s) => chalk.bold(s);
+export const dim = (s) => chalk.dim(s);
+export const cmd = (s) => chalk.cyan(s);
+export const hint = (msg) => console.log(chalk.dim(`  ${msg}`));
+export function stringifyJson(data) {
+    return JSON.stringify(data, (_key, value) => (typeof value === "bigint" ? value.toString() : value), 2);
+}
+export function jsonOutput(data) {
+    console.log(stringifyJson(data));
+}
+export function output(options, handlers) {
+    if (options.json && handlers.json) {
+        jsonOutput(handlers.json());
+    }
+    else if (options.quiet && handlers.quiet) {
+        handlers.quiet();
+    }
+    else if (!options.quiet) {
+        handlers.human();
+    }
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@miclivs/cadcli",
+  "version": "0.1.0",
+  "description": "Agent-friendly CAD inspection, search, viewing, and editing for DWG/DXF files.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "cadcli": "dist/main.js"
+  },
+  "files": [
+    "dist",
+    "patches",
+    "skills"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "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",
+    "build:bun-linux": "bun build --compile --target=bun-linux-x64 src/main.ts --outfile cadcli-linux-x64",
+    "build:bun-mac-arm": "bun build --compile --target=bun-darwin-arm64 src/main.ts --outfile cadcli-darwin-arm64",
+    "build:bun-mac-x64": "bun build --compile --target=bun-darwin-x64 src/main.ts --outfile cadcli-darwin-x64",
+    "test": "bun test",
+    "format": "bunx biome format --write src/",
+    "lint": "bunx biome lint src/",
+    "check": "bunx biome check src/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Michaelliv/cadcli.git"
+  },
+  "homepage": "https://github.com/Michaelliv/cadcli#readme",
+  "bugs": {
+    "url": "https://github.com/Michaelliv/cadcli/issues"
+  },
+  "keywords": [
+    "dwg",
+    "dxf",
+    "cad",
+    "cli",
+    "sdk",
+    "libredwg",
+    "svg",
+    "conversion",
+    "pi-package"
+  ],
+  "pi": {
+    "skills": [
+      "skills"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  },
+  "dependencies": {
+    "@node-projects/acad-ts": "2.3.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "minisearch": "^7.2.0",
+    "nanoid": "^5.1.6"
+  },
+  "patchedDependencies": {
+    "@node-projects/acad-ts@2.3.0": "patches/@node-projects%2Facad-ts@2.3.0.patch"
+  }
+}

package/patches/@node-projects%2Facad-ts@2.3.0.patch

@@ -0,0 +1,48 @@
+diff --git a/dist/IO/DWG/DwgStreamReaders/DwgObjectReader.js b/dist/IO/DWG/DwgStreamReaders/DwgObjectReader.js
+index 76143736c81f492d09c27def63a404575852ad2a..584a409e80755565792529c1982b155e066d2ef8 100644
+--- a/dist/IO/DWG/DwgStreamReaders/DwgObjectReader.js	
++++ b/dist/IO/DWG/DwgStreamReaders/DwgObjectReader.js
+@@ -247,7 +247,7 @@ export class DwgObjectReader extends DwgSectionIO {
+             this._classes.set(c.classNumber, c);
+         }
+         this._memoryStream = new Uint8Array(reader.stream);
+-        this._crcReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream));
++        this._crcReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream);
+     }
+     read() {
+         while (this._handles.length > 0) {
+@@ -291,20 +291,20 @@ export class DwgObjectReader extends DwgSectionIO {
+         if (this.r2010Plus) {
+             const handleSize = this._crcReader.readModularChar();
+             const handleSectionOffset = this._crcReader.positionInBits() + sizeInBits - handleSize;
+-            this._objectReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream), this._reader.encoding);
++            this._objectReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream, this._reader.encoding);
+             this._objectReader.setPositionInBits(this._crcReader.positionInBits());
+             this._objectInitialPos = this._objectReader.positionInBits();
+             type = this._objectReader.readObjectType();
+-            this._handlesReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream), this._reader.encoding);
++            this._handlesReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream, this._reader.encoding);
+             this._handlesReader.setPositionInBits(handleSectionOffset);
+-            this._textReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream), this._reader.encoding);
++            this._textReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream, this._reader.encoding);
+             this._textReader.setPositionByFlag(handleSectionOffset - 1);
+             this._mergedReaders = new DwgMergedReader(this._objectReader, this._textReader, this._handlesReader);
+         }
+         else {
+-            this._objectReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream), this._reader.encoding);
++            this._objectReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream, this._reader.encoding);
+             this._objectReader.setPositionInBits(this._crcReader.positionInBits());
+-            this._handlesReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream), this._reader.encoding);
++            this._handlesReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream, this._reader.encoding);
+             this._textReader = this._objectReader;
+             this._objectInitialPos = this._objectReader.positionInBits();
+             type = this._objectReader.readObjectType();
+@@ -532,7 +532,7 @@ export class DwgObjectReader extends DwgSectionIO {
+         const size = this._objectReader.readRawLong();
+         this._handlesReader.setPositionInBits(size + this._objectInitialPos);
+         if (this._version === ACadVersion.AC1021) {
+-            this._textReader = DwgStreamReaderBase.getStreamHandler(this._version, new Uint8Array(this._memoryStream), this._reader.encoding);
++            this._textReader = DwgStreamReaderBase.getStreamHandler(this._version, this._memoryStream, this._reader.encoding);
+             this._textReader.setPositionByFlag(size + this._objectInitialPos - 1);
+         }
+         this._mergedReaders = new DwgMergedReader(this._objectReader, this._textReader, this._handlesReader);

package/skills/cadcli/SKILL.md

@@ -0,0 +1,34 @@
+---
+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.
+---
+
+# cadcli
+
+Use `cadcli` for progressive CAD file discovery. Start broad, then narrow down:
+
+```bash
+cadcli info <file> --json
+cadcli overview <file>
+cadcli layers <file> --json
+cadcli entities <file> --limit 20 --json
+cadcli search <file> "query" --json
+```
+
+For visual checks, prefer the high-fidelity native path when available:
+
+```bash
+cadcli view <file> -o preview.svg
+```
+
+For lightweight previews from the normalized model:
+
+```bash
+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:
+
+```bash
+cadcli edit <file> --jq '<jq expression>' -o edited.dwg
+```