@rkarim08/sia 1.0.0

package/src/ast/extractors/csharp-project.ts

@@ -0,0 +1,260 @@
+// Module: csharp-project — C# code entity extraction + .csproj dependency extraction
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import type { CandidateFact } from "@/capture/types";
+
+// ─── Phase 1: C# code patterns ──────────────────────────────────────────────
+
+/** Regex for C# methods (access modifier required). Capture group 2 = name.
+ *  Return type allows generic forms like Task<string> or List<T>. */
+const METHOD_RE =
+	/(public|private|protected|internal|static|async|virtual|override|abstract)\s+\w+(?:<[^>]*>)?\s+(\w+)\s*\(/gm;
+
+/** Regex for C# class / interface / struct / enum / record declarations. Capture group 2 = name. */
+const CLASS_RE = /(class|interface|struct|enum|record)\s+(\w+)/gm;
+
+/** Regex for C# auto-properties: `modifier type Name { get; set; }` on a single line.
+ *  [^}\n] prevents crossing into multi-line class bodies. */
+const PROPERTY_RE =
+	/(public|private|protected|internal)\s+[\w<>[\]?]+\s+(\w+)\s*\{[^}\n]*(?:get|set)[^}\n]*\}/gm;
+
+/** Regex for C# using statements. Capture group 1 = namespace. */
+const USING_RE = /^using\s+([\w.]+)\s*;/gm;
+
+// ─── Phase 2: .csproj patterns ───────────────────────────────────────────────
+
+/** ProjectReference Include="..." */
+const PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
+
+/** PackageReference Include="..." with optional Version="..." */
+const PACKAGE_REF_RE = /<PackageReference\s+Include="([^"]+)"(?:[^/]*?Version="([^"]+)")?/g;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Walk UP from startDir looking for a .csproj file in each directory.
+ * Stops at repoRoot or after maxLevels iterations.
+ */
+function findCsprojFile(startDir: string, repoRoot: string, maxLevels = 5): string | null {
+	let current = startDir;
+
+	for (let level = 0; level < maxLevels; level++) {
+		let entries: string[] = [];
+		try {
+			entries = readdirSync(current) as string[];
+		} catch {
+			return null;
+		}
+
+		const csproj = entries.find((e) => e.endsWith(".csproj"));
+		if (csproj) {
+			const fullPath = join(current, csproj);
+			if (existsSync(fullPath)) {
+				return fullPath;
+			}
+		}
+
+		if (current === repoRoot) break;
+
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+
+	return null;
+}
+
+/**
+ * Extract C# code entities from .cs source and project dependencies from an
+ * adjacent .csproj file.
+ *
+ * Phase 1: methods, classes/interfaces/structs/enums/records, properties, usings.
+ * Phase 2: walks up directories to find a .csproj, then extracts ProjectReference
+ *          and PackageReference entries.
+ */
+export function extractCSharpProject(
+	content: string,
+	filePath: string,
+	repoRoot?: string,
+): CandidateFact[] {
+	if (extname(filePath).toLowerCase() !== ".cs") return [];
+	if (!content) return [];
+
+	const base = basename(filePath);
+	const facts: CandidateFact[] = [];
+	const seen = new Set<string>();
+
+	// ── Phase 1: code entity extraction ──────────────────────────────────────
+
+	// Methods
+	{
+		const re = new RegExp(METHOD_RE.source, METHOD_RE.flags);
+		let m = re.exec(content);
+		while (m !== null) {
+			const name = m[2];
+			if (name) {
+				const key = `method:${name}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					facts.push({
+						type: "CodeEntity",
+						name,
+						content: m[0].trim(),
+						summary: `method ${name} in ${base}`,
+						tags: ["csharp", "method"],
+						file_paths: [filePath],
+						trust_tier: 2,
+						confidence: 0.92,
+					});
+				}
+			}
+			m = re.exec(content);
+		}
+	}
+
+	// Classes, interfaces, structs, enums, records
+	{
+		const re = new RegExp(CLASS_RE.source, CLASS_RE.flags);
+		let m = re.exec(content);
+		while (m !== null) {
+			const kind = m[1];
+			const name = m[2];
+			if (name && kind) {
+				const key = `class:${name}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					facts.push({
+						type: "CodeEntity",
+						name,
+						content: m[0].trim(),
+						summary: `${kind} ${name} in ${base}`,
+						tags: ["csharp", "class"],
+						file_paths: [filePath],
+						trust_tier: 2,
+						confidence: 0.92,
+					});
+				}
+			}
+			m = re.exec(content);
+		}
+	}
+
+	// Properties
+	{
+		const re = new RegExp(PROPERTY_RE.source, PROPERTY_RE.flags);
+		let m = re.exec(content);
+		while (m !== null) {
+			const name = m[2];
+			if (name) {
+				const key = `property:${name}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					facts.push({
+						type: "CodeEntity",
+						name,
+						content: m[0].trim(),
+						summary: `property ${name} in ${base}`,
+						tags: ["csharp", "property"],
+						file_paths: [filePath],
+						trust_tier: 2,
+						confidence: 0.92,
+					});
+				}
+			}
+			m = re.exec(content);
+		}
+	}
+
+	// Using statements
+	{
+		const re = new RegExp(USING_RE.source, USING_RE.flags);
+		let m = re.exec(content);
+		while (m !== null) {
+			const name = m[1];
+			if (name) {
+				const key = `using:${name}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					facts.push({
+						type: "CodeEntity",
+						name,
+						content: m[0].trim(),
+						summary: `using ${name} in ${base}`,
+						tags: ["csharp", "using"],
+						file_paths: [filePath],
+						trust_tier: 2,
+						confidence: 0.92,
+					});
+				}
+			}
+			m = re.exec(content);
+		}
+	}
+
+	// ── Phase 2: .csproj dependency extraction ────────────────────────────────
+
+	const searchRoot = repoRoot ?? dirname(filePath);
+	const csprojPath = findCsprojFile(dirname(filePath), searchRoot);
+
+	if (csprojPath) {
+		let csprojContent: string;
+		try {
+			csprojContent = readFileSync(csprojPath, "utf8") as string;
+		} catch {
+			return facts;
+		}
+
+		// ProjectReference entries
+		{
+			const re = new RegExp(PROJECT_REF_RE.source, PROJECT_REF_RE.flags);
+			let m = re.exec(csprojContent);
+			while (m !== null) {
+				const include = m[1];
+				if (include) {
+					facts.push({
+						type: "Dependency",
+						name: include,
+						content: m[0].trim(),
+						summary: `ProjectReference ${include} in ${basename(csprojPath)}`,
+						tags: ["project-reference", "csharp"],
+						file_paths: [filePath, csprojPath],
+						trust_tier: 2,
+						confidence: 0.9,
+						extraction_method: "csharp-project",
+					});
+				}
+				m = re.exec(csprojContent);
+			}
+		}
+
+		// PackageReference entries
+		{
+			const re = new RegExp(PACKAGE_REF_RE.source, PACKAGE_REF_RE.flags);
+			let m = re.exec(csprojContent);
+			while (m !== null) {
+				const pkgName = m[1];
+				const version = m[2];
+				if (pkgName) {
+					const contentStr = version ? `${pkgName} ${version}` : pkgName;
+					facts.push({
+						type: "Dependency",
+						name: pkgName,
+						content: contentStr,
+						summary: version
+							? `PackageReference ${pkgName} v${version} in ${basename(csprojPath)}`
+							: `PackageReference ${pkgName} in ${basename(csprojPath)}`,
+						tags: ["package-reference", "csharp", "nuget"],
+						file_paths: [filePath, csprojPath],
+						trust_tier: 2,
+						confidence: 0.9,
+						extraction_method: "csharp-project",
+					});
+				}
+				m = re.exec(csprojContent);
+			}
+		}
+	}
+
+	return facts;
+}

