@gitwand/core 2.2.0 → 2.4.1

package/dist/structural/index.js

@@ -0,0 +1,177 @@
+/**
+ * @gitwand/core v2.3 — Structural (AST-based) merge dispatcher
+ *
+ * Provides `tryStructuralMergeResolve()`, an async entry point that:
+ *
+ * 1. Reconstructs the three file versions (base/ours/theirs) from the
+ *    Git conflict markers in the conflicted content.
+ * 2. Parses each version with tree-sitter (via `web-tree-sitter`, optional peer).
+ * 3. Extracts top-level entities and matches them across the three versions.
+ * 4. Merges entities individually — only auto-resolvable conflicts are handled.
+ * 5. Reconstructs the merged file following theirs entity order.
+ *
+ * Returns `null` (never throws) when:
+ * - `web-tree-sitter` is not installed (graceful degradation)
+ * - The grammar WASM file is unavailable
+ * - Any version has parse errors
+ * - Any entity has a real (both-changed-diff) conflict
+ *
+ * In all these cases the caller falls back to the standard hunk-based resolver.
+ */
+import { parseConflictMarkers } from "../parser.js";
+import { validateMergedContent } from "../resolver/validation.js";
+import { loadGrammarForFile } from "./parsers/grammars/ts.js";
+import { createParser } from "./parsers/loader.js";
+import { extractEntities, hasParseErrors } from "./entities.js";
+import { matchEntities } from "./matching.js";
+import { mergeEntity, hasEntityConflict } from "./merge.js";
+import { reconstructFile } from "./reconstruct.js";
+import { isStructuralLanguage } from "./parsers/grammars/languages.js";
+export { isStructuralLanguage };
+// ─── Backward-compat alias ────────────────────────────────────────────────────
+/**
+ * Returns `true` for `.ts` and `.tsx` files.
+ * @deprecated Use `isStructuralLanguage` — now covers JS/JSX/Python/Go/Rust too.
+ */
+export function isTypeScriptFile(filePath) {
+    return /\.(ts|tsx)$/i.test(filePath) && !/\.d\.ts$/i.test(filePath);
+}
+/**
+ * Reconstruct the three clean file versions from a conflicted file.
+ *
+ * - `ours`   = text segments + ours lines from each conflict hunk
+ * - `theirs` = text segments + theirs lines from each conflict hunk
+ * - `base`   = text segments + base lines (diff3) or ours lines (diff2 fallback)
+ */
+function reconstructVersions(conflictedContent) {
+    const { segments } = parseConflictMarkers(conflictedContent);
+    const oursLines = [];
+    const theirsLines = [];
+    const baseLines = [];
+    for (const seg of segments) {
+        if (seg.type === "text") {
+            oursLines.push(...seg.lines);
+            theirsLines.push(...seg.lines);
+            baseLines.push(...seg.lines);
+        }
+        else {
+            const { conflict } = seg;
+            oursLines.push(...conflict.oursLines);
+            theirsLines.push(...conflict.theirsLines);
+            // Use diff3 base if available; fall back to ours (conservative)
+            baseLines.push(...(conflict.baseLines.length > 0 ? conflict.baseLines : conflict.oursLines));
+        }
+    }
+    return {
+        base: baseLines.join("\n"),
+        ours: oursLines.join("\n"),
+        theirs: theirsLines.join("\n"),
+    };
+}
+// ─── Main entry point ─────────────────────────────────────────────────────────
+/**
+ * Attempt structural (AST-based) merge resolution for a TypeScript/TSX file.
+ *
+ * @param conflictedContent - File content with Git conflict markers
+ * @param filePath          - File path (grammar selection + type detection)
+ * @param opts              - Optional loader overrides (WASM paths, custom loaders)
+ * @returns Merged content string on success, `null` on any failure
+ */
+export async function tryStructuralMergeResolve(conflictedContent, filePath, opts = {}) {
+    // Only handle supported languages
+    if (!isStructuralLanguage(filePath))
+        return null;
+    // Load tree-sitter grammar (returns null if optional peer not installed)
+    const language = await loadGrammarForFile(filePath, opts);
+    if (!language)
+        return null;
+    // Create parser
+    const parser = await createParser(language, opts);
+    if (!parser)
+        return null;
+    // Reconstruct the three file versions
+    const { base, ours, theirs } = reconstructVersions(conflictedContent);
+    // Parse all three versions
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const p = parser;
+    const [baseTree, oursTree, theirsTree] = [base, ours, theirs].map((src) => p.parse(src));
+    // Abort on parse errors in any version
+    if (hasParseErrors(baseTree) || hasParseErrors(oursTree) || hasParseErrors(theirsTree)) {
+        return null;
+    }
+    // Extract top-level entities
+    const baseEntities = extractEntities(baseTree, base);
+    const oursEntities = extractEntities(oursTree, ours);
+    const theirsEntities = extractEntities(theirsTree, theirs);
+    // 3-way entity matching
+    const matches = matchEntities(baseEntities, oursEntities, theirsEntities);
+    // Entity-level merge decisions
+    const merges = matches.map(mergeEntity);
+    // Abort if any entity has a real conflict
+    if (hasEntityConflict(merges))
+        return null;
+    // Reconstruct the merged file
+    const mergedContent = reconstructFile(merges, theirsEntities, oursEntities, theirs);
+    return mergedContent;
+}
+// ─── MergeResult wrapper ──────────────────────────────────────────────────────
+/**
+ * Wrap a structurally merged content string in a `MergeResult` object.
+ *
+ * All hunks are marked as auto-resolved via the "structural-merge" resolver.
+ * This keeps the return type compatible with the synchronous `resolve()`.
+ */
+export function wrapStructuralResult(conflictedContent, mergedContent, filePath) {
+    const { segments } = parseConflictMarkers(conflictedContent);
+    const hunks = segments
+        .filter((s) => s.type === "conflict")
+        .map((s) => ({
+        baseLines: s.conflict.baseLines,
+        oursLines: s.conflict.oursLines,
+        theirsLines: s.conflict.theirsLines,
+        startLine: s.conflict.startLine,
+        type: "complex",
+        confidence: {
+            score: 100,
+            label: "certain",
+            dimensions: {
+                typeClassification: 100,
+                dataRisk: 0,
+                scopeImpact: 0,
+                fileFrequency: 0,
+                baseAvailability: s.conflict.baseLines.length > 0 ? 100 : 0,
+            },
+            boosters: ["structural-merge"],
+            penalties: [],
+        },
+        explanation: "Résolu via merge structurel (tree-sitter AST)",
+        trace: {
+            steps: [],
+            selected: "complex",
+            summary: "Résolu via analyse structurelle AST — merge par entités TypeScript",
+            hasBase: s.conflict.baseLines.length > 0,
+        },
+    }));
+    const resolutions = hunks.map((hunk) => ({
+        hunk,
+        resolvedLines: null,
+        autoResolved: true,
+        resolutionReason: "structural-merge: résolu via analyse AST tree-sitter",
+    }));
+    const byType = hunks.length > 0 ? { complex: hunks.length } : {};
+    const validation = validateMergedContent(mergedContent, filePath);
+    return {
+        filePath,
+        mergedContent,
+        hunks,
+        resolutions,
+        stats: {
+            totalConflicts: hunks.length,
+            autoResolved: hunks.length,
+            remaining: 0,
+            byType,
+        },
+        validation,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/structural/index.js.map

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

package/dist/structural/matching.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 3-way entity matching for structural merge.
+ *
+ * Matches top-level entities across the three file versions (base / ours /
+ * theirs) using their `signature` as a stable key. Each entity triple is
+ * assigned a status that describes what happened to it during the merge.
+ */
+import type { TopLevelEntity } from "./entities.js";
+export type EntityMatchStatus = 
+/** Text identical in all three versions */
+"unchanged"
+/** Changed in ours, unchanged in theirs */
+ | "ours-only-change"
+/** Changed in theirs, unchanged in ours */
+ | "theirs-only-change"
+/** Both sides made the same change (or both deleted) */
+ | "both-changed-same"
+/** Both sides changed differently — unresolvable at entity level */
+ | "both-changed-diff"
+/** Added only by ours (not in base, not in theirs) */
+ | "ours-added"
+/** Added only by theirs (not in base, not in ours) */
+ | "theirs-added"
+/** Deleted by ours (was in base and theirs) */
+ | "ours-deleted"
+/** Deleted by theirs (was in base and ours) */
+ | "theirs-deleted";
+export interface EntityMatch {
+    signature: string;
+    status: EntityMatchStatus;
+    base: TopLevelEntity | null;
+    ours: TopLevelEntity | null;
+    theirs: TopLevelEntity | null;
+}
+/**
+ * Compute 3-way entity matches between base, ours, and theirs.
+ *
+ * The returned array covers every unique signature found across all three
+ * versions. Order follows: base order → ours-only → theirs-only sigs.
+ *
+ * @param base   - Entities extracted from the base (ancestor) version
+ * @param ours   - Entities extracted from our version (current branch)
+ * @param theirs - Entities extracted from their version (incoming branch)
+ */
+export declare function matchEntities(base: TopLevelEntity[], ours: TopLevelEntity[], theirs: TopLevelEntity[]): EntityMatch[];
+//# sourceMappingURL=matching.d.ts.map

package/dist/structural/matching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matching.d.ts","sourceRoot":"","sources":["../../src/structural/matching.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAIpD,MAAM,MAAM,iBAAiB;AAC3B,2CAA2C;AACzC,WAAW;AACb,2CAA2C;GACzC,kBAAkB;AACpB,2CAA2C;GACzC,oBAAoB;AACtB,wDAAwD;GACtD,mBAAmB;AACrB,oEAAoE;GAClE,mBAAmB;AACrB,sDAAsD;GACpD,YAAY;AACd,sDAAsD;GACpD,cAAc;AAChB,+CAA+C;GAC7C,cAAc;AAChB,+CAA+C;GAC7C,gBAAgB,CAAC;AAErB,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IAC5B,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;CAC/B;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,cAAc,EAAE,EACtB,IAAI,EAAE,cAAc,EAAE,EACtB,MAAM,EAAE,cAAc,EAAE,GACvB,WAAW,EAAE,CA8Bf"}

package/dist/structural/matching.js

@@ -0,0 +1,83 @@
+/**
+ * 3-way entity matching for structural merge.
+ *
+ * Matches top-level entities across the three file versions (base / ours /
+ * theirs) using their `signature` as a stable key. Each entity triple is
+ * assigned a status that describes what happened to it during the merge.
+ */
+// ─── Internal ─────────────────────────────────────────────────────────────────
+function classifyMatch(base, ours, theirs) {
+    const inBase = base !== null;
+    const inOurs = ours !== null;
+    const inTheirs = theirs !== null;
+    // Not in base → newly added in this merge
+    if (!inBase) {
+        if (inOurs && inTheirs) {
+            return ours.text === theirs.text ? "both-changed-same" : "both-changed-diff";
+        }
+        if (inOurs)
+            return "ours-added";
+        if (inTheirs)
+            return "theirs-added";
+        // Unreachable: signature would not be in allSigs without being in at least one version
+        return "unchanged";
+    }
+    // Entity present in base — did ours/theirs change or delete it?
+    const inBothMissing = !inOurs && !inTheirs;
+    if (inBothMissing)
+        return "both-changed-same"; // both deleted = same outcome
+    if (!inOurs)
+        return "ours-deleted";
+    if (!inTheirs)
+        return "theirs-deleted";
+    const oursChanged = ours.text !== base.text;
+    const theirsChanged = theirs.text !== base.text;
+    if (!oursChanged && !theirsChanged)
+        return "unchanged";
+    if (oursChanged && !theirsChanged)
+        return "ours-only-change";
+    if (!oursChanged && theirsChanged)
+        return "theirs-only-change";
+    // Both changed
+    return ours.text === theirs.text ? "both-changed-same" : "both-changed-diff";
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Compute 3-way entity matches between base, ours, and theirs.
+ *
+ * The returned array covers every unique signature found across all three
+ * versions. Order follows: base order → ours-only → theirs-only sigs.
+ *
+ * @param base   - Entities extracted from the base (ancestor) version
+ * @param ours   - Entities extracted from our version (current branch)
+ * @param theirs - Entities extracted from their version (incoming branch)
+ */
+export function matchEntities(base, ours, theirs) {
+    const baseMap = new Map(base.map((e) => [e.signature, e]));
+    const oursMap = new Map(ours.map((e) => [e.signature, e]));
+    const theirsMap = new Map(theirs.map((e) => [e.signature, e]));
+    // Collect all signatures, preserving a sensible order (base → ours-only → theirs-only)
+    const seen = new Set();
+    const orderedSigs = [];
+    for (const map of [baseMap, oursMap, theirsMap]) {
+        for (const sig of map.keys()) {
+            if (!seen.has(sig)) {
+                seen.add(sig);
+                orderedSigs.push(sig);
+            }
+        }
+    }
+    return orderedSigs.map((sig) => {
+        const b = baseMap.get(sig) ?? null;
+        const o = oursMap.get(sig) ?? null;
+        const t = theirsMap.get(sig) ?? null;
+        return {
+            signature: sig,
+            status: classifyMatch(b, o, t),
+            base: b,
+            ours: o,
+            theirs: t,
+        };
+    });
+}
+//# sourceMappingURL=matching.js.map

package/dist/structural/matching.js.map

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

package/dist/structural/merge.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Entity-level merge decisions for structural merge.
+ *
+ * Given a 3-way entity match, decides which text version to use in the
+ * merged output. Conservative by design: if both sides changed an entity
+ * differently, we return a "conflict" result and abort the structural merge
+ * for the whole file (falling back to the hunk-based resolver).
+ */
+import type { EntityMatch } from "./matching.js";
+export interface EntityMergeResult {
+    signature: string;
+    /**
+     * Whether this entity should appear in the merged output.
+     * `false` means the entity was deleted by ours, theirs, or both.
+     */
+    include: boolean;
+    /**
+     * The text to emit for this entity in the merged file.
+     * `null` signals an unresolvable conflict (structural merge aborted).
+     */
+    mergedText: string | null;
+    /** Human-readable explanation of the merge decision */
+    reason: string;
+}
+/**
+ * Decide how to merge a single entity based on its 3-way match status.
+ *
+ * Rules (conservative, correct-by-default):
+ * - unchanged            → emit as-is
+ * - both-changed-same    → emit the common changed version
+ * - ours-only-change     → emit ours
+ * - theirs-only-change   → emit theirs
+ * - ours-added           → emit ours (append after theirs structure)
+ * - theirs-added         → emit theirs
+ * - ours-deleted         → omit (unless theirs also modified it → conflict)
+ * - theirs-deleted       → omit (unless ours also modified it → conflict)
+ * - both-changed-diff    → conflict (return mergedText: null → abort)
+ */
+export declare function mergeEntity(match: EntityMatch): EntityMergeResult;
+/**
+ * Returns `true` if any entity merge has an unresolvable conflict
+ * (i.e. the structural merge cannot produce a clean output).
+ */
+export declare function hasEntityConflict(merges: EntityMergeResult[]): boolean;
+//# sourceMappingURL=merge.d.ts.map

package/dist/structural/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/structural/merge.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;CAChB;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,iBAAiB,CAwGjE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAEtE"}

package/dist/structural/merge.js

@@ -0,0 +1,127 @@
+/**
+ * Entity-level merge decisions for structural merge.
+ *
+ * Given a 3-way entity match, decides which text version to use in the
+ * merged output. Conservative by design: if both sides changed an entity
+ * differently, we return a "conflict" result and abort the structural merge
+ * for the whole file (falling back to the hunk-based resolver).
+ */
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Decide how to merge a single entity based on its 3-way match status.
+ *
+ * Rules (conservative, correct-by-default):
+ * - unchanged            → emit as-is
+ * - both-changed-same    → emit the common changed version
+ * - ours-only-change     → emit ours
+ * - theirs-only-change   → emit theirs
+ * - ours-added           → emit ours (append after theirs structure)
+ * - theirs-added         → emit theirs
+ * - ours-deleted         → omit (unless theirs also modified it → conflict)
+ * - theirs-deleted       → omit (unless ours also modified it → conflict)
+ * - both-changed-diff    → conflict (return mergedText: null → abort)
+ */
+export function mergeEntity(match) {
+    const { signature, status, base, ours, theirs } = match;
+    switch (status) {
+        case "unchanged":
+            return {
+                signature,
+                include: true,
+                mergedText: (ours ?? theirs ?? base).text,
+                reason: "unchanged",
+            };
+        case "both-changed-same":
+            if (ours && theirs) {
+                return {
+                    signature,
+                    include: true,
+                    mergedText: theirs.text,
+                    reason: "both changed identically — taking theirs",
+                };
+            }
+            // Both deleted
+            return {
+                signature,
+                include: false,
+                mergedText: null,
+                reason: "both deleted",
+            };
+        case "ours-only-change":
+            return {
+                signature,
+                include: ours !== null,
+                mergedText: ours?.text ?? null,
+                reason: "ours-only change",
+            };
+        case "theirs-only-change":
+            return {
+                signature,
+                include: theirs !== null,
+                mergedText: theirs?.text ?? null,
+                reason: "theirs-only change",
+            };
+        case "ours-added":
+            return {
+                signature,
+                include: true,
+                mergedText: ours.text,
+                reason: "ours added",
+            };
+        case "theirs-added":
+            return {
+                signature,
+                include: true,
+                mergedText: theirs.text,
+                reason: "theirs added",
+            };
+        case "ours-deleted":
+            // If theirs also modified this entity, it's a conflict (we'd silently
+            // drop a change by theirs). Treat as unresolvable.
+            if (theirs && base && theirs.text !== base.text) {
+                return {
+                    signature,
+                    include: false,
+                    mergedText: null,
+                    reason: "conflict: ours deleted, theirs modified",
+                };
+            }
+            return {
+                signature,
+                include: false,
+                mergedText: null,
+                reason: "ours deleted",
+            };
+        case "theirs-deleted":
+            // Symmetric: if ours modified the entity, conflict.
+            if (ours && base && ours.text !== base.text) {
+                return {
+                    signature,
+                    include: false,
+                    mergedText: null,
+                    reason: "conflict: theirs deleted, ours modified",
+                };
+            }
+            return {
+                signature,
+                include: false,
+                mergedText: null,
+                reason: "theirs deleted",
+            };
+        case "both-changed-diff":
+            return {
+                signature,
+                include: false,
+                mergedText: null,
+                reason: "conflict: both changed differently",
+            };
+    }
+}
+/**
+ * Returns `true` if any entity merge has an unresolvable conflict
+ * (i.e. the structural merge cannot produce a clean output).
+ */
+export function hasEntityConflict(merges) {
+    return merges.some((m) => m.include === false && m.reason.startsWith("conflict:"));
+}
+//# sourceMappingURL=merge.js.map

package/dist/structural/merge.js.map

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

package/dist/structural/parsers/adapters/browser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Browser adapter for loading tree-sitter grammar WASM files.
+ *
+ * Fetches the WASM file from a URL. The bundler / dev server must make the
+ * grammar WASM files available at a known public URL.
+ *
+ * Configure via `LoaderOptions.grammarBaseUrl` (default: "/assets/grammars").
+ */
+export interface BrowserLoaderOptions {
+    /** Base URL where grammar WASM files are served (no trailing slash). */
+    grammarBaseUrl?: string;
+}
+/**
+ * Load grammar WASM bytes via fetch.
+ *
+ * Fetches `{grammarBaseUrl}/{grammarName}.wasm`.
+ *
+ * @param grammarName - e.g. "tree-sitter-typescript"
+ * @param opts        - Browser-specific options
+ */
+export declare function loadGrammarBytes(grammarName: string, opts?: BrowserLoaderOptions): Promise<Uint8Array>;
+//# sourceMappingURL=browser.d.ts.map

package/dist/structural/parsers/adapters/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../../src/structural/parsers/adapters/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,UAAU,CAAC,CAarB"}

package/dist/structural/parsers/adapters/browser.js

@@ -0,0 +1,27 @@
+/**
+ * Browser adapter for loading tree-sitter grammar WASM files.
+ *
+ * Fetches the WASM file from a URL. The bundler / dev server must make the
+ * grammar WASM files available at a known public URL.
+ *
+ * Configure via `LoaderOptions.grammarBaseUrl` (default: "/assets/grammars").
+ */
+/**
+ * Load grammar WASM bytes via fetch.
+ *
+ * Fetches `{grammarBaseUrl}/{grammarName}.wasm`.
+ *
+ * @param grammarName - e.g. "tree-sitter-typescript"
+ * @param opts        - Browser-specific options
+ */
+export async function loadGrammarBytes(grammarName, opts = {}) {
+    const base = opts.grammarBaseUrl ?? "/assets/grammars";
+    const url = `${base}/${grammarName}.wasm`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`[structural] Failed to fetch grammar WASM: ${url} (HTTP ${response.status})`);
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+}
+//# sourceMappingURL=browser.js.map

package/dist/structural/parsers/adapters/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../../../src/structural/parsers/adapters/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,WAAmB,EACnB,OAA6B,EAAE;IAE/B,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,IAAI,kBAAkB,CAAC;IACvD,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,WAAW,OAAO,CAAC;IAE1C,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,8CAA8C,GAAG,UAAU,QAAQ,CAAC,MAAM,GAAG,CAC9E,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC"}

package/dist/structural/parsers/adapters/node.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Node.js adapter for loading tree-sitter grammar WASM files.
+ *
+ * Reads WASM bytes from the filesystem. Grammar resolution order:
+ *   1. `tree-sitter-wasms` package (if installed as optional peer)
+ *   2. `@gitwand/core` local assets directory (packages/core/assets/grammars/)
+ */
+/**
+ * Resolve the filesystem path to a grammar WASM file.
+ *
+ * @param grammarName - e.g. "tree-sitter-typescript"
+ */
+export declare function resolveGrammarPath(grammarName: string): string;
+/**
+ * Load grammar WASM bytes from the Node.js filesystem.
+ */
+export declare function loadGrammarBytes(grammarName: string): Promise<Uint8Array>;
+//# sourceMappingURL=node.d.ts.map

package/dist/structural/parsers/adapters/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../src/structural/parsers/adapters/node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAe9D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAI/E"}

package/dist/structural/parsers/adapters/node.js

@@ -0,0 +1,42 @@
+/**
+ * Node.js adapter for loading tree-sitter grammar WASM files.
+ *
+ * Reads WASM bytes from the filesystem. Grammar resolution order:
+ *   1. `tree-sitter-wasms` package (if installed as optional peer)
+ *   2. `@gitwand/core` local assets directory (packages/core/assets/grammars/)
+ */
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const _require = createRequire(import.meta.url);
+/**
+ * Resolve the filesystem path to a grammar WASM file.
+ *
+ * @param grammarName - e.g. "tree-sitter-typescript"
+ */
+export function resolveGrammarPath(grammarName) {
+    // 1. Try tree-sitter-wasms (optional peer) — publishes to out/ dir
+    try {
+        const pkgJson = _require.resolve("tree-sitter-wasms/package.json");
+        const pkgDir = dirname(pkgJson);
+        return resolve(pkgDir, "out", `${grammarName}.wasm`);
+    }
+    catch {
+        // tree-sitter-wasms not installed
+    }
+    // 2. Fallback: local assets directory (four levels up from this file)
+    //    __file__ = packages/core/src/structural/parsers/adapters/node.ts
+    //    target   = packages/core/assets/grammars/
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    return resolve(thisDir, "../../../../../assets/grammars", `${grammarName}.wasm`);
+}
+/**
+ * Load grammar WASM bytes from the Node.js filesystem.
+ */
+export async function loadGrammarBytes(grammarName) {
+    const grammarPath = resolveGrammarPath(grammarName);
+    const buf = await readFile(grammarPath);
+    return new Uint8Array(buf);
+}
+//# sourceMappingURL=node.js.map

package/dist/structural/parsers/adapters/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../../src/structural/parsers/adapters/node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAEhD;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAmB;IACpD,mEAAmE;IACnE,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,WAAW,OAAO,CAAC,CAAC;IACvD,CAAC;IAAC,MAAM,CAAC;QACP,kCAAkC;IACpC,CAAC;IAED,sEAAsE;IACtE,sEAAsE;IACtE,+CAA+C;IAC/C,MAAM,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACxD,OAAO,OAAO,CAAC,OAAO,EAAE,gCAAgC,EAAE,GAAG,WAAW,OAAO,CAAC,CAAC;AACnF,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,WAAmB;IACxD,MAAM,WAAW,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACpD,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAC;IACxC,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC"}