gitnexus 1.6.8-rc.8 → 1.6.8

package/dist/core/lbug/lbug-adapter.d.ts

@@ -1,9 +1,9 @@
 import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
+import { NodeTableName } from './schema.js';
+import type { PdgEmitManifest } from './pdg-emit-sink.js';
 import type { CachedEmbedding } from '../embeddings/types.js';
 import { type ExtensionEnsureOptions } from './extension-loader.js';
-/** Factory for creating WriteStreams — injectable for testing. */
-export type WriteStreamFactory = (filePath: string) => import('fs').WriteStream;
 /** Result of splitting the relationship CSV into per-label-pair files. */
 export interface RelCsvSplitResult {
     relHeader: string;
@@ -15,21 +15,6 @@ export interface RelCsvSplitResult {
     skippedRels: number;
     totalValidRels: number;
 }
-/**
- * Split a relationship CSV into per-label-pair files on disk.
- *
- * Streams the CSV line-by-line, routing each relationship to a file named
- * `rel_{fromLabel}_{toLabel}.csv`. Handles backpressure correctly: only one
- * drain listener per stream at a time, and readline resumes only when ALL
- * backpressured streams have drained.
- *
- * @param csvPath       Path to the combined relationship CSV
- * @param csvDir        Directory to write per-pair CSV files
- * @param validTables   Set of valid node table names
- * @param getNodeLabel  Function to extract the label from a node ID
- * @param wsFactory     Optional WriteStream factory (defaults to fs.createWriteStream)
- */
-export declare const splitRelCsvByLabelPair: (csvPath: string, csvDir: string, validTables: Set<string>, getNodeLabel: (id: string) => string, wsFactory?: WriteStreamFactory) => Promise<RelCsvSplitResult>;
 /** Expose the current Database for pool adapter reuse in tests. */
 export declare const getDatabase: () => lbug.Database | null;
 /**
@@ -70,12 +55,35 @@ export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>
     readOnly?: boolean;
 }) => Promise<T>;
 export type LbugProgressCallback = (message: string) => void;
-export declare const loadGraphToLbug: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: LbugProgressCallback) => Promise<{
+/**
+ * Persist a KnowledgeGraph: stream CSVs, then bulk-COPY nodes (overlapped with
+ * relationship emit — see the body) and relationships.
+ *
+ * NOT TRANSACTIONAL (#2226). Each `COPY` commits independently and there is no
+ * surrounding transaction, so a failure partway through — a node `COPY` that
+ * throws at the FK barrier, a relationship `COPY` failure, or a `pdgEmitManifest`
+ * collision raised after node rows have already committed in the overlap path —
+ * leaves a partially-loaded DB. The caller surfaces the error; recovery is a
+ * `--force` re-analyze (a full rebuild), not a partial retry. Callers must not
+ * assume the DB is either fully loaded or untouched after a rejection.
+ */
+export declare const loadGraphToLbug: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: LbugProgressCallback, 
+/**
+ * Streamed PDG-emit manifest (#2202). When present (streaming was on, full
+ * rebuild), the BasicBlock node CSV + per-pair PDG-edge CSVs it points at
+ * were already flushed to disk during the emit loop; they are merged into the
+ * COPY plan below so they load alongside the structural CSVs. When streaming
+ * was on the in-memory `graph` holds zero BasicBlocks, so `streamAllCSVsToDisk`
+ * emits none — the manifest is the sole source and there is no double-COPY.
+ */
+pdgEmitManifest?: PdgEmitManifest) => Promise<{
     success: boolean;
     insertedRels: number;
     skippedRels: number;
     warnings: string[];
 }>;
+export declare const COPY_CSV_OPTS = "(HEADER=true, ESCAPE='\"', DELIM=',', QUOTE='\"', PARALLEL=false, auto_detect=false)";
+export declare const getCopyQuery: (table: NodeTableName, filePath: string) => string;
 /**
  * Insert a single node to LadybugDB
  * @param label - Node type (File, Function, Class, etc.)
@@ -206,6 +214,38 @@ export declare const queryImporters: (targetFilePath: string) => Promise<string[
 export declare const deleteAllCommunitiesAndProcesses: () => Promise<{
     nodesDeleted: number;
 }>;
+/**
+ * Drop every interprocedural `TAINT_PATH` relationship (#2084 M4 U6). Used at
+ * the start of an incremental `--pdg` writeback so the `taintSummaries` phase
+ * re-materialises them from scratch on the FULL recomputed graph.
+ *
+ * TAINT_PATH validity is a WHOLE-PROGRAM property (a flow A→C can be
+ * invalidated by a change to an INTERMEDIATE function whose file is neither A
+ * nor C). The endpoint-writability extract rule (`extractChangedSubgraph`)
+ * cannot see that — an A→C edge between two unchanged files would be skipped
+ * and a stale finding would survive. So, exactly like Community/Process, the
+ * sound move is delete-all-then-rebuild: cheap because TAINT_PATH is sparse
+ * (per-run capped), and the compute side already rebuilds every summary each
+ * run. Relationship-level (TAINT_PATH is an edge type, not a node label), so a
+ * plain DELETE on the typed CodeRelation rows — endpoints are untouched.
+ */
+export declare const deleteAllInterprocTaintPaths: () => Promise<{
+    edgesDeleted: number;
+}>;
+/**
+ * Drop every `CALL_SUMMARY` relationship (PDG FU-C, U-C3). Used at the start of
+ * an incremental `--pdg` writeback so the `callSummaries` phase re-materialises
+ * them from scratch on the FULL recomputed graph.
+ *
+ * Mirrors {@link deleteAllInterprocTaintPaths}: CALL_SUMMARY is a self-loop edge
+ * type (not a node label), so a plain DELETE on the typed CodeRelation rows
+ * leaves endpoints untouched. `extractChangedSubgraph` re-includes ALL of them
+ * from the fresh graph (`isGraphWideRelType`), so delete-all-then-rebuild keeps
+ * an unchanged function's summary from being lost.
+ */
+export declare const deleteAllCallSummaries: () => Promise<{
+    edgesDeleted: number;
+}>;
 /**
  * Load the FTS extension on the supplied connection (or the singleton
  * writable connection when none is given).