package/src/ast/extractors/prisma-schema.ts

@@ -0,0 +1,44 @@
+// Module: prisma-schema — Regex-based Prisma model extraction
+
+import type { CandidateFact } from "@/capture/types";
+
+/**
+ * Extract model entities from Prisma schema files using regex patterns.
+ * Recognises `model <Name> { ... }` blocks.
+ */
+export function extractPrismaSchema(content: string, filePath: string): CandidateFact[] {
+	const facts: CandidateFact[] = [];
+
+	const modelRe = /model\s+(\w+)\s*\{([^}]*)}/g;
+	let match: RegExpExecArray | null = modelRe.exec(content);
+	while (match !== null) {
+		const name = match[1];
+		const body = match[2].trim();
+
+		// Build a summary from the field lines
+		const fields = body
+			.split("\n")
+			.map((l) => l.trim())
+			.filter((l) => l.length > 0 && !l.startsWith("//") && !l.startsWith("@@"));
+
+		const summary =
+			fields.length > 0
+				? `Prisma model ${name}: ${fields.slice(0, 5).join(", ")}${fields.length > 5 ? "..." : ""}`
+				: `Prisma model: ${name}`;
+
+		facts.push({
+			type: "CodeEntity",
+			name,
+			content: match[0],
+			summary,
+			tags: ["model"],
+			file_paths: [filePath],
+			trust_tier: 2,
+			confidence: 0.9,
+			extraction_method: "prisma-schema",
+		});
+		match = modelRe.exec(content);
+	}
+
+	return facts;
+}

