@rkarim08/sia 1.0.0

package/src/ast/tree-sitter/backends/native.ts

@@ -0,0 +1,57 @@
+export interface ParserBackend {
+	type: "native" | "wasm";
+	createParser(): unknown;
+	loadLanguage(grammarPackage: string, entrypoint?: string): Promise<unknown>;
+	setTimeoutMicros(parser: unknown, micros: number): void;
+	parse(parser: unknown, source: string, language: unknown, previousTree?: unknown): unknown | null;
+	query(language: unknown, querySource: string): unknown;
+	getChangedRanges(
+		oldTree: unknown,
+		newTree: unknown,
+	): Array<{
+		startPosition: { row: number; column: number };
+		endPosition: { row: number; column: number };
+		startIndex: number;
+		endIndex: number;
+	}>;
+}
+
+export async function tryLoadNativeBackend(): Promise<ParserBackend | null> {
+	try {
+		const Parser = (await import("tree-sitter")).default;
+
+		return {
+			type: "native",
+			createParser() {
+				return new Parser();
+			},
+			async loadLanguage(grammarPackage: string, entrypoint?: string) {
+				const mod = await import(grammarPackage);
+				const lang = entrypoint ? (mod[entrypoint] ?? mod.default) : (mod.default ?? mod);
+				return lang;
+			},
+			setTimeoutMicros(parser: any, micros: number) {
+				if (typeof parser.setTimeoutMicros === "function") {
+					parser.setTimeoutMicros(micros);
+				}
+			},
+			parse(parser: any, source: string, language: unknown, previousTree?: unknown) {
+				parser.setLanguage(language);
+				return parser.parse(source, previousTree as any) ?? null;
+			},
+			query(language: any, querySource: string) {
+				// biome-ignore lint: dynamic require needed for native module
+				var NativeParser = require("tree-sitter");
+				return new NativeParser.Query(language, querySource);
+			},
+			getChangedRanges(oldTree: any, newTree: any) {
+				if (typeof oldTree.getChangedRanges === "function") {
+					return oldTree.getChangedRanges(newTree);
+				}
+				return [];
+			},
+		};
+	} catch {
+		return null;
+	}
+}

package/src/ast/tree-sitter/backends/wasm.ts

@@ -0,0 +1,39 @@
+import type { ParserBackend } from "./native";
+
+export async function tryLoadWasmBackend(): Promise<ParserBackend | null> {
+	try {
+		const mod = await import("web-tree-sitter");
+		const TreeSitter = mod.default as any;
+		await TreeSitter.init();
+
+		return {
+			type: "wasm",
+			createParser() {
+				return new TreeSitter();
+			},
+			async loadLanguage(wasmPath: string, _entrypoint?: string) {
+				return await TreeSitter.Language.load(wasmPath);
+			},
+			setTimeoutMicros(parser: any, micros: number) {
+				if (typeof parser.setTimeoutMicros === "function") {
+					parser.setTimeoutMicros(micros);
+				}
+			},
+			parse(parser: any, source: string, language: unknown, previousTree?: unknown) {
+				parser.setLanguage(language);
+				return parser.parse(source, previousTree as any) ?? null;
+			},
+			query(language: any, querySource: string) {
+				return language.query(querySource);
+			},
+			getChangedRanges(oldTree: any, newTree: any) {
+				if (typeof oldTree.getChangedRanges === "function") {
+					return oldTree.getChangedRanges(newTree);
+				}
+				return [];
+			},
+		};
+	} catch {
+		return null;
+	}
+}

package/src/ast/tree-sitter/call-walker.ts

@@ -0,0 +1,44 @@
+import type { NodeVisitor, Point } from "./types";
+
+export interface WalkResult {
+	nodesVisited: number;
+}
+
+export function walkTree(tree: any, visitor: NodeVisitor): WalkResult {
+	const cursor = tree.rootNode.walk();
+	let nodesVisited = 0;
+	let reachedRoot = false;
+
+	while (!reachedRoot) {
+		const nodeType: string = cursor.nodeType;
+		const nodeText: string = cursor.nodeText;
+		const startPosition: Point = cursor.startPosition;
+		const endPosition: Point = cursor.endPosition;
+
+		nodesVisited++;
+		const shouldDescend = visitor.enter?.(nodeType, nodeText, startPosition, endPosition);
+
+		if (shouldDescend !== false && cursor.gotoFirstChild()) {
+			continue;
+		}
+
+		visitor.leave?.(nodeType, nodeText, startPosition, endPosition);
+
+		if (cursor.gotoNextSibling()) {
+			continue;
+		}
+
+		while (true) {
+			if (!cursor.gotoParent()) {
+				reachedRoot = true;
+				break;
+			}
+			visitor.leave?.(cursor.nodeType, cursor.nodeText, cursor.startPosition, cursor.endPosition);
+			if (cursor.gotoNextSibling()) {
+				break;
+			}
+		}
+	}
+
+	return { nodesVisited };
+}

