@miclivs/cadcli 0.1.0 → 0.1.2

package/README.md

@@ -111,7 +111,7 @@ The public SDK is intentionally small: `Dwg` plus stable CAD/result types. Nativ
 
 ## Cache
 
-Search indexes are cached automatically in the platform-standard cache directory:
+Search indexes are cached automatically in the platform-standard cache directory. On Node.js installs, `cadcli search` uses a disk-backed SQLite FTS index when the optional SQLite dependency is available; otherwise it falls back to a low-memory scan.
 
 ```txt
 macOS    ~/Library/Caches/cadcli

package/dist/core/search.d.ts

@@ -15,4 +15,7 @@ export interface DwgSearchResult {
     matches: string[];
     entity: DwgEntity;
 }
+export declare function stringifySearchValue(value: unknown): string;
+export declare function entitySearchFields(entity: DwgEntity): string[];
+export declare function searchMatchesFor(entity: DwgEntity, query: string | undefined): string[];
 export declare function searchDrawing(file: string, opts?: DwgSearchOptions, loadOpts?: LoadOptions): Promise<DwgSearchResult[]>;

package/dist/core/search.js

@@ -1,48 +1,23 @@
-import MiniSearch from "minisearch";
 import { loadDrawing } from "./drawing.js";
 import { computeDrawingFingerprint, loadSearchCache, saveSearchCache, } from "./search-cache.js";
-const SEARCH_FIELDS = ["entityId", "type", "layer", "text"];
-const STORE_FIELDS = ["entityId", "type", "layer", "text"];
 const DEFAULT_LIMIT = 30;
 const MAX_MATCHES = 5;
-function createSearchIndex() {
-    return new MiniSearch({
-        fields: [...SEARCH_FIELDS],
-        storeFields: [...STORE_FIELDS],
-        searchOptions: {
-            boost: { entityId: 3, type: 2, layer: 2, text: 1 },
-            fuzzy: 0.2,
-            prefix: true,
-        },
-    });
-}
-function loadSearchIndex(indexJson) {
-    return MiniSearch.loadJSON(indexJson, {
-        fields: [...SEARCH_FIELDS],
-        storeFields: [...STORE_FIELDS],
-        searchOptions: {
-            boost: { entityId: 3, type: 2, layer: 2, text: 1 },
-            fuzzy: 0.2,
-            prefix: true,
-        },
-    });
-}
-function stringifyValue(value) {
+export function stringifySearchValue(value) {
     if (value === null || value === undefined)
         return "";
     if (["string", "number", "boolean", "bigint"].includes(typeof value)) {
         return String(value);
     }
     if (Array.isArray(value))
-        return value.map(stringifyValue).join(" ");
+        return value.map(stringifySearchValue).join(" ");
     if (typeof value === "object") {
         return Object.entries(value)
-            .map(([key, val]) => `${key} ${stringifyValue(val)}`)
+            .map(([key, val]) => `${key} ${stringifySearchValue(val)}`)
             .join(" ");
     }
     return "";
 }
-function textFields(entity) {
+export function entitySearchFields(entity) {
     const values = [
         entity.id,
         entity.type,
@@ -52,24 +27,28 @@ function textFields(entity) {
         String(entity.data.name ?? ""),
         String(entity.data.blockName ?? ""),
         String(entity.data.block_name ?? ""),
-        stringifyValue(entity.data),
+        stringifySearchValue(entity.data),
     ];
     return values.filter((value) => value.trim().length > 0);
 }
-function buildDocs(doc) {
+function buildScanDocs(doc) {
     return doc.entities.map((entity, id) => ({
         id,
         entityId: entity.id,
         type: entity.type,
         layer: entity.layer,
-        text: textFields(entity).join(" "),
+        text: entitySearchFields(entity).join(" "),
         entity,
     }));
 }
-function buildIndex(docs) {
-    const index = createSearchIndex();
-    index.addAll(docs);
-    return index;
+async function loadScanCorpus(file, opts, loadOpts) {
+    const fingerprint = computeDrawingFingerprint(file);
+    const cached = loadSearchCache(file, fingerprint, opts.cacheDir);
+    if (cached)
+        return cached.docs;
+    const docs = buildScanDocs(await loadDrawing(file, loadOpts));
+    saveSearchCache(file, { fingerprint, index: "scan", docs }, opts.cacheDir);
+    return docs;
 }
 function matchesFilter(doc, opts) {
     if (opts.type && doc.type.toLowerCase() !== opts.type.toLowerCase()) {
@@ -80,58 +59,69 @@ function matchesFilter(doc, opts) {
     }
     return true;
 }
-function matchesFor(doc, query) {
+export function searchMatchesFor(entity, query) {
     if (!query)
         return [];
     const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
     if (terms.length === 0)
         return [];
-    return textFields(doc.entity)
+    return entitySearchFields(entity)
         .filter((chunk) => {
         const lower = chunk.toLowerCase();
         return terms.some((term) => lower.includes(term));
     })
         .slice(0, MAX_MATCHES);
 }
-async function loadSearchCorpus(file, opts, loadOpts) {
-    const fingerprint = computeDrawingFingerprint(file);
-    const cached = loadSearchCache(file, fingerprint, opts.cacheDir);
-    if (cached) {
-        return {
-            docs: cached.docs,
-            index: loadSearchIndex(cached.index),
-        };
+function queryTerms(query) {
+    return query?.toLowerCase().split(/\s+/).filter(Boolean) ?? [];
+}
+function scanScore(doc, terms) {
+    if (terms.length === 0)
+        return 1;
+    const entityId = doc.entityId.toLowerCase();
+    const type = doc.type.toLowerCase();
+    const layer = doc.layer?.toLowerCase() ?? "";
+    const text = doc.text.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+        if (entityId.includes(term))
+            score += 3;
+        if (type.includes(term))
+            score += 2;
+        if (layer.includes(term))
+            score += 2;
+        if (text.includes(term))
+            score += 1;
     }
-    const docs = buildDocs(await loadDrawing(file, loadOpts));
-    const index = buildIndex(docs);
-    saveSearchCache(file, { fingerprint, index: JSON.stringify(index), docs }, opts.cacheDir);
-    return { docs, index };
+    return score;
 }
-function resultScore(result) {
-    return Math.round((Number(result.score) || 1) * 10) / 10;
+function resultScore(score) {
+    return Math.round((score || 1) * 10) / 10;
 }
-export async function searchDrawing(file, opts = {}, loadOpts = {}) {
-    const { docs, index } = await loadSearchCorpus(file, opts, loadOpts);
+async function searchWithScan(file, opts = {}, loadOpts = {}) {
+    const docs = await loadScanCorpus(file, opts, loadOpts);
     const query = opts.query?.trim();
-    const byId = new Map(docs.map((doc) => [doc.id, doc]));
-    const raw = query
-        ? index.search(query).map((result) => ({
-            id: Number(result.id),
-            score: result.score,
-        }))
-        : docs.map((doc) => ({ id: doc.id, score: 1 }));
-    return raw
-        .map((result) => ({ result, doc: byId.get(result.id) }))
-        .filter((item) => Boolean(item.doc))
-        .filter(({ doc }) => matchesFilter(doc, opts))
-        .map(({ result, doc }) => ({
+    const terms = queryTerms(query);
+    return docs
+        .filter((doc) => matchesFilter(doc, opts))
+        .map((doc) => ({ doc, score: scanScore(doc, terms) }))
+        .filter(({ score }) => terms.length === 0 || score > 0)
+        .map(({ doc, score }) => ({
         entityId: doc.entityId,
         type: doc.type,
         layer: doc.layer,
-        score: resultScore(result),
-        matches: opts.snippets === false ? [] : matchesFor(doc, query),
+        score: resultScore(score),
+        matches: opts.snippets === false ? [] : searchMatchesFor(doc.entity, query),
         entity: doc.entity,
     }))
         .sort((a, b) => b.score - a.score)
         .slice(0, opts.limit ?? DEFAULT_LIMIT);
 }
+async function searchWithDiskIndex(file, opts, loadOpts) {
+    const { searchWithSqlite } = await import("./sqlite-search.js");
+    return searchWithSqlite(file, opts, loadOpts);
+}
+export async function searchDrawing(file, opts = {}, loadOpts = {}) {
+    return ((await searchWithDiskIndex(file, opts, loadOpts)) ??
+        searchWithScan(file, opts, loadOpts));
+}

package/dist/core/sqlite-search.d.ts

@@ -0,0 +1,3 @@
+import { type LoadOptions } from "./drawing.js";
+import { type DwgSearchOptions, type DwgSearchResult } from "./search.js";
+export declare function searchWithSqlite(file: string, opts: DwgSearchOptions, loadOpts: LoadOptions): Promise<DwgSearchResult[] | null>;

package/dist/core/sqlite-search.js

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

package/package.json

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

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

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