@untangle-code/context-artifacts 0.0.0-stage → 0.1.1

package/dist/adapters/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/adapters/shared.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACpB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACxB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGvD,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEjF,sGAAsG;AACtG,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,OAAO,CAAC,mBAAmB,EAAE,MAAM,CAAC,EAC1C,QAAQ,CAAC,EAAE,MAAM,GAChB,gBAAgB,EAAE,CAWpB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,UAAU,EAAE,GACnB,aAAa,EAAE,CA6BjB;AAED,4HAA4H;AAC5H,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAG7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,UAAU,EAAE,EACpB,MAAM,GAAE,kBAA8C,EACtD,iBAAiB,CAAC,EAAE,sBAAsB,GACzC,aAAa,EAAE,CAUjB"}

package/dist/adapters/shared.js

@@ -0,0 +1,95 @@
+import { sha256Hex } from "@untangle-code/domain";
+import { buildArtifactSkipLedger, defaultSkipLedgerReporter, } from "../coverage.js";
+import { buildArtifactChunkId } from "../ids.js";
+import { rangeForLines, sliceBytes, sliceLines } from "../text/line-index.js";
+/** Builds one `ArtifactDocument` per file in `input.files` (spec.md §19.2: files AND directories). */
+export function buildDocuments(input, type, language) {
+    return input.files.map((file) => {
+        const document = {
+            artifactName: input.config.name,
+            type,
+            path: file.path,
+            contentHash: file.contentHash,
+            content: file.content,
+        };
+        return language === undefined ? document : { ...document, language };
+    });
+}
+/**
+ * Turns line-range drafts into fully-formed `ArtifactChunk`s: computes
+ * `range` (via `index`, or the draft's own `startByte`/`endByte` when
+ * given), byte-exact `content` (a slice of the SAME buffer `index` was
+ * built from — never a re-encoded copy, so content is always byte-identical
+ * to the source, spec.md §19.2), `contentHash`, and a deterministic
+ * `chunkId` (ordinal = position in `drafts`).
+ */
+export function buildChunks(document, index, drafts) {
+    return drafts.map((draft, ordinal) => {
+        const hasExactBytes = draft.startByte !== undefined && draft.endByte !== undefined;
+        const range = hasExactBytes
+            ? {
+                startLine: draft.startLine,
+                endLine: draft.endLine,
+                startByte: draft.startByte,
+                endByte: draft.endByte,
+            }
+            : rangeForLines(index, draft.startLine, draft.endLine);
+        const content = hasExactBytes
+            ? sliceBytes(index, draft.startByte, draft.endByte)
+            : sliceLines(index, draft.startLine, draft.endLine);
+        const chunk = {
+            chunkId: buildArtifactChunkId({
+                artifactName: document.artifactName,
+                documentPath: document.path,
+                kind: draft.kind,
+                ordinal,
+            }),
+            artifactName: document.artifactName,
+            kind: draft.kind,
+            range,
+            content,
+            contentHash: sha256Hex(content),
+        };
+        return draft.title === undefined ? chunk : { ...chunk, title: draft.title };
+    });
+}
+/** A single chunk spanning the whole document, used for parse-error degrades and the text fallback's single-window case. */
+export function wholeDocumentDraft(kind, index, title) {
+    const draft = { kind, startLine: 1, endLine: Math.max(index.lineCount, 1) };
+    return title === undefined ? draft : { ...draft, title };
+}
+/**
+ * `buildChunks`, plus BUILD_PLAN §12 E4: `buildArtifactSkipLedger()` must
+ * never be a "Bringschuld" (an obligation a caller has to remember) —
+ * every format adapter's `chunk()` calls this instead of `buildChunks`
+ * directly, so a loss becomes visible in the SAME call that produces
+ * chunks, with zero extra action from whoever calls `adapter.chunk()`.
+ *
+ * `checkPlausibility` (optional, WP-118) reicht die formatspezifische
+ * Plausibilitätsprüfung des Adapters an den Ledger durch: ein Fragment,
+ * das MITTEN DURCH ein Konstrukt geschnitten wurde, ist auch dann ein
+ * Befund, wenn die Byte-Abdeckung lückenlos ist. Siehe
+ * `coverage.ts::ChunkPlausibilityCheck` und `text/delimiter-balance.ts`.
+ *
+ * Only entries beyond plain `"whitespace_or_comment"` are reported —
+ * `"unclassified_content"` and `"semantic_loss"` are the two reasons that
+ * indicate a real problem (see coverage.ts's module doc); a benign gap
+ * between two well-formed sections is expected and stays silent here too,
+ * exactly as it does for a caller who inspects the ledger directly.
+ *
+ * `report` defaults to `defaultSkipLedgerReporter` (a single stderr line
+ * per finding) but every `create*Adapter()` factory accepts an
+ * `onSkipLedgerGap` override — inject a real structured logger, a test
+ * spy, or a no-op, without this package depending on any particular
+ * logging implementation.
+ */
+export function buildChunksReportingSkips(document, index, drafts, report = defaultSkipLedgerReporter, checkPlausibility) {
+    const chunks = buildChunks(document, index, drafts);
+    const options = checkPlausibility === undefined ? {} : { checkPlausibility };
+    const actionable = buildArtifactSkipLedger(document, chunks, options).filter((entry) => entry.reason !== "whitespace_or_comment");
+    if (actionable.length > 0) {
+        report(actionable, document);
+    }
+    return chunks;
+}
+//# sourceMappingURL=shared.js.map

