@stalfh233/omc-cli 0.4.102 → 0.5.1

package/dist/graph.js

@@ -0,0 +1,734 @@
+import { createRequire } from "node:module";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { joinConfigRoot } from "./command-transport.js";
+import { decodeJsonColumn, JSON_COLUMN_NULL_COALESCE } from "./json-column.js";
+import { ENDPOINTS } from "./endpoints.js";
+import { flattenTreeRows, resolveApplicationCode, sha256 } from "./support.js";
+import { wireCall, wireRows } from "./wire.js";
+/**
+ * `node:sqlite` must stay OUT of the CLI's startup module graph: a static
+ * import emits the ExperimentalWarning during ESM linking, before any user
+ * code (including the stderr filter cli.ts installs as its first import) can
+ * run — that is why omc-core is lazily loaded too (sqlite-warning-filter.ts /
+ * omc-core-lazy.ts). Load it on first use, inside a command.
+ */
+let sqliteModule;
+function nodeSqlite() {
+    if (sqliteModule === undefined)
+        sqliteModule = createRequire(import.meta.url)("node:sqlite");
+    return sqliteModule;
+}
+/**
+ * ADR-0008 — the local derived rule-graph index.
+ *
+ * `rule.references` treats the r23 enumeration storm (171 rule.get calls) but
+ * re-scans the whole platform on every invocation and swallows per-model read
+ * failures, so a repeat question pays full wire cost again and its zero-hit
+ * answer can be a silent false negative. This module materializes the same
+ * walk ONCE into a local SQLite index:
+ *
+ * - scope: current-effective business rule graphs only (model.list → rule.list
+ *   rows → businessRuleGet per row id — the exact wire reads rule.references
+ *   makes; rows from the list face are current, so no stale-row double-read);
+ * - edges are api-fact only, extracted with rule.references' matching
+ *   semantics (service/model/field — see extractReferenceEdges);
+ * - fail-closed completeness: every swallowed read/parse failure is a recorded
+ *   gap; a zero-hit answer over a gapped index never claims "no references";
+ * - derived locator, never authority: results are candidate pointers; plan /
+ *   apply / readback keep reading the live baseline;
+ * - no raw payloads persist: whitelisted rule columns + graph sha256 + edges;
+ * - identity-bound: meta carries the canonical environment identity
+ *   fingerprint (which includes baseUrl/enterpriseId/applicationCode by
+ *   construction — it is NOT a config-content fingerprint and never certifies
+ *   "config unchanged"; freshness is complete|partial|unknown only);
+ * - each pull rebuilds wholesale into a staging DB and publishes atomically;
+ *   staleness is handled by reporting pulledAt + identity, refreshed by an
+ *   explicit re-pull (no incremental watermarks, no write-back hooks).
+ */
+const GRAPH_SCHEMA_VERSION = "4";
+const STALE_LOCK_MS = 15 * 60 * 1000;
+export const DEFAULT_PULL_CONCURRENCY = 16;
+export const MAX_PULL_CONCURRENCY = 32;
+export class GraphIndexAbsentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphIndexAbsentError";
+    }
+}
+export class GraphPullLockHeldError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphPullLockHeldError";
+    }
+}
+export function graphDbPath() {
+    return join(joinConfigRoot(), ".omc", "graph", "graph.db");
+}
+/**
+ * Extract api-fact reference edges from one rule's stored node graph. The
+ * matching mirrors `rule.references` exactly (businessrule.ts) so the index and
+ * the live scan answer the same question; anything rule.references cannot see
+ * (condition leaves, datarules — its v1 boundary) is equally invisible here.
+ */
+export function extractReferenceEdges(schemaCode, ruleCode, nodes) {
+    const edges = [];
+    const push = (kind, code, node, via) => {
+        if (code === "")
+            return;
+        edges.push({
+            kind,
+            code,
+            schemaCode,
+            ruleCode,
+            nodeCode: String(node.nodeCode ?? ""),
+            nodeType: String(node.nodeType ?? ""),
+            via,
+        });
+    };
+    for (const node of nodes) {
+        const mapping = node.methodMapping;
+        if (node.nodeType === "BIZ_ACTION" && mapping) {
+            push("service", String(mapping.serviceCode ?? ""), node, "methodMapping.serviceCode");
+        }
+        if (["CREATE", "UPDATE", "DELETE"].includes(String(node.nodeType ?? ""))) {
+            push("model", String(node.targetObjectCode ?? ""), node, "targetObjectCode");
+            if (Array.isArray(node.dataActions))
+                for (const action of node.dataActions)
+                    push("field", String(action.targetDataItem ?? ""), node, "dataActions.targetDataItem");
+        }
+        if (mapping) {
+            push("model", String(mapping.schemaCode ?? ""), node, "methodMapping.schemaCode");
+            for (const [key, label] of [["inputMappings", "inputMappings.bizCode"], ["outputMappings", "outputMappings.bizCode"]]) {
+                if (Array.isArray(mapping[key]))
+                    for (const row of mapping[key])
+                        if (String(row.bizCode ?? "") !== "" && (row.codeType === undefined || row.codeType === 1))
+                            push("field", String(row.bizCode), node, label);
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * datarule face (phase 2): `dataRuleList` is one call per model and the LIST
+ * rows already carry the target fields (`propertyCodes`) and the stored
+ * `options` (formulas/conditions with `{field}` tokens) — no per-rule get.
+ * Target codes are api-fact field edges; `{token}` inside serialized options
+ * is the same class of stored-config reference (the braces are the platform's
+ * own field-reference syntax, cf. formulaFromEditorText).
+ */
+export function extractDataRuleEdges(schemaCode, row) {
+    const targets = Array.isArray(row.propertyCodes) ? row.propertyCodes.map((code) => String(code)) : typeof row.propertyCode === "string" && row.propertyCode !== "" ? [row.propertyCode] : [];
+    const edges = [];
+    const locator = targets.join("+");
+    for (const code of targets)
+        edges.push({ kind: "field", code, schemaCode, ruleCode: "", nodeCode: locator, nodeType: "datarule", via: "datarule.targets" });
+    const tokens = new Set();
+    try {
+        for (const token of JSON.stringify(row.options ?? {}).matchAll(/\{([A-Za-z0-9_.-]+)\}/g))
+            tokens.add(token[1]);
+    }
+    catch {
+        // options stringify never throws; guard anyway
+    }
+    for (const code of tokens)
+        edges.push({ kind: "field", code, schemaCode, ruleCode: "", nodeCode: locator, nodeType: "datarule", via: "datarule.options-token" });
+    return edges;
+}
+/**
+ * listview face (phase 2b): `listQueryList` is one call per model but carries
+ * only code/name — the column/sort/condition field references live in
+ * `listQueryGet` per view (queryColumns/querySorts/queryConditions
+ * propertyCode; the same projector listview.get reads back). Views are
+ * always-live (no draft lifecycle), so a get is the current state.
+ */
+export function extractListViewEdges(schemaCode, viewCode, model) {
+    const edges = [];
+    const push = (code, via) => {
+        if (typeof code === "string" && code !== "")
+            edges.push({ kind: "field", code, schemaCode, ruleCode: "", nodeCode: viewCode, nodeType: "listview", via });
+    };
+    for (const column of Array.isArray(model.queryColumns) ? model.queryColumns : [])
+        push(column.propertyCode, "listview.columns");
+    for (const sort of Array.isArray(model.querySorts) ? model.querySorts : [])
+        push(sort.propertyCode, "listview.sorts");
+    for (const condition of Array.isArray(model.queryConditions) ? model.queryConditions : [])
+        push(condition.propertyCode, "listview.conditions");
+    return edges;
+}
+/**
+ * The full pull walk, PIPELINED: one shared bounded worker pool executes both
+ * task kinds — per-model face reads (rule.list + dataruleList) and per-rule
+ * graph reads. A model face completing submits its rule reads straight into
+ * the pool, so wall time ≈ max(modelFaces, ruleReads) / concurrency instead of
+ * the phased sum. Read failures are gaps, never silent, and per FACE: a model
+ * whose datarule list fails still contributes its business rules (gap kind
+ * `datarule-list`) and vice versa (`rule-list`). Output is sorted so the
+ * published DB is byte-stable regardless of completion order.
+ */
+export async function pullRuleGraph(session, concurrency = DEFAULT_PULL_CONCURRENCY) {
+    const identity = session.environmentFingerprint();
+    const pulledAtIso = new Date().toISOString();
+    const totalStart = Date.now();
+    let listMs = 0;
+    let readMs = 0;
+    // Model enumeration mirrors the governed `model.list` tool exactly: the
+    // application tree flattened to BizModel rows. The bare `modelList` endpoint
+    // returns EMPTY data on a real platform (works only against the fake face)
+    // — using it here made the first live pull enumerate zero models and (pre-
+    // zero-guard) wedge the scheduler.
+    const applicationCode = await resolveApplicationCode(session, undefined).catch(() => "");
+    const schemaCodes = flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode: applicationCode } })).data))
+        .filter((row) => row.type === "BizModel" && typeof row.code === "string" && row.code !== "")
+        .map((row) => String(row.code))
+        .sort();
+    const rules = [];
+    const edges = [];
+    const gaps = [];
+    let parseFailures = 0;
+    let dataruleCount = 0;
+    let viewCount = 0;
+    // --- shared scheduler: bounded starts, dynamic task submission ---
+    class Semaphore {
+        // Handoff semantics: a released slot is handed DIRECTLY to the head
+        // waiter (free is NOT incremented). The naive `free += 1; wake()` lets a
+        // task submitted in the microtask gap steal the slot, driving free
+        // negative — a waiter is then never woken, the pull promise never
+        // settles, and Node exits 0 SILENTLY when the event loop drains (no
+        // envelope, lock left behind). Direct handoff keeps the invariant.
+        free = concurrency;
+        waiters = [];
+        async acquire() {
+            if (this.free > 0) {
+                this.free -= 1;
+                return;
+            }
+            await new Promise((resolve) => this.waiters.push(resolve));
+        }
+        release() {
+            const waiter = this.waiters.shift();
+            if (waiter !== undefined) {
+                waiter();
+                return;
+            }
+            this.free += 1;
+        }
+    }
+    const semaphore = new Semaphore();
+    let inflight = 0;
+    let resolveAll = () => { };
+    const allDone = new Promise((resolve) => {
+        resolveAll = resolve;
+    });
+    const maybeDone = () => {
+        if (inflight === 0)
+            resolveAll();
+    };
+    const submit = (task) => {
+        inflight += 1;
+        void (async () => {
+            await semaphore.acquire();
+            try {
+                await task();
+            }
+            catch (error) {
+                gaps.push({ kind: "pull-task", ref: "internal", note: error instanceof Error ? error.message : String(error) });
+            }
+            finally {
+                semaphore.release();
+                inflight -= 1;
+                maybeDone();
+            }
+        })();
+    };
+    // --- task kinds ---
+    const runModelFace = async (schemaCode) => {
+        const faceStart = Date.now();
+        // Independent per-face reads: one face failing must not drop the other's
+        // rows (review: Promise.all here mis-filed datarule failures as rule gaps).
+        let rows = [];
+        let ruleListOk = true;
+        try {
+            rows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);
+        }
+        catch (error) {
+            ruleListOk = false;
+            gaps.push({ kind: "rule-list", ref: schemaCode, note: error instanceof Error ? error.message : String(error) });
+        }
+        let dataruleRows = [];
+        try {
+            dataruleRows = wireRows((await wireCall(session, { path: ENDPOINTS.dataRuleList, query: { schemaCode } })).data);
+            dataruleCount += dataruleRows.length;
+            for (const row of dataruleRows)
+                edges.push(...extractDataRuleEdges(schemaCode, row));
+        }
+        catch (error) {
+            gaps.push({ kind: "datarule-list", ref: schemaCode, note: error instanceof Error ? error.message : String(error) });
+        }
+        try {
+            const views = wireRows((await wireCall(session, { path: ENDPOINTS.listQueryList, query: { schemaCode, clientType: "PC" } })).data);
+            for (const view of views) {
+                const viewCode = typeof view.code === "string" ? view.code : "";
+                if (viewCode === "")
+                    continue;
+                submit(() => runListViewRead(schemaCode, viewCode));
+            }
+        }
+        catch (error) {
+            gaps.push({ kind: "listview-list", ref: schemaCode, note: error instanceof Error ? error.message : String(error) });
+        }
+        listMs += Date.now() - faceStart;
+        if (!ruleListOk)
+            return;
+        const readSubmit = Date.now();
+        let queued = 0;
+        for (const row of rows) {
+            const ruleCode = String(row.code ?? "");
+            const ruleId = row.id;
+            if (ruleCode === "" || typeof ruleId !== "string" || ruleId === "") {
+                gaps.push({ kind: "rule-row-id", ref: `${schemaCode}/${ruleCode || "?"}` });
+                continue;
+            }
+            queued += 1;
+            submit(() => runRuleRead(schemaCode, ruleCode, ruleId));
+        }
+        if (queued > 0)
+            readMs += Date.now() - readSubmit;
+    };
+    const runRuleRead = async (schemaCode, ruleCode, ruleId) => {
+        const start = Date.now();
+        try {
+            const record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: ruleId } })).data;
+            if (!record) {
+                gaps.push({ kind: "rule-get", ref: `${schemaCode}/${ruleCode}`, note: "empty readback" });
+                return;
+            }
+            const nodes = decodeJsonColumn(record.node, JSON_COLUMN_NULL_COALESCE);
+            if (!Array.isArray(nodes)) {
+                parseFailures += 1;
+                gaps.push({ kind: "rule-graph-parse", ref: `${schemaCode}/${ruleCode}` });
+                return;
+            }
+            rules.push({
+                schemaCode,
+                ruleCode,
+                name: String(record.name ?? ruleCode),
+                enabled: typeof record.enabled === "boolean" ? record.enabled : null,
+                status: typeof record.status === "string" ? record.status : null,
+                defaultRule: typeof record.defaultRule === "boolean" ? record.defaultRule : null,
+                rowId: ruleId,
+                graphSha256: sha256({ nodes, routes: decodeJsonColumn(record.route, JSON_COLUMN_NULL_COALESCE) }),
+            });
+            edges.push(...extractReferenceEdges(schemaCode, ruleCode, nodes));
+        }
+        catch (error) {
+            gaps.push({ kind: "rule-get", ref: `${schemaCode}/${ruleCode}`, note: error instanceof Error ? error.message : String(error) });
+        }
+        finally {
+            readMs += Date.now() - start;
+        }
+    };
+    const runListViewRead = async (schemaCode, viewCode) => {
+        try {
+            const got = (await wireCall(session, { path: ENDPOINTS.listQueryGet, query: { schemaCode, code: viewCode, clientType: "PC" } })).data;
+            if (got === null || !got.id) {
+                gaps.push({ kind: "listview-get", ref: `${schemaCode}/${viewCode}`, note: "empty readback" });
+                return;
+            }
+            viewCount += 1;
+            edges.push(...extractListViewEdges(schemaCode, viewCode, got));
+        }
+        catch (error) {
+            gaps.push({ kind: "listview-get", ref: `${schemaCode}/${viewCode}`, note: error instanceof Error ? error.message : String(error) });
+        }
+    };
+    for (const schemaCode of schemaCodes)
+        submit(() => runModelFace(schemaCode));
+    // Zero-scope guard: with no models there are no tasks, so no finally ever
+    // calls maybeDone — awaiting allDone would wedge the pull until the event
+    // loop drained and Node exited 0 silently. Resolve explicitly.
+    maybeDone();
+    await allDone;
+    rules.sort((a, b) => (a.schemaCode === b.schemaCode ? a.ruleCode.localeCompare(b.ruleCode) : a.schemaCode.localeCompare(b.schemaCode)));
+    edges.sort((a, b) => a.kind === b.kind
+        ? a.code === b.code
+            ? a.schemaCode === b.schemaCode
+                ? a.ruleCode === b.ruleCode
+                    ? a.nodeCode === b.nodeCode
+                        ? a.via.localeCompare(b.via)
+                        : a.nodeCode.localeCompare(b.nodeCode)
+                    : a.ruleCode.localeCompare(b.ruleCode)
+                : a.schemaCode.localeCompare(b.schemaCode)
+            : a.code.localeCompare(b.code)
+        : a.kind.localeCompare(b.kind));
+    gaps.sort((a, b) => (a.kind === b.kind ? a.ref.localeCompare(b.ref) : a.kind.localeCompare(b.kind)));
+    return {
+        meta: {
+            schemaVersion: GRAPH_SCHEMA_VERSION,
+            scope: "businessrule",
+            identityFingerprint: identity,
+            environmentName: session.environmentName,
+            applicationCode: session.profile.applicationCode,
+            pulledAtIso,
+        },
+        rules,
+        edges,
+        gaps,
+        scanned: { models: schemaCodes.length, rules: rules.length, datarules: dataruleCount, views: viewCount, parseFailures },
+        timings: { listMs, readMs, totalMs: Date.now() - totalStart },
+    };
+}
+function ensureGraphDir() {
+    const dir = dirname(graphDbPath());
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+/**
+ * Cross-process pull lock: O_EXCL create; a lock older than STALE_LOCK_MS is
+ * considered abandoned and taken over. This is a LOCAL index lock — pull never
+ * writes the environment, so it must not touch the environment write lock.
+ */
+async function withGraphPullLock(run) {
+    ensureGraphDir();
+    const lockPath = `${graphDbPath()}.lock`;
+    const owner = `${process.pid} ${new Date().toISOString()}`;
+    let fd;
+    try {
+        try {
+            fd = openSync(lockPath, "wx");
+            writeFileSync(fd, owner);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            let stale = false;
+            try {
+                stale = Date.now() - statSync(lockPath).mtimeMs > STALE_LOCK_MS;
+            }
+            catch {
+                stale = false;
+            }
+            if (!stale)
+                throw new GraphPullLockHeldError("graph pull 已在进行（本地索引锁被占用）；稍后重试，或确认无进行中拉取后删除 <配置根>/.omc/graph/graph.db.lock");
+            rmSync(lockPath, { force: true });
+            try {
+                fd = openSync(lockPath, "wx");
+                writeFileSync(fd, owner);
+            }
+            catch (error) {
+                // Lost the stale-takeover race to another pull — still a lock refusal
+                // (exit 12), never a generic thrown error (exit 10).
+                if (error.code === "EEXIST")
+                    throw new GraphPullLockHeldError("graph pull 已在进行（陈旧锁接管竞争失败）；稍后重试");
+                throw error;
+            }
+        }
+        return await run();
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        try {
+            unlinkSync(lockPath);
+        }
+        catch {
+            // already gone — another stale takeover won the race
+        }
+    }
+}
+/** Wholesalerebuild + atomic publish (staging file + rename), 0600. */
+export async function publishGraphPull(session, concurrency = DEFAULT_PULL_CONCURRENCY) {
+    try {
+        return await withGraphPullLock(async () => {
+            const data = await pullRuleGraph(session, concurrency);
+            const staging = `${graphDbPath()}.staging-${process.pid}`;
+            rmSync(staging, { force: true });
+            const DatabaseSyncCtor = nodeSqlite().DatabaseSync;
+            const db = new DatabaseSyncCtor(staging);
+            try {
+                // The index is a rebuildable cache: crash durability is worthless here,
+                // and the default per-transaction journal fsync costs MINUTES on a
+                // network filesystem (observed 165s wall for a 2s pull on NFS /vol1 —
+                // D-state in folio_wait_bit_common). One transaction + memory journal
+                // + synchronous=OFF makes the build effectively free.
+                db.exec("PRAGMA journal_mode=MEMORY; PRAGMA synchronous=OFF;");
+                db.exec(`BEGIN;
+        CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+        CREATE TABLE rules (
+          schema_code TEXT NOT NULL,
+          rule_code TEXT NOT NULL,
+          name TEXT,
+          enabled INTEGER,
+          status TEXT,
+          default_rule INTEGER,
+          row_id TEXT NOT NULL,
+          graph_sha256 TEXT NOT NULL,
+          PRIMARY KEY (schema_code, rule_code)
+        );
+        CREATE TABLE edges (
+          kind TEXT NOT NULL,
+          code TEXT NOT NULL,
+          schema_code TEXT NOT NULL,
+          rule_code TEXT NOT NULL,
+          node_code TEXT,
+          node_type TEXT,
+          via TEXT NOT NULL
+        );
+        CREATE INDEX edges_lookup ON edges(kind, code);
+        CREATE TABLE gaps (kind TEXT NOT NULL, ref TEXT NOT NULL, note TEXT);
+      `);
+                const insertMeta = db.prepare("INSERT INTO meta (key, value) VALUES (?, ?)");
+                for (const [key, value] of Object.entries(data.meta))
+                    insertMeta.run(key, String(value));
+                const insertRule = db.prepare("INSERT INTO rules (schema_code, rule_code, name, enabled, status, default_rule, row_id, graph_sha256) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+                for (const rule of data.rules)
+                    insertRule.run(rule.schemaCode, rule.ruleCode, rule.name, rule.enabled === null ? null : rule.enabled ? 1 : 0, rule.status, rule.defaultRule === null ? null : rule.defaultRule ? 1 : 0, rule.rowId, rule.graphSha256);
+                const insertEdge = db.prepare("INSERT INTO edges (kind, code, schema_code, rule_code, node_code, node_type, via) VALUES (?, ?, ?, ?, ?, ?, ?)");
+                for (const edge of data.edges)
+                    insertEdge.run(edge.kind, edge.code, edge.schemaCode, edge.ruleCode, edge.nodeCode, edge.nodeType, edge.via);
+                const insertGap = db.prepare("INSERT INTO gaps (kind, ref, note) VALUES (?, ?, ?)");
+                for (const gap of data.gaps)
+                    insertGap.run(gap.kind, gap.ref, gap.note ?? null);
+                // FTS5 mirrors rules (code+name) for `graph search`; one rebuild after
+                // the bulk insert is cheaper than per-row triggers on a wholesale rebuild.
+                db.exec(`
+        CREATE VIRTUAL TABLE rules_fts USING fts5(rule_code, name, content='rules', content_rowid='rowid');
+        INSERT INTO rules_fts(rules_fts) VALUES('rebuild');
+      `);
+                db.exec("COMMIT;");
+            }
+            finally {
+                db.close();
+            }
+            chmodSync(staging, 0o600);
+            const dbBytes = statSync(staging).size;
+            renameSync(staging, graphDbPath());
+            return { ...data, dbBytes };
+        });
+    }
+    catch (error) {
+        // A failed build must not leave staging garbage next to the index.
+        rmSync(`${graphDbPath()}.staging-${process.pid}`, { force: true });
+        throw error;
+    }
+}
+function openGraphIndex() {
+    const dbPath = graphDbPath();
+    if (!existsSync(dbPath))
+        throw new GraphIndexAbsentError("没有本地规则图索引（<配置根>/.omc/graph/graph.db）；先运行 omc graph pull --env <env> 全量重建");
+    let db;
+    try {
+        const DatabaseSyncCtor = nodeSqlite().DatabaseSync;
+        db = new DatabaseSyncCtor(dbPath, { readOnly: true });
+        const meta = {};
+        for (const row of db.prepare("SELECT key, value FROM meta").all())
+            meta[row.key] = row.value;
+        if (meta.schemaVersion !== GRAPH_SCHEMA_VERSION)
+            throw new GraphIndexAbsentError(`索引 schema 版本不匹配（${meta.schemaVersion} ≠ ${GRAPH_SCHEMA_VERSION}）；重跑 omc graph pull`);
+        const ruleCount = db.prepare("SELECT COUNT(*) AS n FROM rules").get().n;
+        const modelCount = db.prepare("SELECT COUNT(DISTINCT schema_code) AS n FROM rules").get().n;
+        const edgeRows = db.prepare("SELECT kind, COUNT(*) AS n FROM edges GROUP BY kind").all();
+        const edges = {};
+        for (const row of edgeRows)
+            edges[row.kind] = row.n;
+        const gapRows = db.prepare("SELECT kind, COUNT(*) AS n FROM gaps GROUP BY kind").all();
+        const byKind = {};
+        let gapCount = 0;
+        for (const row of gapRows) {
+            byKind[row.kind] = row.n;
+            gapCount += row.n;
+        }
+        return {
+            db,
+            summary: {
+                environmentName: meta.environmentName ?? "",
+                applicationCode: meta.applicationCode ?? "",
+                identityFingerprint: meta.identityFingerprint ?? "",
+                pulledAtIso: meta.pulledAtIso ?? "",
+                freshness: gapCount === 0 ? "complete" : "partial",
+                models: modelCount,
+                rules: ruleCount,
+                edges,
+                gaps: { count: gapCount, byKind },
+            },
+        };
+    }
+    catch (error) {
+        db?.close();
+        throw error instanceof GraphIndexAbsentError ? error : new GraphIndexAbsentError(`索引不可读（schema 不匹配或文件损坏）：${error instanceof Error ? error.message : String(error)}；重跑 omc graph pull`);
+    }
+}
+export function queryGraphReferences(kind, code) {
+    const { db, summary } = openGraphIndex();
+    try {
+        const rows = db
+            .prepare("SELECT schema_code, rule_code, node_code, node_type, via FROM edges WHERE kind = ? AND code = ? ORDER BY schema_code, rule_code, node_code, via")
+            .all(kind, code);
+        const matches = rows.map((row) => ({
+            schemaCode: row.schema_code,
+            ruleCode: row.rule_code,
+            nodeCode: row.node_code ?? "",
+            nodeType: row.node_type ?? "",
+            via: row.via,
+        }));
+        const gapped = summary.gaps.count > 0;
+        return {
+            kind,
+            code,
+            matches,
+            index: summary,
+            ...(matches.length === 0
+                ? {
+                    note: gapped
+                        ? "零命中，但索引存在扫描缺口——不可作为「无引用」证明；先 omc graph pull 重建再查"
+                        : "零命中=索引覆盖范围内没有引用它（规则面：service→methodMapping.serviceCode；model→targetObjectCode/methodMapping.schemaCode；field→dataActions.targetDataItem/映射 bizCode；数据规则面：propertyCodes 目标与 options {字段} 引用；视图面：列/排序/条件的 propertyCode。不含规则条件叶子/流程绑定）",
+                }
+                : {}),
+            ...(gapped
+                ? { gapWarning: `索引有 ${summary.gaps.count} 个扫描缺口（${Object.entries(summary.gaps.byKind).map(([k, v]) => `${k}:${v}`).join(", ")}）；命中列表可能不完整` }
+                : {}),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function readGraphStatus() {
+    const { db, summary } = openGraphIndex();
+    try {
+        const gaps = db.prepare("SELECT kind, ref, note FROM gaps ORDER BY kind, ref LIMIT 50").all();
+        return { index: summary, dbBytes: statSync(graphDbPath()).size, gaps };
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Bounded FTS5 lookup over rule code + name — the "find the rule about X"
+ * entry point (references/impact need an exact code; search gets you the
+ * code). Tokens are quoted (no FTS syntax injection); the LAST token becomes
+ * a prefix match (`引用*`), which is also what makes CJK usable: unicode61
+ * stores a CJK run as one token, so a full-run query hits only by prefix.
+ */
+export function searchGraphRules(term, limit = 20) {
+    const { db, summary } = openGraphIndex();
+    try {
+        const tokens = term.trim().split(/\s+/).filter((token) => token !== "");
+        let matches = [];
+        if (tokens.length > 0) {
+            const quoted = tokens.map((token, index) => `"${token.replaceAll('"', '""')}"${index === tokens.length - 1 ? "*" : ""}`).join(" ");
+            const rows = db
+                .prepare(`SELECT r.schema_code, r.rule_code, r.name, r.enabled, r.status
+           FROM rules_fts JOIN rules r ON r.rowid = rules_fts.rowid
+           WHERE rules_fts MATCH ? ORDER BY bm25(rules_fts), r.schema_code, r.rule_code LIMIT ?`)
+                .all(quoted, limit);
+            const refsFor = db.prepare("SELECT kind, code FROM edges WHERE schema_code = ? AND rule_code = ? ORDER BY kind, code");
+            matches = rows.map((row) => {
+                const refs = { service: [], model: [], field: [] };
+                for (const edge of refsFor.all(row.schema_code, row.rule_code))
+                    if (edge.kind in refs)
+                        refs[edge.kind].push(edge.code);
+                return {
+                    schemaCode: row.schema_code,
+                    ruleCode: row.rule_code,
+                    name: row.name ?? "",
+                    enabled: row.enabled === null ? null : row.enabled === 1,
+                    status: row.status,
+                    refs,
+                };
+            });
+        }
+        const gapped = summary.gaps.count > 0;
+        return {
+            term,
+            rules: matches,
+            index: summary,
+            ...(matches.length === 0
+                ? { note: tokens.length === 0 ? "检索词为空" : "没有命中规则（code+name 全文；引用检索用 references/impact <kind> <code>）" }
+                : {}),
+            ...(gapped ? { gapWarning: `索引有 ${summary.gaps.count} 个扫描缺口；命中列表可能不完整` } : {}),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Reverse blast radius over the reference edges: hop 1 = rules referencing the
+ * given code (what `references` answers), hop 2 = everything those rules touch
+ * (services/models/fields). "Change field X → these rules fire, and they also
+ * read/write these codes — verify those too." Bounded: 50 rules, 20 codes per
+ * kind; the same fail-closed gap semantics as references apply.
+ */
+export function impactGraph(kind, code) {
+    const { db, summary } = openGraphIndex();
+    try {
+        const hop1 = db
+            .prepare("SELECT DISTINCT schema_code, rule_code FROM edges WHERE kind = ? AND code = ? AND node_type NOT IN ('datarule', 'listview') ORDER BY schema_code, rule_code LIMIT 51")
+            .all(kind, code);
+        const dataruleHits = db
+            .prepare("SELECT DISTINCT schema_code, node_code AS targets, via FROM edges WHERE kind = ? AND code = ? AND node_type = 'datarule' ORDER BY schema_code, node_code, via LIMIT 21")
+            .all(kind, code);
+        const listViewHits = db
+            .prepare("SELECT DISTINCT schema_code, node_code AS view_code, via FROM edges WHERE kind = ? AND code = ? AND node_type = 'listview' ORDER BY schema_code, node_code, via LIMIT 21")
+            .all(kind, code);
+        const capped = hop1.length > 50;
+        const refsFor = db.prepare("SELECT kind, code, via FROM edges WHERE schema_code = ? AND rule_code = ? AND node_type <> 'datarule' ORDER BY kind, code, via");
+        const ruleName = db.prepare("SELECT name FROM rules WHERE schema_code = ? AND rule_code = ?");
+        const services = new Set();
+        const models = new Set();
+        const fields = new Set();
+        const rules = hop1.slice(0, 50).map((row) => {
+            const via = [];
+            const touches = { service: [], model: [], field: [] };
+            for (const edge of refsFor.all(row.schema_code, row.rule_code)) {
+                if (edge.kind === kind && edge.code === code) {
+                    if (!via.includes(edge.via))
+                        via.push(edge.via);
+                    continue; // the queried code itself is not "additional blast radius"
+                }
+                const bucket = touches[edge.kind];
+                if (bucket && !bucket.includes(edge.code))
+                    bucket.push(edge.code);
+                if (edge.kind === "service")
+                    services.add(edge.code);
+                else if (edge.kind === "model")
+                    models.add(edge.code);
+                else if (edge.kind === "field")
+                    fields.add(edge.code);
+            }
+            for (const key of ["service", "model", "field"]) {
+                const bucket = touches[key];
+                if (bucket.length > 20)
+                    touches[key] = bucket.slice(0, 20);
+            }
+            const name = ruleName.get(row.schema_code, row.rule_code)?.name ?? "";
+            return { schemaCode: row.schema_code, ruleCode: row.rule_code, name, matchedVia: via, touches };
+        });
+        const gapped = summary.gaps.count > 0;
+        return {
+            kind,
+            code,
+            rules,
+            datarules: dataruleHits.slice(0, 20).map((hit) => ({ schemaCode: hit.schema_code, targets: hit.targets ?? "", via: hit.via })),
+            listviews: listViewHits.slice(0, 20).map((hit) => ({ schemaCode: hit.schema_code, viewCode: hit.view_code ?? "", via: hit.via })),
+            totals: { rules: hop1.length, datarules: dataruleHits.length, listviews: listViewHits.length, touchedServices: services.size, touchedModels: models.size, touchedFields: fields.size },
+            index: summary,
+            ...(hop1.length === 0 && dataruleHits.length === 0 && listViewHits.length === 0
+                ? {
+                    note: gapped
+                        ? "零命中，但索引存在扫描缺口——不可作为「无影响」证明；先 omc graph pull 重建再查"
+                        : "零命中=索引覆盖范围内没有引用它（规则面+数据规则面+视图列/排序/条件面；流程绑定暂不在索引内）",
+                }
+                : {}),
+            ...(capped || dataruleHits.length > 20 || listViewHits.length > 20
+                ? { truncated: true, note: `命中超过上限已截断（规则 50/实际 ${hop1.length}，数据规则 20/实际 ${dataruleHits.length}，视图 20/实际 ${listViewHits.length}）；完整规则清单用 references` }
+                : {}),
+            ...(gapped ? { gapWarning: `索引有 ${summary.gaps.count} 个扫描缺口（${Object.entries(summary.gaps.byKind).map(([k, v]) => `${k}:${v}`).join(", ")}）；影响面可能不完整` } : {}),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+//# sourceMappingURL=graph.js.map