package/src/ast/tree-sitter/edit-computer.ts

@@ -0,0 +1,55 @@
+import type { InputEdit, Point } from "./types";
+
+export function computeEdits(oldSource: string, newSource: string): InputEdit[] {
+	if (oldSource === newSource) return [];
+
+	const oldLines = oldSource.split("\n");
+	const newLines = newSource.split("\n");
+
+	let topMatch = 0;
+	while (
+		topMatch < oldLines.length &&
+		topMatch < newLines.length &&
+		oldLines[topMatch] === newLines[topMatch]
+	) {
+		topMatch++;
+	}
+
+	let oldBottom = oldLines.length - 1;
+	let newBottom = newLines.length - 1;
+	while (
+		oldBottom > topMatch &&
+		newBottom > topMatch &&
+		oldLines[oldBottom] === newLines[newBottom]
+	) {
+		oldBottom--;
+		newBottom--;
+	}
+
+	const startIndex = byteOffsetForLine(oldLines, topMatch);
+	const oldEndIndex = byteOffsetForLine(oldLines, oldBottom + 1);
+	const newEndIndex = byteOffsetForLine(newLines, newBottom + 1);
+
+	const startPosition: Point = { row: topMatch, column: 0 };
+	const oldEndPosition: Point = { row: oldBottom + 1, column: 0 };
+	const newEndPosition: Point = { row: newBottom + 1, column: 0 };
+
+	return [
+		{
+			startIndex,
+			oldEndIndex,
+			newEndIndex,
+			startPosition,
+			oldEndPosition,
+			newEndPosition,
+		},
+	];
+}
+
+function byteOffsetForLine(lines: string[], lineIndex: number): number {
+	let offset = 0;
+	for (let i = 0; i < lineIndex && i < lines.length; i++) {
+		offset += Buffer.byteLength(lines[i], "utf-8") + 1;
+	}
+	return offset;
+}

package/src/ast/tree-sitter/query-runner.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import type { SiaQueryCapture, SiaQueryMatch } from "./types";
+
+const querySourceCache = new Map<string, string>();
+
+export function loadQuerySource(queryPath: string): string {
+	const cached = querySourceCache.get(queryPath);
+	if (cached) return cached;
+	const source = readFileSync(queryPath, "utf-8");
+	querySourceCache.set(queryPath, source);
+	return source;
+}
+
+export function mapMatchesToSiaMatches(
+	rawMatches: Array<{
+		pattern: number;
+		captures: Array<{
+			name: string;
+			node: {
+				text: string;
+				startPosition: { row: number; column: number };
+				endPosition: { row: number; column: number };
+				startIndex: number;
+				endIndex: number;
+			};
+		}>;
+	}>,
+): SiaQueryMatch[] {
+	return rawMatches.map((match) => ({
+		patternIndex: match.pattern,
+		captures: match.captures.map(
+			(cap): SiaQueryCapture => ({
+				name: cap.name,
+				text: cap.node.text,
+				startPosition: cap.node.startPosition,
+				endPosition: cap.node.endPosition,
+				startIndex: cap.node.startIndex,
+				endIndex: cap.node.endIndex,
+			}),
+		),
+	}));
+}
+
+export function clearQueryCache(): void {
+	querySourceCache.clear();
+}

package/src/ast/tree-sitter/service.ts