package/dist/adapters/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/adapters/shared.ts"],"names":[],"mappings":"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"}

package/dist/adapters/sql.d.ts

@@ -0,0 +1,104 @@
+/**
+ * SQL schema adapter (architecture.md §20: "Tabellen, Views, Indizes,
+ * Constraints als semantische Abschnitte").
+ *
+ * Splits the file into top-level statements (terminated by a `;` that is
+ * not inside a string literal, a quoted identifier, or a comment), then
+ * classifies each statement by its leading keywords. An unrecognized
+ * statement (e.g. `INSERT`, `GRANT`) still becomes a chunk — kind
+ * `"sql_statement"` — rather than being dropped; nothing in a schema file
+ * is silently skipped (rule 4 / BUILD_PLAN §12 E4).
+ *
+ * Statement boundaries are tracked as exact BYTE offsets, not just line
+ * numbers (WP-81 review finding): two statements can share one physical
+ * line (`CREATE TABLE a (id int); CREATE TABLE b (id int);`), and a
+ * line-only span can't tell them apart — either the second collapses into
+ * an empty/inverted range (a phantom chunk carrying no content) or its
+ * bytes get silently absorbed into the first statement's chunk, which
+ * still reports zero gap (byte coverage looks complete) even though the
+ * second statement's identity was lost. `splitStatements` below scans the
+ * document's own UTF-8 bytes once, so every statement — including a second
+ * one sharing its predecessor's line — gets its own precise, non-empty,
+ * non-overlapping byte range that `ChunkDraft.startByte`/`endByte`
+ * (`adapters/shared.ts`) carries straight through, instead of snapping to
+ * whole-line boundaries.
+ *
+ * The file's LAST statement is not required to end in `;` — a schema file
+ * missing its final terminator (a common paste/truncation mistake) still
+ * gets its own chunk for that trailing statement; nothing after the last
+ * real `;` is ever silently dropped.
+ *
+ * WP-118: Der Zerleger kannte lange nur die verdoppelte
+ * Anführungszeichen-Konvention (`''`) als Escape. Ein Literal mit `\'` und
+ * einem `;` darin — in Dumps alltäglich — zerriss deshalb EIN Statement in
+ * zwei syntaktisch kaputte Fragmente, und zwar bei NULL Ledger-Warnungen:
+ * die Byte-Abdeckung war lückenlos, die Fragmente weder leer noch
+ * überlappend. Zwei Änderungen beheben das:
+ *
+ * 1. Die Escape-Behandlung ist dialektbewusst ({@link SqlDialect}), mit
+ *    einem benannten, begründeten Standardwert ({@link DEFAULT_SQL_DIALECT})
+ *    statt einer Vermutung über die vorliegende Datei. Zusätzlich erkennt
+ *    der Scanner `$tag$`-Literale, in denen ein `;` genauso alltäglich ist.
+ * 2. Wichtiger: `sqlPlausibilityCheck` prüft JEDES fertige Fragment auf
+ *    offene Zeichenketten, offene Kommentare und unausgeglichene Klammern.
+ *    Damit greift E4 auch dann, wenn nichts FEHLT, sondern etwas FALSCH
+ *    GESCHNITTEN ist — unabhängig davon, ob der Dialekt richtig gewählt
+ *    war. Eine falsche Dialektwahl ist danach sichtbar, nicht still.
+ */
+import type { ArtifactAdapter } from "@untangle-code/domain";
+import type { SkipLedgerReporter } from "./shared.js";
+/**
+ * Escape-Konvention für Zeichenketten-Literale. Die SQL-Dialekte
+ * WIDERSPRECHEN sich hier, und zwar unauflösbar:
+ *
+ * - `"doubled-quotes-only"` — Standard-SQL: das EINZIGE Escape in einem
+ *   Literal ist das verdoppelte Anführungszeichen (`'it''s'`). Ein `\` ist
+ *   ein ganz normales Zeichen; `'it\'` ist eine ABGESCHLOSSENE Zeichenkette
+ *   mit einem Backslash am Ende.
+ * - `"backslash-escapes"` — die verbreitete Erweiterung: zusätzlich zum
+ *   verdoppelten Anführungszeichen maskiert `\'` ein Anführungszeichen,
+ *   `` ` `` klammert Bezeichner und `#` leitet einen Zeilenkommentar ein.
+ *
+ * Dieselbe Datei bedeutet also je nach Dialekt etwas anderes, und der
+ * Dialekt steht NICHT in der Datei. Deshalb wird hier nicht geraten: die
+ * Wahl ist eine explizite Option mit einem benannten Standardwert, und
+ * jedes Ergebnis, das unter der gewählten Konvention unsinnig aussieht,
+ * erzeugt einen sichtbaren Befund (siehe `sqlPlausibilityCheck`).
+ */
+export type SqlDialect = "backslash-escapes" | "doubled-quotes-only";
+/**
+ * Standardwert: `"backslash-escapes"` — bewusst NICHT der Standard-SQL-Dialekt.
+ *
+ * Begründung (asymmetrische Fehlerkosten für einen ZERLEGER, nicht für
+ * einen Ausführer): dieser Adapter führt kein SQL aus, er schneidet nur
+ * Abschnitte. Der teure Fehler ist der Schnitt MITTEN durch ein Statement,
+ * denn er erzeugt zwei syntaktisch kaputte Chunks, die niemand mehr als
+ * ein Statement erkennt (WP-118). Der billige Fehler ist der zu späte
+ * Schnitt: zwei Statements landen in einem Chunk, der immer noch gültiges,
+ * vollständiges SQL enthält.
+ *
+ * - Nimmt man `\'` als Escape und die Datei war Standard-SQL, kann nur ein
+ *   Literal betroffen sein, das unmittelbar vor seinem Schlusszeichen auf
+ *   `\` endet (`'C:\'`) — selten, und das Ergebnis ist eine offene
+ *   Zeichenkette, die die Plausibilitätsprüfung meldet.
+ * - Nimmt man `\'` NICHT als Escape und die Datei nutzt es, zerreißt jedes
+ *   Literal mit `\'` und einem folgenden `;` ein Statement — genau der
+ *   gemeldete Defekt, und in Dumps alltäglich.
+ *
+ * Wer Standard-SQL indexiert und die Backtick-/`#`-Erweiterungen
+ * ausschließen will, setzt `dialect: "doubled-quotes-only"`.
+ */
+export declare const DEFAULT_SQL_DIALECT: SqlDialect;
+export interface SqlAdapterOptions {
+    /** Overrides how a real skip-ledger finding surfaces from `chunk()` (default: a stderr warning) — see `coverage.ts`'s `SkipLedgerReporter`. */
+    onSkipLedgerGap?: SkipLedgerReporter;
+    /**
+     * Escape-Konvention der Zeichenketten-Literale. Standard:
+     * {@link DEFAULT_SQL_DIALECT} (`"backslash-escapes"`) — die Begründung
+     * dieser Wahl steht dort. Der Dialekt wird NICHT aus dem Dateiinhalt
+     * erraten; er ist eine Entscheidung des Aufrufers.
+     */
+    dialect?: SqlDialect;
+}
+export declare function createSqlAdapter(options?: SqlAdapterOptions): ArtifactAdapter;
+//# sourceMappingURL=sql.d.ts.map