package/src/ast/extractors/project-manifest.ts

@@ -0,0 +1,111 @@
+// Module: project-manifest — Cargo.toml/go.mod/pyproject.toml dependency extraction
+
+import { basename } from "node:path";
+import type { CandidateFact } from "@/capture/types";
+
+/**
+ * Extract dependency / workspace-member facts from project manifest files.
+ *
+ * Supported formats:
+ * - Cargo.toml: `members = ["pkg-a", "pkg-b"]` under [workspace]
+ * - go.mod: `replace ... => <local-path>` directives
+ * - pyproject.toml: `path = "..."` dependency references
+ */
+export function extractManifest(content: string, filePath: string): CandidateFact[] {
+	const file = basename(filePath).toLowerCase();
+
+	if (file === "cargo.toml") {
+		return extractCargoMembers(content, filePath);
+	}
+	if (file === "go.mod") {
+		return extractGoModReplace(content, filePath);
+	}
+	if (file === "pyproject.toml" || file === "setup.py" || file === "setup.cfg") {
+		return extractPyprojectPaths(content, filePath);
+	}
+
+	return [];
+}
+
+/** Extract workspace members from Cargo.toml */
+function extractCargoMembers(content: string, filePath: string): CandidateFact[] {
+	const facts: CandidateFact[] = [];
+
+	// Match members = ["a", "b", "c"] -- possibly multiline
+	const membersRe = /members\s*=\s*\[([^\]]*)\]/gs;
+	let match: RegExpExecArray | null = membersRe.exec(content);
+	while (match !== null) {
+		const block = match[1];
+		const entryRe = /"([^"]+)"/g;
+		let entry: RegExpExecArray | null = entryRe.exec(block);
+		while (entry !== null) {
+			facts.push({
+				type: "Dependency",
+				name: entry[1],
+				content: `workspace member: ${entry[1]}`,
+				summary: `Cargo workspace member: ${entry[1]}`,
+				tags: ["workspace-member"],
+				file_paths: [filePath],
+				trust_tier: 2,
+				confidence: 0.85,
+				extraction_method: "manifest",
+			});
+			entry = entryRe.exec(block);
+		}
+		match = membersRe.exec(content);
+	}
+
+	return facts;
+}
+
+/** Extract replace directives from go.mod */
+function extractGoModReplace(content: string, filePath: string): CandidateFact[] {
+	const facts: CandidateFact[] = [];
+
+	// replace <module> => <local-path>
+	const replaceRe = /replace\s+\S+\s+=>\s+(\S+)/gm;
+	let match: RegExpExecArray | null = replaceRe.exec(content);
+	while (match !== null) {
+		const localPath = match[1];
+		facts.push({
+			type: "Dependency",
+			name: localPath,
+			content: match[0],
+			summary: `go.mod replace: ${localPath}`,
+			tags: ["replace"],
+			file_paths: [filePath],
+			trust_tier: 2,
+			confidence: 0.85,
+			extraction_method: "manifest",
+		});
+		match = replaceRe.exec(content);
+	}
+
+	return facts;
+}
+
+/** Extract path dependencies from pyproject.toml */
+function extractPyprojectPaths(content: string, filePath: string): CandidateFact[] {
+	const facts: CandidateFact[] = [];
+
+	// path = "some/local/path"
+	const pathRe = /path\s*=\s*"([^"]+)"/g;
+	let match: RegExpExecArray | null = pathRe.exec(content);
+	while (match !== null) {
+		const localPath = match[1];
+		facts.push({
+			type: "Dependency",
+			name: localPath,
+			content: match[0],
+			summary: `pyproject path dependency: ${localPath}`,
+			tags: ["path-dependency"],
+			file_paths: [filePath],
+			trust_tier: 2,
+			confidence: 0.85,
+			extraction_method: "manifest",
+		});
+		match = pathRe.exec(content);
+	}
+
+	return facts;
+}

