@untangle-code/parser-registry 0.0.0-stage → 0.1.0

package/dist/languages/prose/index.js

@@ -0,0 +1,172 @@
+import { classifyLinkTarget, findMarkdownLinks, outlineMarkdown, sha256Hex, textFormatExtensions, } from "@untangle-code/domain";
+import { buildLineByteIndex, rangeForLines } from "./line-bytes.js";
+/** Sprachkennung dieses Adapters; identisch mit der Scanner-Klassifikation fuer `.md`. */
+export const PROSE_LANGUAGE_ID = "markdown";
+/** Symbolart eines Prosa-Abschnitts. Ein Abschnitt ist keine Funktion und heisst auch nicht so. */
+export const PROSE_SYMBOL_KIND = "section";
+/** Name des Abschnitts vor der ersten Ueberschrift. */
+const PREAMBLE_NAME = "(Vorspann)";
+/**
+ * Physische Zeilen ohne Zeilenende. Ein abschliessendes `\r` faellt weg,
+ * damit die Ueberschriften- und Verweiserkennung nicht daran scheitert.
+ */
+function splitLines(content) {
+    return content.split("\n").map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+}
+/**
+ * Zwei Abschnitte koennen denselben Breadcrumb tragen (zweimal dieselbe
+ * Ueberschrift unter demselben Elternteil). Der Chunker schluesselt Symbole
+ * ueber `qualifiedName` in einer `Map`; ohne Vereindeutigung wuerde der
+ * zweite Abschnitt den ersten ueberschreiben und beide dieselbe `symbolId`
+ * bekommen. Angehaengt wird deshalb eine laufende Nummer — sichtbar, nicht
+ * still.
+ */
+function uniqueName(breadcrumb, seen) {
+    const base = breadcrumb === "" ? PREAMBLE_NAME : breadcrumb;
+    const count = (seen.get(base) ?? 0) + 1;
+    seen.set(base, count);
+    return count === 1 ? base : `${base} (${String(count)})`;
+}
+function buildSections(lines, index) {
+    const seen = new Map();
+    return outlineMarkdown(lines).map((section) => ({
+        ...section,
+        qualifiedName: uniqueName(section.breadcrumb, seen),
+        range: rangeForLines(index, section.startLine, section.endLine),
+    }));
+}
+function rootOf(ast) {
+    return ast.root;
+}
+function sectionContent(root, section) {
+    return root.lines.slice(section.startLine - 1, section.endLine).join("\n");
+}
+function headingTextOf(section) {
+    return section.level === 0 ? PREAMBLE_NAME : `${"#".repeat(section.level)} ${section.title}`;
+}
+function symbolOf(root, section) {
+    return {
+        name: section.level === 0 ? PREAMBLE_NAME : section.title,
+        qualifiedName: section.qualifiedName,
+        kind: PROSE_SYMBOL_KIND,
+        signature: headingTextOf(section),
+        // Die "Signatur" eines Abschnitts ist seine Ueberschriftenebene plus
+        // Pfad: was ihn im Dokument identifiziert, unabhaengig von seiner Zeile.
+        normalizedSignature: `h${String(section.level)} ${section.qualifiedName}`,
+        range: section.range,
+        exportedNames: [],
+        // Formhash: Ebene und Pfad — aendert sich, wenn der Abschnitt umbenannt
+        // oder verschoben wird, nicht wenn sein Text sich aendert.
+        astHash: sha256Hex(`prose-section ${String(section.level)} ${section.qualifiedName}`),
+        // Inhaltshash: der Rohtext des Abschnitts.
+        tokenFingerprint: sha256Hex(sectionContent(root, section)),
+    };
+}
+export function createProseAdapter() {
+    return {
+        languageId: PROSE_LANGUAGE_ID,
+        extensions: textFormatExtensions("prose"),
+        supportLevel: "text",
+        parse(source) {
+            const lines = splitLines(source.content);
+            const index = buildLineByteIndex(source.content);
+            const root = {
+                fileId: source.fileId,
+                lines,
+                index,
+                sections: buildSections(lines, index),
+            };
+            const ast = {
+                languageId: PROSE_LANGUAGE_ID,
+                parseQuality: "complete",
+                root,
+                diagnostics: [],
+            };
+            return {
+                parseQuality: "complete",
+                ast,
+                diagnostics: [],
+                errorNodeCount: 0,
+                missingNodeCount: 0,
+            };
+        },
+        extractChunks(ast) {
+            const root = rootOf(ast);
+            const children = root.sections.map((section) => ({
+                // Der Vorspann vor der ersten Ueberschrift ist genau das, was
+                // `file_preamble` beschreibt; alles Weitere ist ein Prosa-Abschnitt.
+                chunkKind: section.level === 0 ? "file_preamble" : "prose_section",
+                range: section.range,
+                scopeId: `${root.fileId}#${section.qualifiedName}`,
+                symbolFqn: section.qualifiedName,
+                headerText: section.level === 0
+                    ? PREAMBLE_NAME
+                    : `${"#".repeat(section.level)} ${section.breadcrumb}`,
+                // Ein Abschnitt hat keine feineren AST-Grenzen; ist er zu gross,
+                // teilt der Chunker ihn an Tokengrenzen in `symbol_fragment`s, die
+                // seine `symbolId` erben (spec.md §8.5).
+                splittable: false,
+            }));
+            return [
+                {
+                    chunkKind: "module",
+                    range: {
+                        startLine: 1,
+                        endLine: root.index.lineCount,
+                        startByte: 0,
+                        endByte: root.index.totalBytes,
+                    },
+                    scopeId: root.fileId,
+                    splittable: children.length > 0,
+                    ...(children.length > 0 ? { children } : {}),
+                },
+            ];
+        },
+        extractSymbols(ast) {
+            const root = rootOf(ast);
+            return root.sections.map((section) => symbolOf(root, section));
+        },
+        extractImports(ast) {
+            const root = rootOf(ast);
+            const imports = [];
+            for (const link of findMarkdownLinks(root.lines)) {
+                if (classifyLinkTarget(link.target) !== "relative_file")
+                    continue;
+                imports.push({
+                    specifier: link.target,
+                    importKind: "import",
+                    range: rangeForLines(root.index, link.line, link.line),
+                });
+            }
+            return imports;
+        },
+        extractCalls(_ast) {
+            // Prosa hat keine Aufrufe. Eine leere Liste ist hier die vollstaendige
+            // Antwort, keine Abstufung.
+            return [];
+        },
+        computeComplexity(ast) {
+            // KEINE `symbolScopes` und KEINE `decisions` — siehe Kopfkommentar.
+            // Stuende hier je Abschnitt ein Scope, rechnete jede
+            // Code-Metrik-Pipeline anschliessend `cyclomatic = 1` je Ueberschrift
+            // und addierte das zur Summe des Repositories. Genau das verhindert
+            // diese leere Antwort.
+            return {
+                symbolScopes: [],
+                decisions: [],
+                nestingEvents: [],
+                operators: [],
+                operands: [],
+                nodeKinds: [],
+                comments: [],
+                identifiers: [],
+                literals: [],
+                parseDiagnostics: ast.diagnostics,
+            };
+        },
+        tokenizeForHalstead(_ast) {
+            return { operators: [], operands: [] };
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/languages/prose/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/languages/prose/index.ts"],"names":[],"mappings":"AA4DA,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAsB,MAAM,iBAAiB,CAAC;AAExF,0FAA0F;AAC1F,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;AAE5C,mGAAmG;AACnG,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAC;AAE3C,uDAAuD;AACvD,MAAM,aAAa,GAAG,YAAY,CAAC;AAgBnC;;;GAGG;AACH,SAAS,UAAU,CAAC,OAAe;IACjC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,UAAU,CAAC,UAAkB,EAAE,IAAyB;IAC/D,MAAM,IAAI,GAAG,UAAU,KAAK,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC;IAC5D,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtB,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;AAC3D,CAAC;AAED,SAAS,aAAa,CAAC,KAAwB,EAAE,KAAoB;IACnE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAC9C,GAAG,OAAO;QACV,aAAa,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC;QACnD,KAAK,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC;KAChE,CAAC,CAAC,CAAC;AACN,CAAC;AAED,SAAS,MAAM,CAAC,GAAc;IAC5B,OAAO,GAAG,CAAC,IAAoB,CAAC;AAClC,CAAC;AAED,SAAS,cAAc,CAAC,IAAkB,EAAE,OAAqB;IAC/D,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,GAAG,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,aAAa,CAAC,OAAqB;IAC1C,OAAO,OAAO,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;AAC/F,CAAC;AAED,SAAS,QAAQ,CAAC,IAAkB,EAAE,OAAqB;IACzD,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK;QACzD,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,IAAI,EAAE,iBAAiB;QACvB,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC;QACjC,qEAAqE;QACrE,yEAAyE;QACzE,mBAAmB,EAAE,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,aAAa,EAAE;QACzE,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,aAAa,EAAE,EAAE;QACjB,wEAAwE;QACxE,2DAA2D;QAC3D,OAAO,EAAE,SAAS,CAAC,iBAAiB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;QACrF,2CAA2C;QAC3C,gBAAgB,EAAE,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KAC3D,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,UAAU,EAAE,iBAAiB;QAC7B,UAAU,EAAE,oBAAoB,CAAC,OAAO,CAAC;QACzC,YAAY,EAAE,MAAM;QAEpB,KAAK,CAAC,MAAkB;YACtB,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACzC,MAAM,KAAK,GAAG,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,IAAI,GAAiB;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,KAAK;gBACL,KAAK;gBACL,QAAQ,EAAE,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC;aACtC,CAAC;YACF,MAAM,GAAG,GAAc;gBACrB,UAAU,EAAE,iBAAiB;gBAC7B,YAAY,EAAE,UAAU;gBACxB,IAAI;gBACJ,WAAW,EAAE,EAAE;aAChB,CAAC;YACF,OAAO;gBACL,YAAY,EAAE,UAAU;gBACxB,GAAG;gBACH,WAAW,EAAE,EAAE;gBACf,cAAc,EAAE,CAAC;gBACjB,gBAAgB,EAAE,CAAC;aACpB,CAAC;QACJ,CAAC;QAED,aAAa,CAAC,GAAc;YAC1B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACzB,MAAM,QAAQ,GAAgB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBAC5D,8DAA8D;gBAC9D,qEAAqE;gBACrE,SAAS,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe;gBAClE,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,OAAO,EAAE,GAAG,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,aAAa,EAAE;gBAClD,SAAS,EAAE,OAAO,CAAC,aAAa;gBAChC,UAAU,EACR,OAAO,CAAC,KAAK,KAAK,CAAC;oBACjB,CAAC,CAAC,aAAa;oBACf,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,UAAU,EAAE;gBAC1D,iEAAiE;gBACjE,mEAAmE;gBACnE,yCAAyC;gBACzC,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC,CAAC;YACJ,OAAO;gBACL;oBACE,SAAS,EAAE,QAAQ;oBACnB,KAAK,EAAE;wBACL,SAAS,EAAE,CAAC;wBACZ,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS;wBAC7B,SAAS,EAAE,CAAC;wBACZ,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU;qBAC/B;oBACD,OAAO,EAAE,IAAI,CAAC,MAAM;oBACpB,UAAU,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC;oBAC/B,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBAC7C;aACF,CAAC;QACJ,CAAC;QAED,cAAc,CAAC,GAAc;YAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACzB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;QACjE,CAAC;QAED,cAAc,CAAC,GAAc;YAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACzB,MAAM,OAAO,GAAgB,EAAE,CAAC;YAChC,KAAK,MAAM,IAAI,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACjD,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,eAAe;oBAAE,SAAS;gBAClE,OAAO,CAAC,IAAI,CAAC;oBACX,SAAS,EAAE,IAAI,CAAC,MAAM;oBACtB,UAAU,EAAE,QAAQ;oBACpB,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;iBACvD,CAAC,CAAC;YACL,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,YAAY,CAAC,IAAe;YAC1B,uEAAuE;YACvE,4BAA4B;YAC5B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,iBAAiB,CAAC,GAAc;YAC9B,oEAAoE;YACpE,qDAAqD;YACrD,sEAAsE;YACtE,oEAAoE;YACpE,uBAAuB;YACvB,OAAO;gBACL,YAAY,EAAE,EAAE;gBAChB,SAAS,EAAE,EAAE;gBACb,aAAa,EAAE,EAAE;gBACjB,SAAS,EAAE,EAAE;gBACb,QAAQ,EAAE,EAAE;gBACZ,SAAS,EAAE,EAAE;gBACb,QAAQ,EAAE,EAAE;gBACZ,WAAW,EAAE,EAAE;gBACf,QAAQ,EAAE,EAAE;gBACZ,gBAAgB,EAAE,GAAG,CAAC,WAAW;aAClC,CAAC;QACJ,CAAC;QAED,mBAAmB,CAAC,IAAe;YACjC,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;QACzC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/languages/prose/line-bytes.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Zeilenanfaenge als UTF-8-Byte-Versaetze.
+ *
+ * `SourceRange` (domain `types/common.ts`) ist auf BYTES normativ; die
+ * Prosa-Gliederung arbeitet in ZEILEN. Diese Tabelle ist die Uebersetzung.
+ * Geschnitten wird ausschliesslich unmittelbar nach `\n` (0x0A) — ein
+ * Einzelbyte, nie ein UTF-8-Folgebyte —, damit jede erzeugte Grenze eine
+ * gueltige Zeichengrenze ist.
+ */
+export interface LineByteIndex {
+    /** Byte-Versatz jedes Zeilenanfangs, plus ein Schlusswaechter = Dateigroesse. */
+    readonly lineStarts: readonly number[];
+    /** Anzahl physischer Zeilen. */
+    readonly lineCount: number;
+    readonly totalBytes: number;
+}
+export declare function buildLineByteIndex(content: string): LineByteIndex;
+/** Byte-Versatz des Anfangs der 1-basierten Zeile `line`, geklemmt. */
+export declare function lineStartByte(index: LineByteIndex, line: number): number;
+/**
+ * `SourceRange` fuer die 1-basierte inklusive Zeilenspanne. `endByte` ist der
+ * Anfang der Zeile NACH `endLine`, also sind zwei benachbarte Spannen
+ * lueckenlos und ueberlappungsfrei.
+ */
+export declare function rangeForLines(index: LineByteIndex, startLine: number, endLine: number): {
+    startLine: number;
+    endLine: number;
+    startByte: number;
+    endByte: number;
+};
+//# sourceMappingURL=line-bytes.d.ts.map

package/dist/languages/prose/line-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-bytes.d.ts","sourceRoot":"","sources":["../../../src/languages/prose/line-bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,aAAa;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,gCAAgC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CASjE;AAED,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAO5E"}

package/dist/languages/prose/line-bytes.js

@@ -0,0 +1,39 @@
+/**
+ * Zeilenanfaenge als UTF-8-Byte-Versaetze.
+ *
+ * `SourceRange` (domain `types/common.ts`) ist auf BYTES normativ; die
+ * Prosa-Gliederung arbeitet in ZEILEN. Diese Tabelle ist die Uebersetzung.
+ * Geschnitten wird ausschliesslich unmittelbar nach `\n` (0x0A) — ein
+ * Einzelbyte, nie ein UTF-8-Folgebyte —, damit jede erzeugte Grenze eine
+ * gueltige Zeichengrenze ist.
+ */
+export function buildLineByteIndex(content) {
+    const buffer = Buffer.from(content, "utf8");
+    const lineStarts = [0];
+    for (let i = 0; i < buffer.length; i += 1) {
+        if (buffer[i] === 0x0a)
+            lineStarts.push(i + 1);
+    }
+    const lineCount = lineStarts.length;
+    lineStarts.push(buffer.length);
+    return { lineStarts, lineCount, totalBytes: buffer.length };
+}
+/** Byte-Versatz des Anfangs der 1-basierten Zeile `line`, geklemmt. */
+export function lineStartByte(index, line) {
+    const clamped = Math.min(Math.max(line, 1), index.lineStarts.length);
+    return index.lineStarts[clamped - 1] ?? index.totalBytes;
+}
+/**
+ * `SourceRange` fuer die 1-basierte inklusive Zeilenspanne. `endByte` ist der
+ * Anfang der Zeile NACH `endLine`, also sind zwei benachbarte Spannen
+ * lueckenlos und ueberlappungsfrei.
+ */
+export function rangeForLines(index, startLine, endLine) {
+    return {
+        startLine,
+        endLine,
+        startByte: lineStartByte(index, startLine),
+        endByte: lineStartByte(index, endLine + 1),
+    };
+}
+//# sourceMappingURL=line-bytes.js.map

package/dist/languages/prose/line-bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-bytes.js","sourceRoot":"","sources":["../../../src/languages/prose/line-bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAUH,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,MAAM,UAAU,GAAa,CAAC,CAAC,CAAC,CAAC;IACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI;YAAE,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,CAAC;IACD,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC;IACpC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AAC9D,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,aAAa,CAAC,KAAoB,EAAE,IAAY;IAC9D,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACrE,OAAO,KAAK,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC;AAC3D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAoB,EACpB,SAAiB,EACjB,OAAe;IAEf,OAAO;QACL,SAAS;QACT,OAAO;QACP,SAAS,EAAE,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC;QAC1C,OAAO,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC;KAC3C,CAAC;AACJ,CAAC"}

package/dist/languages/python/create-adapter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Der Python-`LanguageAdapter`: die Tabelle aus `table.ts` und die
+ * Verfeinerung aus `profile.ts` durch das gemeinsame ast-grep-Backend.
+ *
+ * WAS HIER FRUEHER STAND (WP-239): dieselbe Datei verdrahtete einen eigenen
+ * Tokenizer, einen eigenen rekursiven Abstiegsparser, einen eigenen AST und
+ * einen eigenen Motor — 5.604 Zeilen, die es nur gab, weil eine Auftragsgrenze
+ * das Aufnehmen einer Grammatik verbot. Sie sind ersatzlos entfallen; was
+ * bleibt, ist `signature.ts` (reine Textnormalisierung, ohne AST) und die
+ * Tabelle daneben.
+ *
+ * DIE PARSERVERSION HAT SICH GEAENDERT, und das steht in domain
+ * `versions.ts`: Python laeuft ab jetzt unter `ASTGREP_PARSER_VERSION`. Ohne
+ * diesen Wechsel lieferten die inhaltsadressierten Caches aus WP-100 nach dem
+ * Backendwechsel stillschweigend Chunk-IDs und Fingerabdruecke der alten
+ * AST-Form (E4).
+ */
+import type { LanguageAdapter } from "@untangle-code/domain";
+export declare function createPythonAdapter(): LanguageAdapter;
+//# sourceMappingURL=create-adapter.d.ts.map

package/dist/languages/python/create-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-adapter.d.ts","sourceRoot":"","sources":["../../../src/languages/python/create-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAO7D,wBAAgB,mBAAmB,IAAI,eAAe,CAIrD"}

package/dist/languages/python/create-adapter.js

@@ -0,0 +1,9 @@
+import { createAstGrepAdapter } from "../astgrep-backend/index.js";
+import { createPythonProfile } from "./profile.js";
+import { PYTHON_SOURCE, PYTHON_TABLE } from "./table.js";
+export function createPythonAdapter() {
+    return createAstGrepAdapter(PYTHON_TABLE, PYTHON_SOURCE, {
+        profileForFile: createPythonProfile,
+    });
+}
+//# sourceMappingURL=create-adapter.js.map

package/dist/languages/python/create-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-adapter.js","sourceRoot":"","sources":["../../../src/languages/python/create-adapter.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEzD,MAAM,UAAU,mBAAmB;IACjC,OAAO,oBAAoB,CAAC,YAAY,EAAE,aAAa,EAAE;QACvD,cAAc,EAAE,mBAAmB;KACpC,CAAC,CAAC;AACL,CAAC"}

package/dist/languages/python/index.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageAdapter } from "@untangle-code/domain";
+/** Python `LanguageAdapter` (`.py`, `.pyi`), support level "deep" (spec.md §7.2, WP-09). */
+export declare function createPythonAdapter(): LanguageAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/languages/python/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/languages/python/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,4FAA4F;AAC5F,wBAAgB,mBAAmB,IAAI,eAAe,CAErD"}

package/dist/languages/python/index.js

@@ -0,0 +1,6 @@
+import { createPythonAdapter as createPythonAdapterImpl } from "./create-adapter.js";
+/** Python `LanguageAdapter` (`.py`, `.pyi`), support level "deep" (spec.md §7.2, WP-09). */
+export function createPythonAdapter() {
+    return createPythonAdapterImpl();
+}
+//# sourceMappingURL=index.js.map

package/dist/languages/python/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/languages/python/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,IAAI,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAErF,4FAA4F;AAC5F,MAAM,UAAU,mBAAmB;IACjC,OAAO,uBAAuB,EAAE,CAAC;AACnC,CAAC"}

package/dist/languages/python/profile.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Die Python-Regeln, die KEINE Tabelle ausdrueckt.
+ *
+ * Alles Uebrige — Entscheidungen, Nesting, Kommentare, Halstead-Token,
+ * Aufrufe, Scopes — kommt aus `table.ts` durch den gemeinsamen Motor
+ * (`shared/table-profile.ts`, `shared/engine.ts`). Hier steht nur, was
+ * Python anders macht als jede andere Sprache dieses Projekts:
+ *
+ *  1. DOCSTRINGS. Python bindet die Beschreibung nicht an einen Kommentar VOR
+ *     der Definition, sondern an die erste Anweisung IM Rumpf.
+ *  2. SICHTBARKEIT. Es gibt keinen Modifikator; sie steht in der
+ *     Namenskonvention (`_x` geschuetzt, `__x` privat, `__x__` oeffentlich).
+ *  3. `__all__`. Was eine Datei exportiert, steht in einer Zuweisung auf
+ *     Modulebene — also je DATEI, nicht je Knoten. Deshalb wird dieses Profil
+ *     je Parse gebaut (`AstGrepAdapterHooks.profileForFile`) und nicht einmal
+ *     je Adapter.
+ *  4. METHODE ODER FUNKTION. `def` ist beides; welches, sagt erst der
+ *     umgebende Knoten. Eine Tabelle bildet Knotenart auf Scope-Art ab und
+ *     kann das nicht.
+ *  5. IMPORTE. Eine Anweisung fuehrt mehrere Ziele mit je eigenem Alias
+ *     (`from a import b as c, d`) — `ImportRules` kennt genau eines.
+ *  6. SIGNATUREN. Die Normalform folgt `signature.ts` (Vorgabewerte fallen
+ *     weg, Annotationen bleiben) und nicht der Rohtextregel der Tabelle.
+ *  7. ZEICHENKETTEN. Ein `string` ist hier KEIN geschlossener Container
+ *     (siehe `table.ts`); seine Textblaetter muessen deshalb ausdruecklich
+ *     als Zeichenkettenliterale gelten.
+ */
+import type { SourceFile } from "@untangle-code/domain";
+import type { LanguageProfile } from "../shared/profile.js";
+import type { SyntaxNode } from "../shared/syntax.js";
+/**
+ * Baut das Python-Profil ueber dem Tabellenprofil — EINMAL JE DATEI, weil
+ * `__all__` und `__init__.py` Dateieigenschaften sind.
+ */
+export declare function createPythonProfile(base: LanguageProfile, root: SyntaxNode, file: SourceFile): LanguageProfile;
+//# sourceMappingURL=profile.d.ts.map

package/dist/languages/python/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../src/languages/python/profile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAA0B,UAAU,EAAe,MAAM,uBAAuB,CAAC;AAK7F,OAAO,KAAK,EAAE,eAAe,EAAkC,MAAM,sBAAsB,CAAC;AAE5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAyOtD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACf,eAAe,CAiEjB"}

package/dist/languages/python/profile.js

@@ -0,0 +1,282 @@
+import { rangeOf } from "../shared/node-utils.js";
+import { normalizeHeaderText, normalizeParameterList, normalizeReturnType } from "./signature.js";
+import { PYTHON_STRING_LEAF_KINDS } from "./table.js";
+const INIT_FILE_RE = /(^|\/)__init__\.pyi?$/;
+const STRING_LEAF_KINDS = new Set(PYTHON_STRING_LEAF_KINDS);
+/** Knotenarten, die einen eigenen Namensraum aufmachen — die Grenze fuer "steht in einer Klasse". */
+const SCOPE_OPENING_KINDS = new Set([
+    "function_definition",
+    "class_definition",
+    "lambda",
+]);
+// ---------------------------------------------------------------------------
+// 2. Sichtbarkeit aus der Namenskonvention (PEP 8)
+// ---------------------------------------------------------------------------
+/**
+ * `__x__` ist das oeffentliche Protokoll (`__init__`, `__len__`) und bekommt
+ * deshalb GAR KEINE Angabe — nicht "public": das Feld ist optional, und
+ * "keine Angabe" ist die ehrliche Aussage ueber eine Sprache ohne
+ * Sichtbarkeitsmodifikatoren.
+ */
+function pythonVisibility(name) {
+    if (name.startsWith("__") && name.endsWith("__") && name.length > 4)
+        return undefined;
+    if (name.startsWith("__"))
+        return "private";
+    if (name.startsWith("_"))
+        return "protected";
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// 1. Docstrings
+// ---------------------------------------------------------------------------
+/** Der Text eines Zeichenkettenknotens ohne Anfuehrungszeichen (auch dreifache). */
+function stringLiteralText(node) {
+    if (node.type !== "string")
+        return null;
+    for (const child of node.children) {
+        if (child.type === "string_content")
+            return child.text;
+    }
+    return "";
+}
+/**
+ * Der Docstring eines Scopes: die erste Anweisung des Rumpfes, wenn sie aus
+ * nichts als einem Zeichenkettenliteral besteht. Alles andere ist Code, und
+ * ein Stueck Code als Beschreibung auszugeben waere eine Erfindung.
+ */
+function docstringRange(node, ctx, bodyField) {
+    const body = node.childForFieldName(bodyField);
+    if (body === null)
+        return undefined;
+    const first = body.namedChild(0);
+    if (first === null || first.type !== "expression_statement")
+        return undefined;
+    const expression = first.namedChild(0);
+    if (expression === null || stringLiteralText(expression) === null)
+        return undefined;
+    return rangeOf(expression, ctx);
+}
+// ---------------------------------------------------------------------------
+// 3. `__all__`
+// ---------------------------------------------------------------------------
+/**
+ * Die Namen aus `__all__ = [...]` auf Modulebene, oder `null`, wenn die Datei
+ * keines hat. `null` und nicht "leere Menge": ohne `__all__` gilt die
+ * Unterstrich-Konvention, mit leerem `__all__` exportiert die Datei nichts.
+ * Die beiden Faelle zu vermengen hiesse, jede Datei ohne `__all__` fuer
+ * exportlos zu erklaeren.
+ */
+function findDunderAll(root) {
+    for (const statement of root.children) {
+        if (statement.type !== "expression_statement")
+            continue;
+        const assignment = statement.namedChild(0);
+        if (assignment === null || assignment.type !== "assignment")
+            continue;
+        const left = assignment.childForFieldName("left");
+        if (left === null || left.type !== "identifier" || left.text !== "__all__")
+            continue;
+        const right = assignment.childForFieldName("right");
+        if (right === null ||
+            (right.type !== "list" && right.type !== "tuple" && right.type !== "set")) {
+            continue;
+        }
+        const names = new Set();
+        for (const element of right.children) {
+            const text = stringLiteralText(element);
+            if (text !== null)
+                names.add(text);
+        }
+        return names;
+    }
+    return null;
+}
+/** Steht dieser Knoten unmittelbar auf Modulebene (auch unter einem Dekorator)? */
+function isTopLevel(node) {
+    const parent = node.parent;
+    if (parent === null)
+        return false;
+    if (parent.type === "module")
+        return true;
+    return parent.type === "decorated_definition" && parent.parent?.type === "module";
+}
+// ---------------------------------------------------------------------------
+// 4. Methode oder Funktion
+// ---------------------------------------------------------------------------
+/** Der naechste umschliessende Knoten, der selbst einen Namensraum oeffnet. */
+function enclosingScopeKind(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (SCOPE_OPENING_KINDS.has(current.type))
+            return current.type;
+        current = current.parent;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 5. Importe
+// ---------------------------------------------------------------------------
+/** Ziel und Alias eines einzelnen Importeintrags (`os.path as osp`, `helper`). */
+function importEntryOf(node) {
+    if (node.type === "dotted_name")
+        return { path: node.text };
+    if (node.type !== "aliased_import")
+        return null;
+    const path = node.childForFieldName("name");
+    const alias = node.childForFieldName("alias");
+    if (path === null)
+        return null;
+    return { path: path.text, ...(alias === null ? {} : { alias: alias.text }) };
+}
+/**
+ * `import a, b as c` — jedes Ziel ist ein eigener Import mit eigenem Pfad.
+ * `from m import a, b as c` — EIN Pfad (`m`) mit mehreren gebundenen Namen.
+ * Zwei Formen, deshalb zwei Zweige und keine gemeinsame Schleife, die beide
+ * halb falsch bedient.
+ */
+function collectPythonImports(node, ctx, sink, isInitFile) {
+    const range = rangeOf(node, ctx);
+    // spec.md §6.2: was ein Paketkopf (`__init__.py`) auf oberster Ebene
+    // hereinholt, reicht er weiter — das ist ein Re-Export, kein Verbrauch.
+    const importKind = isInitFile && isTopLevel(node) ? "re_export" : "import";
+    if (node.type === "import_statement") {
+        for (const child of node.children) {
+            const entry = importEntryOf(child);
+            if (entry === null)
+                continue;
+            sink.imports.push({
+                specifier: entry.path,
+                importKind,
+                range,
+                ...(entry.alias === undefined ? {} : { importedNames: [entry.alias] }),
+            });
+        }
+        return;
+    }
+    const moduleNode = node.childForFieldName("module_name");
+    if (moduleNode === null)
+        return;
+    const importedNames = [];
+    // Die gebundenen Namen stehen NACH dem Schluesselwort `import`; davor steht
+    // der Modulpfad, der genauso aussieht. Ohne diese Schranke stuende
+    // `collections` bei `from collections import x` als importierter Name da.
+    let afterKeyword = false;
+    for (const child of node.children) {
+        if (child.type === "import") {
+            afterKeyword = true;
+            continue;
+        }
+        if (!afterKeyword)
+            continue;
+        // `from m import *` bindet unbekannt viele Namen. KEINEN zu nennen ist
+        // die einzige ehrliche Antwort (domain `analysis.ts`: ein fehlendes Feld
+        // heisst "unbekannt").
+        const entry = importEntryOf(child);
+        if (entry !== null)
+            importedNames.push(entry.alias ?? entry.path);
+    }
+    sink.imports.push({
+        specifier: moduleNode.text,
+        importKind,
+        range,
+        ...(importedNames.length > 0 ? { importedNames } : {}),
+    });
+}
+// ---------------------------------------------------------------------------
+// 6. Signaturen
+// ---------------------------------------------------------------------------
+function headerBeforeBody(node, bodyField) {
+    const body = node.childForFieldName(bodyField);
+    if (body === null)
+        return node.text.split("\n")[0]?.trim() ?? node.text;
+    return node.text.slice(0, Math.max(0, body.startIndex - node.startIndex)).trimEnd();
+}
+function pythonSignature(node, name, bodyField) {
+    if (node.type === "class_definition") {
+        const raw = headerBeforeBody(node, bodyField);
+        return { raw, normalized: normalizeHeaderText(raw) };
+    }
+    const parameters = node.childForFieldName("parameters");
+    // `lambda_parameters` traegt KEINE Klammern; `parameters` traegt sie. Beide
+    // muessen als `(...)` in die Normalform, sonst zerfaellt die Aufteilung.
+    const parametersText = parameters === null
+        ? "()"
+        : parameters.text.trim().startsWith("(")
+            ? parameters.text
+            : `(${parameters.text})`;
+    const returnType = node.childForFieldName("return_type");
+    // `async` ist ein anonymes Kind, kein Feld — und es gehoert zur
+    // Aufrufschnittstelle: eine Koroutine ist nicht dasselbe wie eine Funktion.
+    const isAsync = node.children.some((child) => child.type === "async");
+    const head = `${isAsync ? "async " : ""}${name}`;
+    const raw = `${head}${parametersText}${returnType === null ? "" : ` -> ${returnType.text}`}`;
+    const normalized = `${head}${normalizeParameterList(parametersText)}${normalizeReturnType(returnType?.text)}`;
+    return { raw, normalized };
+}
+// ---------------------------------------------------------------------------
+/**
+ * Baut das Python-Profil ueber dem Tabellenprofil — EINMAL JE DATEI, weil
+ * `__all__` und `__init__.py` Dateieigenschaften sind.
+ */
+export function createPythonProfile(base, root, file) {
+    const dunderAll = findDunderAll(root);
+    const isInitFile = INIT_FILE_RE.test(file.path.replace(/\\/g, "/"));
+    const bodyField = "body";
+    return {
+        ...base,
+        // 7. Zeichenkettenblaetter (siehe `table.ts`: `string` ist kein Container).
+        simpleLiteralLeafKinds: new Set([...base.simpleLiteralLeafKinds, ...STRING_LEAF_KINDS]),
+        simpleLiteralKind(kind) {
+            return STRING_LEAF_KINDS.has(kind) ? "string" : base.simpleLiteralKind(kind);
+        },
+        // Der Dekorator gehoert zum Symbol: `@app.route(...)` steht ueber der
+        // Funktion und beschreibt sie. `chunks.ts` weitet den Bereich darauf aus.
+        exportWrapperKinds: new Set(["decorated_definition"]),
+        // 4. `def` ist Funktion, Methode oder Konstruktor.
+        scopeKindOf(node) {
+            const kind = base.scopeKindOf(node);
+            if (kind !== "function" || node.type !== "function_definition")
+                return kind;
+            if (enclosingScopeKind(node) !== "class_definition")
+                return "function";
+            return base.scopeName(node) === "__init__" ? "constructor" : "method";
+        },
+        scopeSignature(node, _kind, name) {
+            return pythonSignature(node, name, bodyField);
+        },
+        docRange: (node, ctx) => docstringRange(node, ctx, bodyField),
+        visibility: (_node, name) => pythonVisibility(name),
+        // 3. `__all__` schlaegt die Unterstrich-Konvention. Beides gilt nur fuer
+        // Namen auf Modulebene: eine Methode wird nicht aus der Datei exportiert.
+        exportedNames(node, name) {
+            if (!isTopLevel(node))
+                return [];
+            if (dunderAll !== null)
+                return dunderAll.has(name) ? [name] : [];
+            return name.startsWith("_") ? [] : [name];
+        },
+        detectDecisionAndNesting(node) {
+            const detected = base.detectDecisionAndNesting(node);
+            // `union_pattern` ist FLACH: `case 1 | 2 | 3` ist EIN Knoten mit drei
+            // Zweigen, waehrend Rusts `or_pattern` fuer dasselbe zwei verschachtelte
+            // Knoten baut. Ohne diese Zahl kostete `1 | 2 | 3` so viel wie `1 | 2`.
+            if (node.type !== "union_pattern" || detected.decision === undefined)
+                return detected;
+            const alternatives = node.namedChildCount;
+            if (alternatives <= 1)
+                return detected;
+            return { ...detected, decision: { ...detected.decision, repeat: alternatives - 1 } };
+        },
+        collectModuleFacts(node, kind, callerScopeId, ctx, sink) {
+            if (kind === "import_statement" ||
+                kind === "import_from_statement" ||
+                kind === "future_import_statement") {
+                collectPythonImports(node, ctx, sink, isInitFile);
+                return;
+            }
+            base.collectModuleFacts(node, kind, callerScopeId, ctx, sink);
+        },
+    };
+}
+//# sourceMappingURL=profile.js.map