lattice-graph 0.1.0

package/src/extract/typescript/imports.ts

@@ -0,0 +1,71 @@
+import type { TreeSitterNode, TreeSitterTree } from "../parser.ts";
+
+/** A parsed import statement from TypeScript source. */
+type TypeScriptImport = {
+	readonly module: string;
+	readonly names: readonly string[];
+	readonly defaultImport: string | undefined;
+	readonly isRelative: boolean;
+	readonly line: number;
+};
+
+/**
+ * Extracts import statements from a TypeScript AST.
+ *
+ * @param tree - Parsed tree-sitter tree
+ * @param _filePath - Relative file path (unused, kept for interface consistency)
+ * @returns Parsed imports with module paths and imported names
+ */
+function extractTypeScriptImports(
+	tree: TreeSitterTree,
+	_filePath: string,
+): readonly TypeScriptImport[] {
+	const imports: TypeScriptImport[] = [];
+
+	for (const child of tree.rootNode.children) {
+		if (child.type === "import_statement") {
+			parseImportStatement(child, imports);
+		}
+	}
+
+	return imports;
+}
+
+/** Parses an import statement into module path, named imports, and default import. */
+function parseImportStatement(node: TreeSitterNode, results: TypeScriptImport[]): void {
+	const fromClause = node.children.find((c) => c.type === "string");
+	if (!fromClause) return;
+
+	const contentNode = fromClause.children.find((c) => c.type === "string_fragment");
+	const module = contentNode?.text ?? "";
+	const isRelative = module.startsWith(".");
+
+	const importClause = node.children.find((c) => c.type === "import_clause");
+	if (!importClause) return;
+
+	let defaultImport: string | undefined;
+	const names: string[] = [];
+
+	for (const child of importClause.children) {
+		if (child.type === "identifier") {
+			defaultImport = child.text;
+		} else if (child.type === "named_imports") {
+			for (const spec of child.children) {
+				if (spec.type === "import_specifier") {
+					const nameNode = spec.childForFieldName("name");
+					if (nameNode) names.push(nameNode.text);
+				}
+			}
+		}
+	}
+
+	results.push({
+		module,
+		names,
+		defaultImport,
+		isRelative,
+		line: node.startPosition.row + 1,
+	});
+}
+
+export { extractTypeScriptImports, type TypeScriptImport };

package/src/extract/typescript/symbols.ts

