@miclivs/cadcli 0.1.0

package/dist/core/adapter.js

@@ -0,0 +1,165 @@
+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
+        : {};
+}
+export function arrayBufferFor(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function items(value) {
+    return value ? [...value] : [];
+}
+function point(value) {
+    const rec = asRecord(value);
+    const x = Number(rec.x ?? rec.X);
+    const y = Number(rec.y ?? rec.Y);
+    const z = Number(rec.z ?? rec.Z);
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return undefined;
+    return Number.isFinite(z) ? { x, y, z } : { x, y };
+}
+function constructorName(value) {
+    const ctor = asRecord(value).constructor;
+    return typeof ctor === "function" && ctor.name ? ctor.name : "UNKNOWN";
+}
+function entityType(entity) {
+    const name = constructorName(entity);
+    const known = {
+        BlockReference: "INSERT",
+        Insert: "INSERT",
+        Line: "LINE",
+        Circle: "CIRCLE",
+        Arc: "ARC",
+        LwPolyline: "LWPOLYLINE",
+        Polyline2D: "POLYLINE",
+        Polyline3D: "POLYLINE",
+        TextEntity: "TEXT",
+        MText: "MTEXT",
+        Point: "POINT",
+    };
+    return known[name] ?? name.replace(/Entity$/, "").toUpperCase();
+}
+function layerName(entity) {
+    const layer = asRecord(entity).layer;
+    const name = asRecord(layer).name;
+    return name === undefined || name === null ? undefined : String(name);
+}
+function colorValue(entity) {
+    const color = asRecord(entity).color;
+    if (color === undefined || color === null)
+        return undefined;
+    const index = asRecord(color).index;
+    if (typeof index === "number")
+        return index;
+    return String(color);
+}
+function valueString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    return text.length > 0 ? text : undefined;
+}
+function blockName(entity) {
+    const block = asRecord(entity).block;
+    return valueString(asRecord(block).name);
+}
+function vertices(entity) {
+    const raw = asRecord(entity).vertices;
+    if (!Array.isArray(raw))
+        return undefined;
+    const result = raw
+        .map((vertex) => point(asRecord(vertex).location ?? vertex))
+        .filter((vertex) => Boolean(vertex));
+    return result.length > 0 ? result : undefined;
+}
+function normalizeAcadEntity(entity) {
+    const rec = asRecord(entity);
+    const type = entityType(entity);
+    const data = {
+        handle: rec.handle,
+        type,
+        layer: layerName(entity),
+        color: colorValue(entity),
+    };
+    const start = point(rec.startPoint);
+    const end = point(rec.endPoint);
+    const center = point(rec.center);
+    const insertPoint = point(rec.insertPoint);
+    const location = point(rec.location);
+    const entityVertices = vertices(entity);
+    const text = valueString(rec.plainText ?? rec.value);
+    const name = blockName(entity);
+    if (start)
+        data.start = start;
+    if (end)
+        data.end = end;
+    if (center)
+        data.center = center;
+    if (insertPoint)
+        data.insertionPoint = insertPoint;
+    if (insertPoint)
+        data.position = insertPoint;
+    if (location)
+        data.point = location;
+    if (entityVertices)
+        data.vertices = entityVertices;
+    if (typeof rec.radius === "number")
+        data.radius = rec.radius;
+    if (typeof rec.startAngle === "number")
+        data.startAngle = rec.startAngle;
+    if (typeof rec.endAngle === "number")
+        data.endAngle = rec.endAngle;
+    if (text)
+        data.text = text;
+    if (name)
+        data.blockName = name;
+    return data;
+}
+export function normalizeAcadDocument(doc) {
+    const layers = items(doc.layers).map((layer) => ({ name: layer.name }));
+    const blocks = items(doc.blockRecords).map((block) => ({
+        name: block.name,
+        entities: items(block.entities).map((entity) => ({
+            type: entityType(entity),
+        })),
+    }));
+    const entities = items(doc.modelSpace?.entities).map(normalizeAcadEntity);
+    return {
+        version: doc.header?.versionString ?? String(doc.header?.version ?? ""),
+        layers,
+        blocks,
+        entities,
+    };
+}
+export class AcadTsReader {
+    async parse(_file, bytes, format) {
+        try {
+            const doc = format === "DWG"
+                ? DwgReader.readFromStream(arrayBufferFor(bytes))
+                : DxfReader.readFromStream(bytes);
+            return normalizeAcadDocument(doc);
+        }
+        catch (error) {
+            throw new DwgCliError(`Could not parse ${format}: ${error.message}`, "PARSE_FAILED", EXIT_USER_ERROR);
+        }
+    }
+    async thumbnail() {
+        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

@@ -0,0 +1,14 @@
+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>;
+export declare function getLayers(file: string, opts?: LoadOptions): Promise<DwgLayer[]>;
+export declare function getBlocks(file: string, opts?: LoadOptions): Promise<DwgBlock[]>;
+export declare function filterEntities(entities: DwgEntity[], filter?: EntityFilter): DwgEntity[];
+export declare function getEntities(file: string, filter?: EntityFilter, opts?: LoadOptions): Promise<DwgEntity[]>;
+export declare function toJson(file: string, opts?: LoadOptions): Promise<DwgDocument>;
+export declare function toSvg(file: string, opts?: LoadOptions): Promise<SvgResult>;
+export declare function getThumbnail(file: string, opts?: LoadOptions): Promise<ThumbnailResult>;

package/dist/core/drawing.js

@@ -0,0 +1,61 @@
+import { EXIT_UNAVAILABLE, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { AcadTsReader } from "./adapter.js";
+import { DwgCliError } from "./errors.js";
+import { readCadFile } from "./files.js";
+import { normalizeDocument } from "./normalize.js";
+import { renderSvg } from "./svg.js";
+function readerFor(opts) {
+    return opts.reader ?? new AcadTsReader();
+}
+export async function loadDrawing(file, opts = {}) {
+    const { bytes, format } = readCadFile(file);
+    const raw = await readerFor(opts).parse(file, bytes, format);
+    return normalizeDocument(file, format, raw);
+}
+export async function getInfo(file, opts) {
+    return (await loadDrawing(file, opts)).summary;
+}
+export async function getLayers(file, opts) {
+    return (await loadDrawing(file, opts)).layers;
+}
+export async function getBlocks(file, opts) {
+    return (await loadDrawing(file, opts)).blocks;
+}
+export function filterEntities(entities, filter = {}) {
+    let result = entities;
+    if (filter.type)
+        result = result.filter((e) => e.type.toLowerCase() === filter.type?.toLowerCase());
+    if (filter.layer)
+        result = result.filter((e) => e.layer?.toLowerCase() === filter.layer?.toLowerCase());
+    if (filter.limit !== undefined)
+        result = result.slice(0, filter.limit);
+    return result;
+}
+export async function getEntities(file, filter = {}, opts) {
+    const doc = await loadDrawing(file, opts);
+    if (filter.layer &&
+        !doc.layers.some((l) => l.name.toLowerCase() === filter.layer?.toLowerCase())) {
+        throw new DwgCliError(`Layer not found: ${filter.layer}`, "LAYER_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    if (filter.type &&
+        !doc.entities.some((e) => e.type.toLowerCase() === filter.type?.toLowerCase())) {
+        throw new DwgCliError(`Entity type not found: ${filter.type}`, "TYPE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    return filterEntities(doc.entities, filter);
+}
+export async function toJson(file, opts) {
+    return loadDrawing(file, opts);
+}
+export async function toSvg(file, opts) {
+    return renderSvg(await loadDrawing(file, opts));
+}
+export async function getThumbnail(file, opts = {}) {
+    const { bytes, format } = readCadFile(file);
+    const reader = readerFor(opts);
+    if (!reader.thumbnail)
+        throw new DwgCliError("Thumbnail extraction is not available through the configured reader.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
+    const result = await reader.thumbnail(file, bytes, format);
+    if (!result)
+        throw new DwgCliError("No thumbnail was found in this drawing.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
+    return result;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class DwgCliError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    constructor(message: string, code?: string, exitCode?: number);
+}

package/dist/core/errors.js

@@ -0,0 +1,10 @@
+export class DwgCliError extends Error {
+    code;
+    exitCode;
+    constructor(message, code = "DWG_ERROR", exitCode = 1) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.name = "DwgCliError";
+    }
+}

package/dist/core/files.d.ts

@@ -0,0 +1,7 @@
+import type { DwgFormat } from "../types.js";
+export declare function detectFormat(file: string): DwgFormat;
+export declare function readCadFile(file: string): {
+    bytes: Uint8Array;
+    format: DwgFormat;
+};
+export declare function writeOutput(file: string, data: string | Uint8Array): void;

package/dist/core/files.js

@@ -0,0 +1,27 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, extname } from "node:path";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { DwgCliError } from "./errors.js";
+export function detectFormat(file) {
+    const ext = extname(file).toLowerCase();
+    if (ext === ".dwg")
+        return "DWG";
+    if (ext === ".dxf")
+        return "DXF";
+    throw new DwgCliError(`Unsupported file extension: ${ext || "none"}. Expected .dwg or .dxf.`, "UNSUPPORTED_FORMAT", EXIT_USER_ERROR);
+}
+export function readCadFile(file) {
+    if (!existsSync(file)) {
+        throw new DwgCliError(`File not found: ${file}`, "FILE_NOT_FOUND", EXIT_NOT_FOUND);
+    }
+    return { bytes: readFileSync(file), format: detectFormat(file) };
+}
+export function writeOutput(file, data) {
+    try {
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, data);
+    }
+    catch (error) {
+        throw new DwgCliError(`Could not write output to ${file}: ${error.message}`, "OUTPUT_WRITE_FAILED", EXIT_USER_ERROR);
+    }
+}

package/dist/core/libredwg.d.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,86 @@
+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,
+    };
+}

package/dist/core/normalize.d.ts

@@ -0,0 +1,3 @@
+import type { DwgBounds, DwgDocument, DwgEntity, DwgFormat } from "../types.js";
+export declare function computeBounds(entities: DwgEntity[]): DwgBounds | undefined;
+export declare function normalizeDocument(file: string, format: DwgFormat, raw: unknown): DwgDocument;

package/dist/core/normalize.js

@@ -0,0 +1,156 @@
+import { basename } from "node:path";
+const ENTITY_ARRAY_FIELDS = ["entities", "Entities", "objects", "Objects"];
+const LAYER_ARRAY_FIELDS = ["layers", "Layers"];
+const BLOCK_ARRAY_FIELDS = ["blocks", "Blocks", "blockHeaders"];
+const POINT_FIELDS = [
+    "start",
+    "end",
+    "center",
+    "insertionPoint",
+    "position",
+    "point",
+];
+const POINT_LIST_FIELDS = ["vertices", "points"];
+const SUPPORTED_ENTITY_TYPES = new Set([
+    "LINE",
+    "CIRCLE",
+    "ARC",
+    "LWPOLYLINE",
+    "POLYLINE",
+    "TEXT",
+    "MTEXT",
+    "POINT",
+]);
+function asRecord(value) {
+    return value && typeof value === "object"
+        ? value
+        : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function firstArray(raw, names) {
+    for (const name of names) {
+        const value = raw[name];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function stringField(rec, names) {
+    for (const name of names) {
+        const value = rec[name];
+        if (value !== undefined && value !== null && String(value) !== "") {
+            return String(value);
+        }
+    }
+    return undefined;
+}
+function getName(value, fallback) {
+    return (stringField(asRecord(value), ["name", "Name", "layerName", "LayerName"]) ??
+        fallback);
+}
+function getEntityType(value) {
+    return (stringField(asRecord(value), [
+        "type",
+        "Type",
+        "objectType",
+        "entityType",
+        "_type",
+    ]) ?? "UNKNOWN").toUpperCase();
+}
+function getLayer(value) {
+    return stringField(asRecord(value), [
+        "layer",
+        "Layer",
+        "layerName",
+        "layer_name",
+    ]);
+}
+function pointFrom(value) {
+    const rec = asRecord(value);
+    const x = Number(rec.x ?? rec.X ?? rec[0]);
+    const y = Number(rec.y ?? rec.Y ?? rec[1]);
+    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+}
+function collectEntityPoints(entity) {
+    const points = [];
+    for (const key of POINT_FIELDS) {
+        const point = pointFrom(entity.data[key]);
+        if (point)
+            points.push(point);
+    }
+    for (const key of POINT_LIST_FIELDS) {
+        for (const item of asArray(entity.data[key])) {
+            const point = pointFrom(item);
+            if (point)
+                points.push(point);
+        }
+    }
+    return points;
+}
+function normalizeEntity(item, index) {
+    const rec = asRecord(item);
+    return {
+        id: String(rec.id ?? rec.handle ?? rec.Handle ?? index + 1),
+        type: getEntityType(rec),
+        layer: getLayer(rec),
+        color: rec.color,
+        data: rec,
+    };
+}
+function normalizeLayers(rawLayers, entities) {
+    const counts = new Map();
+    for (const [index, layer] of rawLayers.entries()) {
+        counts.set(getName(layer, `Layer ${index + 1}`), 0);
+    }
+    for (const entity of entities) {
+        if (!entity.layer)
+            continue;
+        counts.set(entity.layer, (counts.get(entity.layer) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, entityCount]) => ({ name, entityCount }));
+}
+function normalizeBlocks(rawBlocks) {
+    return rawBlocks.map((block, index) => {
+        const rec = asRecord(block);
+        return {
+            name: getName(block, `Block ${index + 1}`),
+            entityCount: asArray(rec.entities ?? rec.Entities).length,
+        };
+    });
+}
+export function computeBounds(entities) {
+    const points = entities.flatMap(collectEntityPoints);
+    if (points.length === 0)
+        return undefined;
+    return {
+        minX: Math.min(...points.map((p) => p.x)),
+        minY: Math.min(...points.map((p) => p.y)),
+        maxX: Math.max(...points.map((p) => p.x)),
+        maxY: Math.max(...points.map((p) => p.y)),
+    };
+}
+export function normalizeDocument(file, format, raw) {
+    const root = asRecord(raw);
+    const entities = firstArray(root, ENTITY_ARRAY_FIELDS).map(normalizeEntity);
+    const unsupported = entities.filter((entity) => !SUPPORTED_ENTITY_TYPES.has(entity.type));
+    const layers = normalizeLayers(firstArray(root, LAYER_ARRAY_FIELDS), entities);
+    const blocks = normalizeBlocks(firstArray(root, BLOCK_ARRAY_FIELDS));
+    const version = stringField(root, ["version", "headerVersion", "dwgVersion"]);
+    const summary = {
+        file: basename(file),
+        format,
+        version,
+        counts: {
+            entities: entities.length,
+            layers: layers.length,
+            blocks: blocks.length,
+            unsupported: unsupported.length,
+        },
+        bounds: computeBounds(entities),
+    };
+    return { summary, layers, blocks, entities, unsupported, raw };
+}

package/dist/core/overview.d.ts

@@ -0,0 +1,35 @@
+import type { DwgDocument, DwgSummary } from "../types.js";
+import { type LoadOptions } from "./drawing.js";
+export interface OverviewLayer {
+    name: string;
+    entities: number;
+    types: string[];
+    keywords: string[];
+}
+export interface OverviewEntityType {
+    type: string;
+    count: number;
+}
+export interface OverviewBlock {
+    name: string;
+    definitions: number;
+    references: number;
+}
+export interface OverviewText {
+    keywords: string[];
+    samples: string[];
+}
+export interface DrawingOverview {
+    summary: DwgSummary;
+    layers: OverviewLayer[];
+    entityTypes: OverviewEntityType[];
+    blocks: OverviewBlock[];
+    text: OverviewText;
+    searchHints: string[];
+}
+export interface DrawingOverviewOptions {
+    keywords?: number;
+    samples?: number;
+}
+export declare function createDrawingOverview(doc: DwgDocument, opts?: DrawingOverviewOptions): DrawingOverview;
+export declare function getOverview(file: string, opts?: DrawingOverviewOptions, loadOpts?: LoadOptions): Promise<DrawingOverview>;