package/src/ast/extractors/sql-schema.ts

@@ -0,0 +1,67 @@
+// Module: sql-schema — Regex-based SQL CREATE TABLE/INDEX extraction
+
+import type { CandidateFact } from "@/capture/types";
+
+/**
+ * Extract schema entities from SQL files using regex patterns.
+ * Recognises CREATE TABLE and CREATE INDEX statements.
+ */
+export function extractSqlSchema(content: string, filePath: string): CandidateFact[] {
+	const facts: CandidateFact[] = [];
+
+	// CREATE TABLE
+	const tableRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)/gi;
+	let match: RegExpExecArray | null = tableRe.exec(content);
+	while (match !== null) {
+		const name = match[1];
+		facts.push({
+			type: "CodeEntity",
+			name,
+			content: surroundingContext(content, match.index),
+			summary: `SQL table: ${name}`,
+			tags: ["table"],
+			file_paths: [filePath],
+			trust_tier: 2,
+			confidence: 0.9,
+			extraction_method: "sql-schema",
+		});
+		match = tableRe.exec(content);
+	}
+
+	// CREATE INDEX
+	const indexRe = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)/gi;
+	let idxMatch: RegExpExecArray | null = indexRe.exec(content);
+	while (idxMatch !== null) {
+		const name = idxMatch[1];
+		facts.push({
+			type: "CodeEntity",
+			name,
+			content: surroundingContext(content, idxMatch.index),
+			summary: `SQL index: ${name}`,
+			tags: ["index"],
+			file_paths: [filePath],
+			trust_tier: 2,
+			confidence: 0.9,
+			extraction_method: "sql-schema",
+		});
+		idxMatch = indexRe.exec(content);
+	}
+
+	return facts;
+}
+
+/** Return a few lines surrounding the match position for context. */
+function surroundingContext(content: string, matchIndex: number): string {
+	const before = content.lastIndexOf("\n", matchIndex);
+	const lineStart = before === -1 ? 0 : before + 1;
+	let end = matchIndex;
+	for (let i = 0; i < 5; i++) {
+		const next = content.indexOf("\n", end + 1);
+		if (next === -1) {
+			end = content.length;
+			break;
+		}
+		end = next;
+	}
+	return content.slice(lineStart, end).trim();
+}