@@ -0,0 +1,252 @@
+import type { Node, NodeKind } from "../../types/graph.ts";
+import type { TreeSitterNode, TreeSitterTree } from "../parser.ts";
+
+/**
+ * Extracts symbols (functions, classes, methods, interfaces, type aliases)
+ * from a TypeScript AST.
+ *
+ * @param tree - Parsed tree-sitter tree
+ * @param filePath - Relative file path for node ID construction
+ * @param _source - Original source text (unused, kept for interface consistency)
+ * @returns Extracted nodes with deterministic IDs
+ */
+function extractTypeScriptSymbols(
+	tree: TreeSitterTree,
+	filePath: string,
+	_source: string,
+): readonly Node[] {
+	const nodes: Node[] = [];
+	visitNode(tree.rootNode, filePath, [], nodes);
+	return nodes;
+}
+
+/** Scope entry for tracking parent context. */
+type ScopeEntry = { readonly name: string; readonly isClass: boolean };
+
+/** Recursively visits AST nodes to extract symbols. */
+function visitNode(
+	node: TreeSitterNode,
+	filePath: string,
+	scopeStack: readonly ScopeEntry[],
+	results: Node[],
+): void {
+	switch (node.type) {
+		case "function_declaration":
+			extractFunction(node, filePath, scopeStack, results);
+			return;
+		case "class_declaration":
+			extractClass(node, filePath, scopeStack, results);
+			return;
+		case "interface_declaration":
+			extractTypeDecl(node, filePath, scopeStack, results, "type");
+			return;
+		case "type_alias_declaration":
+			extractTypeDecl(node, filePath, scopeStack, results, "type");
+			return;
+		case "export_statement": {
+			// Unwrap: export function X, export class X, export const X = ...
+			for (const child of node.children) {
+				visitNode(child, filePath, scopeStack, results);
+			}
+			return;
+		}
+		case "lexical_declaration": {
+			// const handler = async () => { ... }
+			extractArrowFunctions(node, filePath, scopeStack, results);
+			return;
+		}
+		case "method_definition": {
+			extractMethod(node, filePath, scopeStack, results);
+			return;
+		}
+		default:
+			for (const child of node.children) {
+				visitNode(child, filePath, scopeStack, results);
+			}
+	}
+}
+
+/** Extracts a function declaration. */
+function extractFunction(
+	node: TreeSitterNode,
+	filePath: string,
+	scopeStack: readonly ScopeEntry[],
+	results: Node[],
+): void {
+	const nameNode = node.childForFieldName("name");
+	if (!nameNode) return;
+
+	const name = nameNode.text;
+	const qualifiedName = [...scopeStack.map((s) => s.name), name].join(".");
+	const id = `${filePath}::${qualifiedName}`;
+
+	results.push({
+		id,
+		kind: "function",
+		name,
+		file: filePath,
+		lineStart: node.startPosition.row + 1,
+		lineEnd: node.endPosition.row + 1,
+		language: "typescript",
+		signature: buildSignature(node, name),
+		isTest: false,
+		metadata: undefined,
+	});
+}
+
+/** Extracts a class declaration and recurses into its body for methods. */
+function extractClass(
+	node: TreeSitterNode,
+	filePath: string,
+	scopeStack: readonly ScopeEntry[],
+	results: Node[],
+): void {
+	const nameNode = node.childForFieldName("name");
+	if (!nameNode) return;
+
+	const name = nameNode.text;
+	const qualifiedName = [...scopeStack.map((s) => s.name), name].join(".");
+	const id = `${filePath}::${qualifiedName}`;
+
+	results.push({
+		id,
+		kind: "class",
+		name,
+		file: filePath,
+		lineStart: node.startPosition.row + 1,
+		lineEnd: node.endPosition.row + 1,
+		language: "typescript",
+		signature: undefined,
+		isTest: false,
+		metadata: undefined,
+	});
+
+	// Recurse into class body for methods
+	const body = node.childForFieldName("body");
+	if (body) {
+		const newScope = [...scopeStack, { name, isClass: true }];
+		for (const child of body.children) {
+			visitNode(child, filePath, newScope, results);
+		}
+	}
+}
+
+/** Extracts a method definition inside a class. */
+function extractMethod(
+	node: TreeSitterNode,
+	filePath: string,
+	scopeStack: readonly ScopeEntry[],
+	results: Node[],
+): void {
+	const nameNode = node.childForFieldName("name");
+	if (!nameNode) return;
+
+	const name = nameNode.text;
+	const qualifiedName = [...scopeStack.map((s) => s.name), name].join(".");
+	const id = `${filePath}::${qualifiedName}`;
+
+	results.push({
+		id,
+		kind: "method",
+		name,
+		file: filePath,
+		lineStart: node.startPosition.row + 1,
+		lineEnd: node.endPosition.row + 1,
+		language: "typescript",
+		signature: buildSignature(node, name),
+		isTest: false,
+		metadata: undefined,
+	});
+}
+
+/** Extracts an interface or type alias declaration. */
+function extractTypeDecl(
+	node: TreeSitterNode,
+	filePath: string,
+	scopeStack: readonly ScopeEntry[],
+	results: Node[],
+	kind: NodeKind,
+): void {
+	const nameNode = node.childForFieldName("name");
+	if (!nameNode) return;
+
+	const name = nameNode.text;
+	const qualifiedName = [...scopeStack.map((s) => s.name), name].join(".");
+	const id = `${filePath}::${qualifiedName}`;
+
+	results.push({
+		id,
+		kind,
+		name,
+		file: filePath,
+		lineStart: node.startPosition.row + 1,
+		lineEnd: node.endPosition.row + 1,
+		language: "typescript",
+		signature: undefined,
+		isTest: false,
+		metadata: undefined,
+	});
+}
+
+/** Extracts arrow functions assigned to const/let variables. */
+function extractArrowFunctions(
+	node: TreeSitterNode,
+	filePath: string,
+	scopeStack: readonly ScopeEntry[],
+	results: Node[],
+): void {
+	for (const child of node.children) {
+		if (child.type === "variable_declarator") {
+			const nameNode = child.childForFieldName("name");
+			const valueNode = child.childForFieldName("value");
+			if (nameNode && valueNode?.type === "arrow_function") {
+				const name = nameNode.text;
+				const qualifiedName = [...scopeStack.map((s) => s.name), name].join(".");
+				const id = `${filePath}::${qualifiedName}`;
+
+				results.push({
+					id,
+					kind: "function",
+					name,
+					file: filePath,
+					lineStart: node.startPosition.row + 1,
+					lineEnd: node.endPosition.row + 1,
+					language: "typescript",
+					signature: buildArrowSignature(valueNode, name),
+					isTest: false,
+					metadata: undefined,
+				});
+			}
+		}
+	}
+}
+
+/** Builds a signature string from a function/method declaration. */
+function buildSignature(node: TreeSitterNode, name: string): string {
+	const params = node.childForFieldName("parameters");
+	const returnType =
+		node.childForFieldName("return_type") ??
+		node.children.find((c) => c.type === "type_annotation");
+
+	const paramsStr = params?.text ?? "()";
+	const returnStr = returnType?.text ?? "";
+
+	return `${name}${paramsStr}${returnStr ? ` ${returnStr}` : ""}`;
+}
+
+/** Builds a signature string from an arrow function. */
+function buildArrowSignature(node: TreeSitterNode, name: string): string {
+	const params =
+		node.childForFieldName("parameters") ??
+		node.children.find((c) => c.type === "formal_parameters");
+	const returnType =
+		node.childForFieldName("return_type") ??
+		node.children.find((c) => c.type === "type_annotation");
+
+	const paramsStr = params?.text ?? "()";
+	const returnStr = returnType?.text ?? "";
+
+	return `${name}${paramsStr}${returnStr ? ` ${returnStr}` : ""}`;
+}
+
+export { extractTypeScriptSymbols };

