@rkarim08/sia 1.0.0

package/src/workspace/api-contracts.ts

@@ -0,0 +1,226 @@
+// Module: api-contracts — API contract auto-detection scanner
+import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import type { SiaDb } from "@/graph/db-interface";
+
+export interface DetectedContract {
+	type: string;
+	specPath: string;
+}
+
+/**
+ * Scan a repository directory for API contracts.
+ * Returns detected contracts — does NOT write to the database.
+ */
+export async function detectApiContracts(repoPath: string): Promise<DetectedContract[]> {
+	const contracts: DetectedContract[] = [];
+
+	// OpenAPI / Swagger
+	for (const name of ["openapi.yaml", "openapi.json", "swagger.yaml", "swagger.json"]) {
+		if (existsSync(join(repoPath, name))) {
+			contracts.push({ type: "openapi", specPath: name });
+		}
+	}
+
+	// GraphQL — root level
+	const rootFiles = safeReaddir(repoPath);
+	for (const entry of rootFiles) {
+		if (entry.isFile() && entry.name.endsWith(".graphql")) {
+			contracts.push({ type: "graphql", specPath: entry.name });
+		}
+	}
+	// GraphQL — recursive (depth 3)
+	findFilesRecursive(repoPath, ".graphql", contracts, repoPath, 3);
+
+	// TypeScript project references
+	const tsconfigPath = join(repoPath, "tsconfig.json");
+	if (existsSync(tsconfigPath)) {
+		try {
+			const tsconfig = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
+			if (Array.isArray(tsconfig.references)) {
+				for (const ref of tsconfig.references) {
+					if (typeof ref.path === "string") {
+						contracts.push({ type: "ts-reference", specPath: ref.path });
+					}
+				}
+			}
+		} catch {
+			/* ignore */
+		}
+	}
+
+	// C# .csproj ProjectReference
+	for (const entry of rootFiles) {
+		if (entry.isFile() && entry.name.endsWith(".csproj")) {
+			try {
+				const content = readFileSync(join(repoPath, entry.name), "utf-8");
+				const refPattern = /ProjectReference\s+Include="([^"]+)"/g;
+				let match: RegExpExecArray | null = refPattern.exec(content);
+				while (match !== null) {
+					contracts.push({ type: "csproj-reference", specPath: match[1] });
+					match = refPattern.exec(content);
+				}
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+
+	// Cargo.toml workspace members
+	const cargoPath = join(repoPath, "Cargo.toml");
+	if (existsSync(cargoPath)) {
+		try {
+			const content = readFileSync(cargoPath, "utf-8");
+			const membersMatch = content.match(/members\s*=\s*\[([^\]]+)\]/);
+			if (membersMatch) {
+				const members = membersMatch[1]
+					.split(",")
+					.map((m) => m.trim().replace(/^["']|["']$/g, ""))
+					.filter(Boolean);
+				for (const member of members) {
+					contracts.push({ type: "cargo-dependency", specPath: member });
+				}
+			}
+		} catch {
+			/* ignore */
+		}
+	}
+
+	// go.mod replace directives
+	const goModPath = join(repoPath, "go.mod");
+	if (existsSync(goModPath)) {
+		try {
+			const content = readFileSync(goModPath, "utf-8");
+			const replacePattern = /replace\s+\S+\s+=>\s+(\S+)/g;
+			let match: RegExpExecArray | null = replacePattern.exec(content);
+			while (match !== null) {
+				contracts.push({ type: "go-mod-replace", specPath: match[1] });
+				match = replacePattern.exec(content);
+			}
+		} catch {
+			/* ignore */
+		}
+	}
+
+	// pyproject.toml path dependencies
+	const pyprojectPath = join(repoPath, "pyproject.toml");
+	if (existsSync(pyprojectPath)) {
+		try {
+			const content = readFileSync(pyprojectPath, "utf-8");
+			const pathPattern = /path\s*=\s*"([^"]+)"/g;
+			let match: RegExpExecArray | null = pathPattern.exec(content);
+			while (match !== null) {
+				contracts.push({ type: "python-path-dep", specPath: match[1] });
+				match = pathPattern.exec(content);
+			}
+		} catch {
+			/* ignore */
+		}
+	}
+
+	// Gradle settings.gradle / settings.gradle.kts
+	for (const name of ["settings.gradle", "settings.gradle.kts"]) {
+		const gradlePath = join(repoPath, name);
+		if (existsSync(gradlePath)) {
+			try {
+				const content = readFileSync(gradlePath, "utf-8");
+				const includePattern = /include\s*\(?([^\n)]+)\)?/g;
+				let lineMatch: RegExpExecArray | null = includePattern.exec(content);
+				while (lineMatch !== null) {
+					const parts = lineMatch[1].split(",");
+					for (const part of parts) {
+						const cleaned = part
+							.trim()
+							.replace(/^\(/, "")
+							.replace(/\)$/, "")
+							.replace(/^['"]/, "")
+							.replace(/['"]$/, "");
+						if (cleaned.startsWith(":")) {
+							contracts.push({
+								type: "gradle-project",
+								specPath: cleaned.slice(1).replace(/:/g, "/"),
+							});
+						}
+					}
+					lineMatch = includePattern.exec(content);
+				}
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+
+	return contracts;
+}
+
+function safeReaddir(dirPath: string) {
+	try {
+		return readdirSync(dirPath, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+
+/** Recursively find files by extension, avoiding duplicates with root-level scan. */
+function findFilesRecursive(
+	dir: string,
+	ext: string,
+	contracts: DetectedContract[],
+	rootDir: string,
+	maxDepth: number,
+): void {
+	if (maxDepth <= 0) return;
+	const entries = safeReaddir(dir);
+	for (const entry of entries) {
+		if (entry.name === "node_modules" || entry.name === ".git") continue;
+		if (entry.isDirectory()) {
+			const childDir = join(dir, entry.name);
+			const childEntries = safeReaddir(childDir);
+			for (const child of childEntries) {
+				if (child.isFile() && child.name.endsWith(ext)) {
+					const relPath = relative(rootDir, join(childDir, child.name));
+					// Don't duplicate root-level files
+					if (!contracts.some((c) => c.specPath === relPath)) {
+						contracts.push({ type: "graphql", specPath: relPath });
+					}
+				}
+			}
+			findFilesRecursive(childDir, ext, contracts, rootDir, maxDepth - 1);
+		}
+	}
+}
+
+/**
+ * Write detected contracts to api_contracts in meta.db with trust_tier=2.
+ * Idempotent: upserts by (provider_repo_id, contract_type, spec_path).
+ */
+export async function writeDetectedContracts(
+	db: SiaDb,
+	providerRepoId: string,
+	contracts: DetectedContract[],
+): Promise<void> {
+	const now = Date.now();
+
+	for (const contract of contracts) {
+		const existing = await db.execute(
+			`SELECT id FROM api_contracts
+       WHERE provider_repo_id = ? AND contract_type = ? AND spec_path = ?`,
+			[providerRepoId, contract.type, contract.specPath],
+		);
+
+		if (existing.rows.length > 0) {
+			await db.execute("UPDATE api_contracts SET detected_at = ? WHERE id = ?", [
+				now,
+				existing.rows[0]?.id as string,
+			]);
+			continue;
+		}
+
+		await db.execute(
+			`INSERT INTO api_contracts (id, provider_repo_id, consumer_repo_id, contract_type, spec_path, trust_tier, detected_at)
+       VALUES (?, ?, ?, ?, ?, 2, ?)`,
+			[randomUUID(), providerRepoId, providerRepoId, contract.type, contract.specPath, now],
+		);
+	}
+}

package/src/workspace/cross-repo.ts

@@ -0,0 +1,61 @@
+// Module: cross-repo — ATTACH/DETACH helpers and peer repo discovery
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { SiaDb } from "@/graph/db-interface";
+import { getWorkspaceRepos } from "@/graph/meta-db";
+import { SIA_HOME } from "@/shared/config";
+
+/** Info about a peer repo that can be ATTACHed for workspace search. */
+export interface PeerRepo {
+	repoId: string;
+	graphDbPath: string;
+	name: string | null;
+}
+
+/**
+ * Attach a peer repository database under the given alias.
+ *
+ * Uses a plain ATTACH DATABASE statement. Does NOT set WAL pragma on the
+ * attached connection — the caller opens it read-only.
+ */
+export async function attachPeerRepo(db: SiaDb, peerDbPath: string, alias: string): Promise<void> {
+	await db.execute(`ATTACH DATABASE ? AS ${alias}`, [peerDbPath]);
+}
+
+/**
+ * Detach a previously attached peer database.
+ */
+export async function detachPeerRepo(db: SiaDb, alias: string): Promise<void> {
+	await db.execute(`DETACH DATABASE ${alias}`, []);
+}
+
+/**
+ * Get peer repos for workspace search (all workspace repos except primaryRepoId).
+ * Only returns peers whose graph.db file exists on disk.
+ */
+export async function getPeerRepos(
+	metaDb: SiaDb,
+	workspaceId: string,
+	primaryRepoId: string,
+	siaHome: string = SIA_HOME,
+): Promise<PeerRepo[]> {
+	const allRepos = await getWorkspaceRepos(metaDb, workspaceId);
+	const peers: PeerRepo[] = [];
+
+	for (const repo of allRepos) {
+		const repoId = repo.id as string;
+		if (repoId === primaryRepoId) continue;
+
+		const graphDbPath = join(siaHome, "repos", repoId, "graph.db");
+		if (existsSync(graphDbPath)) {
+			peers.push({
+				repoId,
+				graphDbPath,
+				name: (repo.name as string | null) ?? (repo.path as string | null) ?? null,
+			});
+		}
+	}
+
+	return peers;
+}

package/src/workspace/detector.ts

@@ -0,0 +1,190 @@
+// Module: detector — Monorepo auto-detection and package registration
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import type { SiaDb } from "@/graph/db-interface";
+
+/**
+ * Detect monorepo packages from the repo root.
+ * Detection precedence:
+ * 1. pnpm-workspace.yaml
+ * 2. package.json "workspaces"
+ * 3. nx.json + project.json files
+ * 4. settings.gradle / settings.gradle.kts
+ * Turborepo (turbo.json) is informational only.
+ */
+export async function detectMonorepoPackages(repoRoot: string): Promise<string[]> {
+	// 1. pnpm-workspace.yaml
+	const pnpmPath = join(repoRoot, "pnpm-workspace.yaml");
+	if (existsSync(pnpmPath)) {
+		const content = readFileSync(pnpmPath, "utf-8");
+		const patterns = parsePnpmWorkspace(content);
+		if (patterns.length > 0) return expandGlobs(repoRoot, patterns);
+	}
+
+	// 2. package.json "workspaces"
+	const pkgJsonPath = join(repoRoot, "package.json");
+	if (existsSync(pkgJsonPath)) {
+		try {
+			const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+			const workspaces = pkgJson?.workspaces;
+			if (workspaces) {
+				const patterns = Array.isArray(workspaces) ? workspaces : (workspaces.packages ?? []);
+				if (patterns.length > 0) return expandGlobs(repoRoot, patterns as string[]);
+			}
+		} catch {
+			/* ignore malformed package.json */
+		}
+	}
+
+	// 3. Nx (nx.json + project.json files in subdirs)
+	if (existsSync(join(repoRoot, "nx.json"))) {
+		return findProjectJsonRoots(repoRoot);
+	}
+
+	// 4. Gradle (settings.gradle or settings.gradle.kts)
+	for (const name of ["settings.gradle", "settings.gradle.kts"]) {
+		const gradlePath = join(repoRoot, name);
+		if (existsSync(gradlePath)) {
+			const content = readFileSync(gradlePath, "utf-8");
+			const includes = parseGradleIncludes(content);
+			if (includes.length > 0) return includes;
+		}
+	}
+
+	// Turborepo: informational only
+	if (existsSync(join(repoRoot, "turbo.json"))) {
+		console.info(
+			"Turborepo project detected; package paths sourced from underlying package manager",
+		);
+	}
+
+	return [];
+}
+
+function parsePnpmWorkspace(content: string): string[] {
+	const patterns: string[] = [];
+	let inPackages = false;
+
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (/^packages:\s*$/.test(trimmed) || trimmed === "packages:") {
+			inPackages = true;
+			continue;
+		}
+		if (inPackages) {
+			if (trimmed.startsWith("- ")) {
+				const pattern = trimmed.slice(2).trim().replace(/^['"]/, "").replace(/['"]$/, "");
+				if (pattern) patterns.push(pattern);
+			} else if (trimmed && !trimmed.startsWith("#")) {
+				break;
+			}
+		}
+	}
+	return patterns;
+}
+
+function expandGlobs(repoRoot: string, patterns: string[]): string[] {
+	const results: string[] = [];
+	for (const pattern of patterns) {
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -2);
+			const parentDir = join(repoRoot, prefix);
+			if (existsSync(parentDir)) {
+				const entries = readdirSync(parentDir, { withFileTypes: true });
+				for (const entry of entries) {
+					if (entry.isDirectory()) {
+						results.push(`${prefix}/${entry.name}`);
+					}
+				}
+			}
+		} else {
+			if (existsSync(join(repoRoot, pattern))) {
+				results.push(pattern);
+			}
+		}
+	}
+	return results.sort();
+}
+
+function findProjectJsonRoots(repoRoot: string): string[] {
+	const results: string[] = [];
+	walkForFile(repoRoot, "project.json", results, repoRoot, 3);
+	return results.sort();
+}
+
+function walkForFile(
+	dir: string,
+	filename: string,
+	results: string[],
+	rootDir: string,
+	maxDepth: number,
+): void {
+	if (maxDepth <= 0) return;
+	let entries: import("node:fs").Dirent[];
+	try {
+		entries = readdirSync(dir, { withFileTypes: true }) as import("node:fs").Dirent[];
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if ((entry.name as string) === "node_modules" || (entry.name as string) === ".git") continue;
+		if (entry.isDirectory()) {
+			const childPath = join(dir, entry.name as string);
+			if (existsSync(join(childPath, filename))) {
+				results.push(relative(rootDir, childPath));
+			}
+			walkForFile(childPath, filename, results, rootDir, maxDepth - 1);
+		}
+	}
+}
+
+function parseGradleIncludes(content: string): string[] {
+	const results: string[] = [];
+	const includePattern = /include\s*\(?([^\n)]+)\)?/g;
+	let lineMatch: RegExpExecArray | null = includePattern.exec(content);
+	while (lineMatch !== null) {
+		const parts = lineMatch[1].split(",");
+		for (const part of parts) {
+			const cleaned = part
+				.trim()
+				.replace(/^\(/, "")
+				.replace(/\)$/, "")
+				.replace(/^['"]/, "")
+				.replace(/['"]$/, "");
+			if (cleaned.startsWith(":")) {
+				results.push(cleaned.slice(1).replace(/:/g, "/"));
+			}
+		}
+		lineMatch = includePattern.exec(content);
+	}
+	return [...new Set(results)].sort();
+}
+
+/**
+ * Register detected monorepo packages in meta.db.
+ */
+export async function registerMonorepoPackages(
+	db: SiaDb,
+	rootRepoId: string,
+	rootPath: string,
+	packagePaths: string[],
+): Promise<void> {
+	await db.execute("UPDATE repos SET detected_type = 'monorepo_root' WHERE id = ?", [rootRepoId]);
+
+	for (const pkgPath of packagePaths) {
+		const fullPath = resolve(rootPath, pkgPath);
+		const id = createHash("sha256").update(fullPath).digest("hex");
+		const now = Date.now();
+
+		await db.execute(
+			`INSERT INTO repos (id, path, name, detected_type, monorepo_root_id, created_at, last_accessed)
+       VALUES (?, ?, ?, 'monorepo_package', ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         detected_type = 'monorepo_package',
+         monorepo_root_id = ?,
+         last_accessed = ?`,
+			[id, fullPath, pkgPath, rootRepoId, now, now, rootRepoId, now],
+		);
+	}
+}

package/src/workspace/manifest.ts

@@ -0,0 +1,141 @@
+// Module: manifest — .sia-manifest.yaml parser and contract writer
+import { randomUUID } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+import type { SiaDb } from "@/graph/db-interface";
+
+export interface ManifestContract {
+	type: string;
+	path?: string;
+	package?: string;
+}
+
+export interface SiaManifest {
+	provides: ManifestContract[];
+	consumes: ManifestContract[];
+	depends_on: ManifestContract[];
+}
+
+/**
+ * Parse a .sia-manifest.yaml string into a SiaManifest.
+ * Returns null on malformed YAML (logs warning, never throws).
+ */
+export function parseManifest(content: string): SiaManifest | null {
+	let doc: Record<string, unknown>;
+	try {
+		doc = parseYaml(content) as Record<string, unknown>;
+	} catch (err) {
+		console.warn("sia-manifest.yaml: malformed YAML, skipping", err);
+		return null;
+	}
+
+	if (!doc || typeof doc !== "object") {
+		return { provides: [], consumes: [], depends_on: [] };
+	}
+
+	return {
+		provides: parseContractList(doc.provides),
+		consumes: parseContractList(doc.consumes),
+		depends_on: parseContractList(doc.depends_on),
+	};
+}
+
+function parseContractList(raw: unknown): ManifestContract[] {
+	if (!Array.isArray(raw)) return [];
+	return raw
+		.filter(
+			(item): item is Record<string, unknown> =>
+				item !== null && typeof item === "object" && typeof item.type === "string",
+		)
+		.map((item) => ({
+			type: item.type as string,
+			path: typeof item.path === "string" ? item.path : undefined,
+			package: typeof item.package === "string" ? item.package : undefined,
+		}));
+}
+
+/**
+ * Write manifest contracts to api_contracts in meta.db.
+ * All writes idempotent (upsert by provider+consumer+type).
+ */
+export async function writeManifestContracts(
+	db: SiaDb,
+	providerRepoId: string,
+	consumerRepoId: string,
+	manifest: SiaManifest,
+): Promise<void> {
+	const now = Date.now();
+
+	for (const contract of manifest.provides) {
+		await upsertContract(db, {
+			providerRepoId,
+			consumerRepoId,
+			type: contract.type,
+			specPath: contract.path ?? null,
+			trustTier: 1,
+			now,
+		});
+	}
+
+	for (const contract of manifest.depends_on) {
+		await upsertContract(db, {
+			providerRepoId: consumerRepoId,
+			consumerRepoId: providerRepoId,
+			type: contract.type,
+			specPath: contract.path ?? null,
+			trustTier: 1,
+			now,
+		});
+	}
+
+	for (const contract of manifest.consumes) {
+		await upsertContract(db, {
+			providerRepoId: consumerRepoId,
+			consumerRepoId: providerRepoId,
+			type: contract.type,
+			specPath: contract.path ?? contract.package ?? null,
+			trustTier: 1,
+			now,
+		});
+	}
+}
+
+async function upsertContract(
+	db: SiaDb,
+	opts: {
+		providerRepoId: string;
+		consumerRepoId: string;
+		type: string;
+		specPath: string | null;
+		trustTier: number;
+		now: number;
+	},
+): Promise<void> {
+	const existing = await db.execute(
+		`SELECT id FROM api_contracts
+     WHERE provider_repo_id = ? AND consumer_repo_id = ? AND contract_type = ?`,
+		[opts.providerRepoId, opts.consumerRepoId, opts.type],
+	);
+
+	if (existing.rows.length > 0) {
+		await db.execute("UPDATE api_contracts SET detected_at = ?, spec_path = ? WHERE id = ?", [
+			opts.now,
+			opts.specPath,
+			existing.rows[0]?.id as string,
+		]);
+		return;
+	}
+
+	await db.execute(
+		`INSERT INTO api_contracts (id, provider_repo_id, consumer_repo_id, contract_type, spec_path, trust_tier, detected_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+		[
+			randomUUID(),
+			opts.providerRepoId,
+			opts.consumerRepoId,
+			opts.type,
+			opts.specPath,
+			opts.trustTier,
+			opts.now,
+		],
+	);
+}