package/dist/adapters/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/adapters/sql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,OAAO,KAAK,EACV,eAAe,EAKhB,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EAAsC,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAK1F;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,mBAAmB,GAAG,qBAAqB,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAgC,CAAC;AA2XnE,MAAM,WAAW,iBAAiB;IAChC,+IAA+I;IAC/I,eAAe,CAAC,EAAE,kBAAkB,CAAC;IACrC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,iBAAsB,GAAG,eAAe,CAoDjF"}

package/dist/adapters/sql.js

@@ -0,0 +1,427 @@
+import { describeDelimiterImbalances, findDelimiterImbalances } from "../text/delimiter-balance.js";
+import { buildLineIndex, lineNumberForByte, sliceBytes, } from "../text/line-index.js";
+import { buildChunks, buildChunksReportingSkips, buildDocuments } from "./shared.js";
+const SQL_EXTENSION = /\.sql$/i;
+/**
+ * Standardwert: `"backslash-escapes"` — bewusst NICHT der Standard-SQL-Dialekt.
+ *
+ * Begründung (asymmetrische Fehlerkosten für einen ZERLEGER, nicht für
+ * einen Ausführer): dieser Adapter führt kein SQL aus, er schneidet nur
+ * Abschnitte. Der teure Fehler ist der Schnitt MITTEN durch ein Statement,
+ * denn er erzeugt zwei syntaktisch kaputte Chunks, die niemand mehr als
+ * ein Statement erkennt (WP-118). Der billige Fehler ist der zu späte
+ * Schnitt: zwei Statements landen in einem Chunk, der immer noch gültiges,
+ * vollständiges SQL enthält.
+ *
+ * - Nimmt man `\'` als Escape und die Datei war Standard-SQL, kann nur ein
+ *   Literal betroffen sein, das unmittelbar vor seinem Schlusszeichen auf
+ *   `\` endet (`'C:\'`) — selten, und das Ergebnis ist eine offene
+ *   Zeichenkette, die die Plausibilitätsprüfung meldet.
+ * - Nimmt man `\'` NICHT als Escape und die Datei nutzt es, zerreißt jedes
+ *   Literal mit `\'` und einem folgenden `;` ein Statement — genau der
+ *   gemeldete Defekt, und in Dumps alltäglich.
+ *
+ * Wer Standard-SQL indexiert und die Backtick-/`#`-Erweiterungen
+ * ausschließen will, setzt `dialect: "doubled-quotes-only"`.
+ */
+export const DEFAULT_SQL_DIALECT = "backslash-escapes";
+function isAsciiWhitespaceByte(byte) {
+    return (byte === 0x20 ||
+        byte === 0x09 ||
+        byte === 0x0a ||
+        byte === 0x0d ||
+        byte === 0x0b ||
+        byte === 0x0c);
+}
+/**
+ * After a statement-terminating `;` (buffer offset `semicolonEnd`, already
+ * past the `;` itself), decides how far the just-CLOSED statement's span
+ * should extend: through the rest of this physical line — its trailing
+ * whitespace, an optional trailing `-- ...` line comment, and the newline
+ * itself — when nothing else remains before that newline. This matches how
+ * a statement "owns" the rest of its own terminator line in the common
+ * case, where a schema file has exactly one statement per line (the exact
+ * byte a hand-formatted schema's next statement starts on is then, as
+ * before, the first byte of the following line).
+ *
+ * When real content follows the `;` on the SAME line instead — a second
+ * statement sharing that line — this returns `semicolonEnd` UNCHANGED, so
+ * that content starts its own span right where it begins rather than being
+ * silently folded into the span that just closed (the WP-81 review's
+ * "two statements, one line" defect: `TABLE_RE`/`VIEW_RE`/etc. would only
+ * ever see the FIRST statement's text, and the second statement's own span
+ * would either come out empty or never exist at all).
+ */
+function extendPastTrailingLineNoise(buffer, semicolonEnd) {
+    let j = semicolonEnd;
+    for (;;) {
+        while (j < buffer.length && buffer[j] !== 0x0a && isAsciiWhitespaceByte(buffer[j])) {
+            j += 1;
+        }
+        if (j < buffer.length && buffer[j] === 0x2d && buffer[j + 1] === 0x2d) {
+            // "--": a trailing line comment on the terminator's own line is also
+            // benign noise, not a new statement — skip to (not past) its newline.
+            while (j < buffer.length && buffer[j] !== 0x0a) {
+                j += 1;
+            }
+            continue; // a comment could be followed by more whitespace before the newline
+        }
+        break;
+    }
+    if (j >= buffer.length)
+        return buffer.length;
+    if (buffer[j] === 0x0a)
+        return j + 1;
+    return semicolonEnd; // real content follows on the same line: do not extend past the `;`
+}
+/** Byte-Konstanten des Scanners — alles Einzelbyte-ASCII, siehe `splitStatements`. */
+const BYTE_NEWLINE = 0x0a;
+const BYTE_HASH = 0x23;
+const BYTE_DOLLAR = 0x24;
+const BYTE_SINGLE_QUOTE = 0x27;
+const BYTE_DOUBLE_QUOTE = 0x22;
+const BYTE_BACKTICK = 0x60;
+const BYTE_BACKSLASH = 0x5c;
+const BYTE_STAR = 0x2a;
+const BYTE_SLASH = 0x2f;
+const BYTE_DASH = 0x2d;
+const BYTE_SEMICOLON = 0x3b;
+const BYTE_UNDERSCORE = 0x5f;
+function isDigitByte(byte) {
+    return byte >= 0x30 && byte <= 0x39;
+}
+function isLetterByte(byte) {
+    return (byte >= 0x41 && byte <= 0x5a) || (byte >= 0x61 && byte <= 0x7a);
+}
+/** Zeichen, die in einem `$tag$`-Etikett vorkommen dürfen (ohne `$` selbst). */
+function isTagByte(byte) {
+    return (byte !== undefined && (isLetterByte(byte) || isDigitByte(byte) || byte === BYTE_UNDERSCORE));
+}
+/**
+ * Länge eines `$tag$`-Öffners an Position `i` (0, wenn dort keiner steht).
+ *
+ * Ein Dollar-Literal (`$$ … $$`, `$body$ … $body$`) ist der übliche Weg,
+ * einen Funktionsrumpf einzubetten — und darin steht fast immer ein `;`.
+ * Ohne diese Erkennung zerreißt jeder Funktionsrumpf in Fragmente, also
+ * exakt derselbe Defekt wie bei den Backslash-Escapes, nur mit anderem
+ * Auslöser. Erkannt wird das dialektübergreifend: `$tag$` hat außerhalb
+ * einer Zeichenkette in keinem gängigen Dialekt eine andere Bedeutung, die
+ * einen Statement-Zerleger interessieren müsste.
+ *
+ * Ein vorangehendes Bezeichnerzeichen verhindert die Erkennung — sonst
+ * würde der Bezeichner `my$col$x` fälschlich ein Literal öffnen.
+ */
+function dollarQuoteLength(buffer, i) {
+    if (buffer[i] !== BYTE_DOLLAR)
+        return 0;
+    const previous = i > 0 ? buffer[i - 1] : undefined;
+    if (previous !== undefined && (isTagByte(previous) || previous === BYTE_DOLLAR))
+        return 0;
+    let j = i + 1;
+    const first = buffer[j];
+    if (first !== undefined && (isLetterByte(first) || first === BYTE_UNDERSCORE)) {
+        j += 1;
+        while (j < buffer.length && isTagByte(buffer[j]))
+            j += 1;
+    }
+    if (buffer[j] !== BYTE_DOLLAR)
+        return 0;
+    return j + 1 - i;
+}
+/** Ob an Position `i` genau das Etikett steht, das bei `tagStart` geöffnet wurde. */
+function matchesDollarTag(buffer, i, tagStart, tagLength) {
+    if (i + tagLength > buffer.length)
+        return false;
+    for (let k = 0; k < tagLength; k += 1) {
+        if (buffer[i + k] !== buffer[tagStart + k])
+            return false;
+    }
+    return true;
+}
+/**
+ * Splits `index`'s underlying document into top-level statement byte spans
+ * (terminated by `;` outside strings/comments — see the module doc for why
+ * this is byte-, not line-, precise). Scans the raw UTF-8 `Buffer` directly
+ * (never the decoded JS string): every byte this function compares against
+ * (`'`, `"`, `` ` ``, `$`, `#`, `;`, `-`, `/`, `*`, `\\`, ASCII whitespace) is
+ * single-byte ASCII, and any UTF-8 continuation/multibyte-lead byte is
+ * `>= 0x80` and never matches one of those comparisons — so scanning raw
+ * bytes instead of UTF-16 code units never misreads a multibyte character
+ * (e.g. inside a comment or string) as one of these ASCII control
+ * characters. Das gilt auch für das Überspringen des Zeichens nach einem
+ * `\\`: übersprungen wird ein einzelnes Byte, und die restlichen Bytes
+ * eines Mehrbyte-Zeichens sind `>= 0x80` und lösen selbst nichts aus.
+ *
+ * `dialect` entscheidet über die Escape-Konvention (siehe {@link SqlDialect}).
+ * Falsch geschnittene Ergebnisse bleiben trotzdem möglich — deshalb prüft
+ * `sqlPlausibilityCheck` jedes fertige Fragment nach (WP-118, E4).
+ */
+function splitStatements(index, dialect) {
+    const { buffer } = index;
+    const backslashEscapes = dialect === "backslash-escapes";
+    const backtickIdentifiers = backslashEscapes;
+    const hashLineComments = backslashEscapes;
+    const spans = [];
+    let statementStartByte = 0;
+    let statementHasContent = false;
+    /** Offenes Anführungszeichen (`'`, `"` oder `` ` ``), sonst `undefined`. */
+    let quoteByte;
+    /** Länge des offenen `$tag$`-Etiketts (0 = kein Dollar-Literal offen). */
+    let dollarTagLength = 0;
+    let dollarTagStart = 0;
+    let inLineComment = false;
+    let inBlockComment = false;
+    const flush = (endByteExclusive) => {
+        if (!statementHasContent)
+            return;
+        spans.push({
+            startByte: statementStartByte,
+            endByte: endByteExclusive,
+            startLine: lineNumberForByte(index, statementStartByte),
+            endLine: lineNumberForByte(index, endByteExclusive - 1),
+        });
+    };
+    for (let i = 0; i < buffer.length; i += 1) {
+        const c = buffer[i];
+        const next = buffer[i + 1];
+        if (inBlockComment) {
+            if (c === BYTE_STAR && next === BYTE_SLASH) {
+                inBlockComment = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (inLineComment) {
+            if (c === BYTE_NEWLINE)
+                inLineComment = false;
+            continue;
+        }
+        if (dollarTagLength > 0) {
+            if (c === BYTE_DOLLAR && matchesDollarTag(buffer, i, dollarTagStart, dollarTagLength)) {
+                i += dollarTagLength - 1;
+                dollarTagLength = 0;
+            }
+            statementHasContent = true;
+            continue;
+        }
+        if (quoteByte !== undefined) {
+            // Reihenfolge: erst Backslash (verschluckt AUCH ein direkt folgendes
+            // Anführungszeichen), dann das verdoppelte Anführungszeichen, dann
+            // das schließende. Innerhalb von `` ` `` ist `\` kein Escape — dort
+            // ist die Verdopplung die einzige Konvention.
+            if (backslashEscapes && quoteByte !== BYTE_BACKTICK && c === BYTE_BACKSLASH) {
+                i += 1;
+            }
+            else if (c === quoteByte && next === quoteByte) {
+                i += 1;
+            }
+            else if (c === quoteByte) {
+                quoteByte = undefined;
+            }
+            statementHasContent = true;
+            continue;
+        }
+        if (c === BYTE_DASH && next === BYTE_DASH) {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+        if (hashLineComments && c === BYTE_HASH) {
+            inLineComment = true;
+            continue;
+        }
+        if (c === BYTE_SLASH && next === BYTE_STAR) {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+        const dollarLength = dollarQuoteLength(buffer, i);
+        if (dollarLength > 0) {
+            dollarTagStart = i;
+            dollarTagLength = dollarLength;
+            i += dollarLength - 1;
+            statementHasContent = true;
+            continue;
+        }
+        if (c === BYTE_SINGLE_QUOTE ||
+            c === BYTE_DOUBLE_QUOTE ||
+            (backtickIdentifiers && c === BYTE_BACKTICK)) {
+            quoteByte = c;
+            statementHasContent = true;
+            continue;
+        }
+        if (c === BYTE_SEMICOLON) {
+            const endByteExclusive = extendPastTrailingLineNoise(buffer, i + 1);
+            flush(endByteExclusive);
+            statementStartByte = endByteExclusive;
+            statementHasContent = false;
+            i = endByteExclusive - 1;
+            continue;
+        }
+        if (!isAsciiWhitespaceByte(c)) {
+            statementHasContent = true;
+        }
+    }
+    // A final statement with no terminating `;` (the file's last statement
+    // missing its semicolon) still becomes its own span — never silently
+    // dropped (rule 4 / BUILD_PLAN §12 E4). Trailing whitespace-only content
+    // after the true last `;` reaches here with `statementHasContent` still
+    // `false` and correctly produces no extra span.
+    flush(buffer.length);
+    return spans;
+}
+/**
+ * Trennzeichen-Konventionen für die Plausibilitätsprüfung, abgeleitet aus
+ * demselben Dialekt wie die Zerlegung. Geprüft werden nur runde Klammern —
+ * eckige Klammern sind in manchen Dialekten Bezeichner-Klammern und in
+ * anderen Array-Syntax; sie zu prüfen brächte Fehlalarme statt Befunde.
+ */
+function sqlScanOptions(dialect) {
+    const backslashEscapes = dialect === "backslash-escapes";
+    const quotes = [
+        { open: "'", close: "'", backslashEscapes, doubledEscapes: true, spansLines: true },
+        { open: '"', close: '"', backslashEscapes, doubledEscapes: true, spansLines: true },
+        // Backtick-Bezeichner kennt der Zerleger nur im Backslash-Dialekt, der
+        // Prüfer dagegen IMMER — er darf misstrauischer sein als der Zerleger
+        // (siehe `text/delimiter-balance.ts`). Genau so wird die falsche
+        // Dialektwahl sichtbar: eine Datei mit `` `a;b` `` wird unter
+        // `"doubled-quotes-only"` falsch geschnitten, und beide Fragmente
+        // melden dann einen offenen Backtick, statt still zu bleiben. In
+        // Standard-SQL ist ein einzelner Backtick ohnehin ungültig, ein
+        // Fehlalarm also nicht möglich.
+        { open: "`", close: "`", backslashEscapes: false, doubledEscapes: true, spansLines: true },
+    ];
+    return {
+        quotes,
+        brackets: [{ open: "(", close: ")" }],
+        lineComments: backslashEscapes ? ["--", "#"] : ["--"],
+        blockComment: { open: "/*", close: "*/" },
+        dollarQuotedStrings: true,
+    };
+}
+/**
+ * Die eigentliche Antwort auf WP-118: ein Statement-Fragment mit offener
+ * Zeichenkette, offenem Kommentar oder unausgeglichenen Klammern ist ein
+ * Befund — auch dann, wenn die Byte-Abdeckung lückenlos ist, weil nichts
+ * FEHLT, sondern etwas FALSCH GESCHNITTEN wurde.
+ */
+function sqlPlausibilityCheck(dialect) {
+    const scanOptions = sqlScanOptions(dialect);
+    return (chunk) => {
+        const imbalances = findDelimiterImbalances(chunk.content, scanOptions);
+        return imbalances.length === 0 ? undefined : describeDelimiterImbalances(imbalances);
+    };
+}
+const TABLE_RE = /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:TEMP(?:ORARY)?\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`[]?([\w.]+)["`\]]?/i;
+const VIEW_RE = /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?["`[]?([\w.]+)["`\]]?/i;
+const INDEX_RE = /^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`[]?([\w.]+)["`\]]?\s+ON\s+["`[]?([\w.]+)["`\]]?/i;
+const ALTER_CONSTRAINT_RE = /^\s*ALTER\s+TABLE\s+["`[]?([\w.]+)["`\]]?\s+ADD\s+CONSTRAINT\s+["`[]?([\w.]+)["`\]]?/i;
+/** Strips leading whitespace and leading `--`/`/* *\/` comments so classification regexes only ever see real SQL. */
+function stripLeadingComments(text) {
+    let remaining = text;
+    for (;;) {
+        const trimmed = remaining.replace(/^\s+/, "");
+        if (trimmed.startsWith("--")) {
+            const newlineIndex = trimmed.indexOf("\n");
+            remaining = newlineIndex === -1 ? "" : trimmed.slice(newlineIndex + 1);
+            continue;
+        }
+        if (trimmed.startsWith("/*")) {
+            const closeIndex = trimmed.indexOf("*/");
+            remaining = closeIndex === -1 ? "" : trimmed.slice(closeIndex + 2);
+            continue;
+        }
+        return trimmed;
+    }
+}
+function classify(rawStatementText) {
+    const statementText = stripLeadingComments(rawStatementText);
+    const table = TABLE_RE.exec(statementText);
+    if (table)
+        return { kind: "sql_table", title: table[1] };
+    const view = VIEW_RE.exec(statementText);
+    if (view)
+        return { kind: "sql_view", title: view[1] };
+    const index = INDEX_RE.exec(statementText);
+    if (index)
+        return { kind: "sql_index", title: `${index[1]} ON ${index[2]}` };
+    const constraint = ALTER_CONSTRAINT_RE.exec(statementText);
+    if (constraint)
+        return { kind: "sql_constraint", title: `${constraint[2]} ON ${constraint[1]}` };
+    const firstWord = /^\s*(\w+)/.exec(statementText)?.[1] ?? "statement";
+    return { kind: "sql_statement", title: firstWord.toUpperCase() };
+}
+function sqlDrafts(index, dialect) {
+    return splitStatements(index, dialect).map((span) => {
+        const text = sliceBytes(index, span.startByte, span.endByte);
+        const { kind, title } = classify(text);
+        return {
+            kind,
+            startLine: span.startLine,
+            endLine: span.endLine,
+            title,
+            startByte: span.startByte,
+            endByte: span.endByte,
+        };
+    });
+}
+/** Table name a chunk defines, when its kind is `"sql_table"` — used by `links()`. */
+function tableNameOf(chunk) {
+    return chunk.kind === "sql_table" ? chunk.title : undefined;
+}
+/** `snake_case`/`kebab-case` table name → PascalCase-ish repository class name guess. */
+function guessRepositoryName(tableName) {
+    const bareName = tableName.includes(".") ? tableName.split(".").at(-1) : tableName;
+    const pascal = bareName
+        .split(/[_-]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+    return `${pascal}Repository`;
+}
+export function createSqlAdapter(options = {}) {
+    const dialect = options.dialect ?? DEFAULT_SQL_DIALECT;
+    const checkPlausibility = sqlPlausibilityCheck(dialect);
+    return {
+        supports(type, path) {
+            return type === "sql" || (type === "auto" && SQL_EXTENSION.test(path));
+        },
+        async read(input) {
+            return buildDocuments(input, "sql");
+        },
+        chunk(document) {
+            const index = buildLineIndex(document.content);
+            return buildChunksReportingSkips(document, index, sqlDrafts(index, dialect), options.onSkipLedgerGap, checkPlausibility);
+        },
+        /**
+         * Heuristic-only (architecture.md §20): guesses that table `orders`
+         * has a corresponding `OrdersRepository` code symbol, purely from a
+         * naming convention. `targetId` is deliberately left unset — this
+         * adapter has no code-symbol index to resolve against, only the
+         * repository-adapter graph-linking stage (a different WP) can turn
+         * `targetName` into a real `targetId`. Confidence is fixed and
+         * conservative: this guess is right often enough to be worth surfacing,
+         * wrong often enough that a caller MUST treat it as a hint, never a fact.
+         */
+        links(document) {
+            const index = buildLineIndex(document.content);
+            const chunks = buildChunks(document, index, sqlDrafts(index, dialect));
+            const links = [];
+            for (const chunk of chunks) {
+                const tableName = tableNameOf(chunk);
+                if (tableName === undefined)
+                    continue;
+                links.push({
+                    fromChunkId: chunk.chunkId,
+                    targetKind: "symbol",
+                    targetName: guessRepositoryName(tableName),
+                    heuristic: true,
+                    confidence: 0.4,
+                    note: `naming-convention guess: SQL table "${tableName}" → repository symbol, not a resolved reference`,
+                });
+            }
+            return links;
+        },
+    };
+}
+//# sourceMappingURL=sql.js.map

package/dist/adapters/sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.js","sourceRoot":"","sources":["../../src/adapters/sql.ts"],"names":[],"mappings":"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"}