package/src/graph/database.ts

@@ -0,0 +1,95 @@
+import { Database } from "bun:sqlite";
+import { err, ok, type Result } from "../types/result.ts";
+
+const SCHEMA_VERSION = "1";
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS nodes (
+	id          TEXT PRIMARY KEY,
+	kind        TEXT NOT NULL,
+	name        TEXT NOT NULL,
+	file        TEXT NOT NULL,
+	line_start  INTEGER NOT NULL,
+	line_end    INTEGER NOT NULL,
+	language    TEXT NOT NULL,
+	signature   TEXT,
+	is_test     INTEGER DEFAULT 0,
+	metadata    TEXT
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+	source_id   TEXT NOT NULL,
+	target_id   TEXT NOT NULL,
+	kind        TEXT NOT NULL,
+	certainty   TEXT DEFAULT 'certain',
+	PRIMARY KEY (source_id, target_id, kind)
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+	node_id     TEXT NOT NULL REFERENCES nodes(id),
+	kind        TEXT NOT NULL,
+	value       TEXT NOT NULL,
+	PRIMARY KEY (node_id, kind, value)
+);
+
+CREATE TABLE IF NOT EXISTS unresolved (
+	file        TEXT NOT NULL,
+	line        INTEGER NOT NULL,
+	expression  TEXT NOT NULL,
+	reason      TEXT NOT NULL,
+	PRIMARY KEY (file, line, expression)
+);
+
+CREATE TABLE IF NOT EXISTS meta (
+	key         TEXT PRIMARY KEY,
+	value       TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id, kind);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id, kind);
+CREATE INDEX IF NOT EXISTS idx_tags_kind_value ON tags(kind, value);
+CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file);
+CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
+`;
+
+/**
+ * Creates or opens a SQLite database with the Lattice schema.
+ * Uses WAL mode for concurrent read performance.
+ *
+ * @param path - File path for the database, or ":memory:" for in-memory
+ * @returns An open Database handle with the schema applied
+ */
+// @lattice:boundary sqlite
+function createDatabase(path: string): Database {
+	const db = new Database(path);
+	db.run("PRAGMA journal_mode = WAL");
+	db.run("PRAGMA foreign_keys = ON");
+	for (const statement of SCHEMA_SQL.split(";").filter((s) => s.trim())) {
+		db.run(`${statement};`);
+	}
+	db.run("INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', ?)", [SCHEMA_VERSION]);
+	return db;
+}
+
+/**
+ * Validates that the database schema version matches the expected version.
+ *
+ * @param db - An open Database handle
+ * @returns Ok if versions match, Err with a message if they don't
+ */
+function checkSchemaVersion(db: Database): Result<undefined, string> {
+	const row = db.query("SELECT value FROM meta WHERE key = 'schema_version'").get() as {
+		value: string;
+	} | null;
+	if (!row) {
+		return err("No schema_version found in database");
+	}
+	if (row.value !== SCHEMA_VERSION) {
+		return err(
+			`Schema version mismatch: expected ${SCHEMA_VERSION}, found ${row.value}. Run 'lattice build' to rebuild.`,
+		);
+	}
+	return ok(undefined);
+}
+
+export { checkSchemaVersion, createDatabase, SCHEMA_VERSION };