@@ -0,0 +1,174 @@
+import { join } from "node:path";
+import { type LanguageConfig, resolveLanguageConfig } from "@/ast/languages";
+import type { TreeSitterConfig } from "@/shared/config";
+import type { ParserBackend } from "./backends/native";
+import { tryLoadNativeBackend } from "./backends/native";
+import { tryLoadWasmBackend } from "./backends/wasm";
+import { walkTree } from "./call-walker";
+import { loadQuerySource, mapMatchesToSiaMatches } from "./query-runner";
+import { TreeCache } from "./tree-cache";
+import type {
+	ITreeSitterService,
+	NodeVisitor,
+	Point,
+	SiaQueryMatch,
+	TreeSitterBackend,
+	TreeSitterRange,
+} from "./types";
+
+export class TreeSitterService implements ITreeSitterService {
+	private _backend: TreeSitterBackend = "unavailable";
+	private parserBackend: ParserBackend | null = null;
+	private parser: unknown = null;
+	private languages = new Map<string, unknown>();
+	private treeCache: TreeCache;
+	private initialized = false;
+	private initPromise: Promise<void> | null = null;
+
+	constructor(private readonly config: TreeSitterConfig) {
+		this.treeCache = new TreeCache(config.maxCachedTrees);
+	}
+
+	get backend(): TreeSitterBackend {
+		return this._backend;
+	}
+
+	get cache(): TreeCache {
+		return this.treeCache;
+	}
+
+	async initialize(): Promise<void> {
+		if (this.initialized) return;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this._initialize();
+		await this.initPromise;
+	}
+
+	private async _initialize(): Promise<void> {
+		if (!this.config.enabled) {
+			this._backend = "unavailable";
+			this.initialized = true;
+			return;
+		}
+
+		if (this.config.preferNative) {
+			this.parserBackend = await tryLoadNativeBackend();
+			if (this.parserBackend) {
+				this._backend = "native";
+				this.parser = this.parserBackend.createParser();
+				this.parserBackend.setTimeoutMicros(this.parser, this.config.parseTimeoutMs * 1000);
+				this.initialized = true;
+				return;
+			}
+		}
+
+		this.parserBackend = await tryLoadWasmBackend();
+		if (this.parserBackend) {
+			this._backend = "wasm";
+			this.parser = this.parserBackend.createParser();
+			this.parserBackend.setTimeoutMicros(this.parser, this.config.parseTimeoutMs * 1000);
+			this.initialized = true;
+			return;
+		}
+
+		this._backend = "unavailable";
+		this.initialized = true;
+	}
+
+	private async ensureLanguage(langConfig: LanguageConfig): Promise<unknown | null> {
+		const resolved = resolveLanguageConfig(langConfig);
+		const key = `${resolved.nativePackage}:${resolved.parserEntrypoint ?? "default"}`;
+		const cached = this.languages.get(key);
+		if (cached) return cached;
+		if (!this.parserBackend) return null;
+
+		try {
+			let grammarRef: string;
+			if (this._backend === "wasm") {
+				grammarRef = join(this.config.wasmDir, resolved.wasmFile);
+			} else {
+				grammarRef = resolved.nativePackage;
+			}
+			const language = await this.parserBackend.loadLanguage(grammarRef, resolved.parserEntrypoint);
+			this.languages.set(key, language);
+			return language;
+		} catch {
+			return null;
+		}
+	}
+
+	async parse(source: string, langName: string, previousTree?: unknown): Promise<unknown | null> {
+		await this.initialize();
+		if (!this.parserBackend || !this.parser) return null;
+
+		const { LANGUAGE_REGISTRY } = await import("@/ast/languages");
+		const langConfig = LANGUAGE_REGISTRY[langName];
+		if (!langConfig) return null;
+
+		const language = await this.ensureLanguage(langConfig);
+		if (!language) return null;
+
+		try {
+			return this.parserBackend.parse(this.parser, source, language, previousTree);
+		} catch {
+			return null;
+		}
+	}
+
+	query(
+		tree: unknown,
+		querySchemePath: string,
+		startPosition?: Point,
+		endPosition?: Point,
+	): SiaQueryMatch[] {
+		if (!this.parserBackend || !tree) return [];
+		try {
+			const querySource = loadQuerySource(querySchemePath);
+			const treeAny = tree as any;
+			const language = treeAny.getLanguage?.() ?? treeAny.rootNode?.language;
+			if (!language) return [];
+
+			const queryObj = this.parserBackend.query(language, querySource);
+			const queryAny = queryObj as any;
+
+			const options: any = {};
+			if (startPosition) options.startPosition = startPosition;
+			if (endPosition) options.endPosition = endPosition;
+
+			const rootNode = treeAny.rootNode ?? treeAny;
+			const matches = queryAny.matches?.(rootNode, options) ?? [];
+			return mapMatchesToSiaMatches(matches);
+		} catch {
+			return [];
+		}
+	}
+
+	walk(tree: unknown, visitor: NodeVisitor): void {
+		walkTree(tree, visitor);
+	}
+
+	getChangedRanges(oldTree: unknown, newTree: unknown): TreeSitterRange[] {
+		if (!this.parserBackend) return [];
+		try {
+			const ranges = this.parserBackend.getChangedRanges(oldTree, newTree);
+			return ranges.map((r) => ({
+				startPosition: r.startPosition,
+				endPosition: r.endPosition,
+				startIndex: r.startIndex,
+				endIndex: r.endIndex,
+			}));
+		} catch {
+			return [];
+		}
+	}
+
+	dispose(): void {
+		this.treeCache.clear();
+		this.languages.clear();
+		this.parser = null;
+		this.parserBackend = null;
+		this._backend = "unavailable";
+		this.initialized = false;
+		this.initPromise = null;
+	}
+}

package/src/ast/tree-sitter/tree-cache.ts

@@ -0,0 +1,39 @@
+export interface TreeCacheEntry {
+	tree: unknown;
+	source: string;
+}
+
+export class TreeCache {
+	private cache = new Map<string, TreeCacheEntry>();
+
+	constructor(private readonly maxSize: number) {}
+
+	get size(): number {
+		return this.cache.size;
+	}
+
+	get(filePath: string): TreeCacheEntry | undefined {
+		const entry = this.cache.get(filePath);
+		if (!entry) return undefined;
+		this.cache.delete(filePath);
+		this.cache.set(filePath, entry);
+		return entry;
+	}
+
+	set(filePath: string, tree: unknown, source: string): void {
+		this.cache.delete(filePath);
+		if (this.cache.size >= this.maxSize) {
+			const oldest = this.cache.keys().next().value!;
+			this.cache.delete(oldest);
+		}
+		this.cache.set(filePath, { tree, source });
+	}
+
+	delete(filePath: string): boolean {
+		return this.cache.delete(filePath);
+	}
+
+	clear(): void {
+		this.cache.clear();
+	}
+}

package/src/ast/tree-sitter/types.ts

@@ -0,0 +1,79 @@
+/** Which tree-sitter backend is active */
+export type TreeSitterBackend = "native" | "wasm" | "unavailable";
+
+/** Position in source code (0-indexed row/column) */
+export interface Point {
+	row: number;
+	column: number;
+}
+
+/** A range in the source code */
+export interface TreeSitterRange {
+	startPosition: Point;
+	endPosition: Point;
+	startIndex: number;
+	endIndex: number;
+}
+
+/** A single captured node from a .scm query */
+export interface SiaQueryCapture {
+	name: string;
+	text: string;
+	startPosition: Point;
+	endPosition: Point;
+	startIndex: number;
+	endIndex: number;
+}
+
+/** A full match from a .scm query (may contain multiple captures) */
+export interface SiaQueryMatch {
+	patternIndex: number;
+	captures: SiaQueryCapture[];
+}
+
+/** Tree-sitter InputEdit for incremental re-parsing */
+export interface InputEdit {
+	startIndex: number;
+	oldEndIndex: number;
+	newEndIndex: number;
+	startPosition: Point;
+	oldEndPosition: Point;
+	newEndPosition: Point;
+}
+
+/** Visitor callbacks for programmatic tree traversal */
+export interface NodeVisitor {
+	/** Called for each node. Return false to skip children. */
+	enter?(
+		nodeType: string,
+		text: string,
+		startPosition: Point,
+		endPosition: Point,
+	): boolean | undefined;
+	/** Called after all children have been visited */
+	leave?(nodeType: string, text: string, startPosition: Point, endPosition: Point): void;
+}
+
+/**
+ * Core tree-sitter service interface.
+ * Encapsulates native/WASM duality behind a single API.
+ */
+export interface ITreeSitterService {
+	/** Which backend was loaded: native, wasm, or unavailable */
+	readonly backend: TreeSitterBackend;
+
+	parse(source: string, langName: string, previousTree?: unknown): unknown | null;
+
+	query(
+		tree: unknown,
+		querySchemePath: string,
+		startPosition?: Point,
+		endPosition?: Point,
+	): SiaQueryMatch[];
+
+	walk(tree: unknown, visitor: NodeVisitor): void;
+
+	getChangedRanges(oldTree: unknown, newTree: unknown): TreeSitterRange[];
+
+	dispose(): void;
+}