pi-harness-runtime 0.10.11 → 0.10.12

package/packages/framework-detector/src/detector.ts

@@ -0,0 +1,586 @@
+/**
+ * Framework Detector - Detector
+ *
+ * Main framework detection engine.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import type {
+	DetectionResult,
+	DetectorConfig,
+	FrameworkSignature,
+	MatchedSignal,
+	PackageJson,
+	ProjectAnalysis,
+	ScanOptions,
+	ScanResult,
+	ScannedFile,
+} from "./types.js";
+import { SignatureRegistry } from "./signatures/registry.js";
+
+// --- Default Configuration -------------------------------------------------
+
+const DEFAULT_CONFIG: Required<DetectorConfig> = {
+	confidenceThreshold: 0.3,
+	detectVersions: true,
+	resolveImplications: true,
+	cache: true,
+	cacheTtlMs: 5 * 60 * 1000, // 5 minutes
+	timeoutMs: 30000, // 30 seconds
+	signatures: [],
+};
+
+// --- Framework Detector ----------------------------------------------------
+
+export class FrameworkDetector {
+	private readonly config: Required<DetectorConfig>;
+	private readonly registry: SignatureRegistry;
+	private readonly scanCache: Map<
+		string,
+		{ result: ScanResult; timestamp: number }
+	> = new Map();
+
+	constructor(config: DetectorConfig = {}) {
+		this.config = { ...DEFAULT_CONFIG, ...config };
+		this.registry = new SignatureRegistry();
+
+		// Add custom signatures
+		if (this.config.signatures) {
+			for (const sig of this.config.signatures) {
+				this.registry.register(sig);
+			}
+		}
+	}
+
+	/**
+	 * Detect frameworks in a project
+	 */
+	async detect(projectPath: string): Promise<ProjectAnalysis> {
+		const startTime = Date.now();
+
+		// Scan project
+		const scanResult = await this.scan({ rootPath: projectPath });
+
+		// Get package.json
+		const packageJson = this.parsePackageJson(scanResult);
+
+		// Detect frameworks
+		const results = await this.detectFrameworks(scanResult, packageJson);
+
+		// Determine primary framework
+		const primaryFramework = this.determinePrimaryFramework(results);
+
+		// Detect language
+		const language = this.detectLanguage(scanResult);
+
+		// Detect package manager
+		const packageManager = this.detectPackageManager(scanResult);
+
+		return {
+			projectPath,
+			frameworks: results,
+			primaryFramework,
+			language,
+			packageManager,
+			hasTypeScript: scanResult.configs.some((c) =>
+				c.name.includes("tsconfig"),
+			),
+			hasTests: scanResult.configs.some((c) =>
+				["jest", "vitest", "cypress", "playwright", "pytest", "rspec"].some(
+					(t) => c.name.includes(t),
+				),
+			),
+			files: scanResult.files,
+			scanTimeMs: Date.now() - startTime,
+		};
+	}
+
+	/**
+	 * Scan project files
+	 */
+	async scan(options: ScanOptions): Promise<ScanResult> {
+		const { rootPath, maxDepth = 5 } = options;
+
+		// Check cache
+		const cacheKey = `${rootPath}:${maxDepth}`;
+		if (this.config.cache) {
+			const cached = this.scanCache.get(cacheKey);
+			if (cached && Date.now() - cached.timestamp < this.config.cacheTtlMs) {
+				return cached.result;
+			}
+		}
+
+		const files: ScannedFile[] = [];
+		const configs: ScanResult["configs"] = [];
+		let packageJson: PackageJson | undefined;
+
+		// Scan directory recursively
+		await this.scanDirectory(rootPath, files, configs, 0, maxDepth);
+
+		// Look for package.json
+		const packagePath = join(rootPath, "package.json");
+		if (existsSync(packagePath)) {
+			try {
+				const content = readFileSync(packagePath, "utf-8");
+				packageJson = JSON.parse(content) as PackageJson;
+				configs.push({
+					path: packagePath,
+					name: "package.json",
+					content,
+					type: "package",
+				});
+			} catch {
+				// Ignore parse errors
+			}
+		}
+
+		// Look for other config files
+		const configPatterns = [
+			"tsconfig.json",
+			"jsconfig.json",
+			"vite.config.js",
+			"vite.config.ts",
+			"next.config.js",
+			"next.config.mjs",
+			"nuxt.config.ts",
+			"webpack.config.js",
+			"babel.config.js",
+			"jest.config.js",
+			"vitest.config.ts",
+			"python.toml",
+			"pyproject.toml",
+			"requirements.txt",
+			"go.mod",
+			"Cargo.toml",
+			"pom.xml",
+			"build.gradle",
+			"docker-compose.yml",
+			"Dockerfile",
+		];
+
+		for (const configName of configPatterns) {
+			const configPath = join(rootPath, configName);
+			if (existsSync(configPath)) {
+				try {
+					const content = readFileSync(configPath, "utf-8");
+					configs.push({
+						path: configPath,
+						name: configName,
+						content,
+						type: this.getConfigType(configName),
+					});
+				} catch {
+					// Ignore read errors
+				}
+			}
+		}
+
+		const result: ScanResult = {
+			files,
+			packageJson,
+			configs,
+			scanTimeMs: 0,
+		};
+
+		// Cache result
+		if (this.config.cache) {
+			this.scanCache.set(cacheKey, {
+				result,
+				timestamp: Date.now(),
+			});
+		}
+
+		return result;
+	}
+
+	/**
+	 * Scan directory recursively
+	 */
+	private async scanDirectory(
+		dir: string,
+		files: ScannedFile[],
+		configs: ScanResult["configs"],
+		depth: number,
+		maxDepth: number,
+	): Promise<void> {
+		if (depth > maxDepth) return;
+
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+
+			for (const entry of entries) {
+				const fullPath = join(dir, entry.name);
+
+				// Skip common directories to ignore
+				if (
+					entry.isDirectory() &&
+					[
+						"node_modules",
+						".git",
+						"dist",
+						"build",
+						"__pycache__",
+						".venv",
+						"venv",
+						"target",
+					].includes(entry.name)
+				) {
+					continue;
+				}
+
+				if (entry.isFile()) {
+					const ext = extname(entry.name);
+					const name = basename(entry.name);
+
+					files.push({
+						path: fullPath,
+						exists: true,
+						matches: [ext, name],
+					});
+				} else if (entry.isDirectory()) {
+					await this.scanDirectory(
+						fullPath,
+						files,
+						configs,
+						depth + 1,
+						maxDepth,
+					);
+				}
+			}
+		} catch {
+			// Ignore permission errors
+		}
+	}
+
+	/**
+	 * Parse package.json
+	 */
+	private parsePackageJson(scanResult: ScanResult): PackageJson | undefined {
+		return scanResult.packageJson;
+	}
+
+	/**
+	 * Detect frameworks from scan result
+	 */
+	private async detectFrameworks(
+		scanResult: ScanResult,
+		packageJson?: PackageJson,
+	): Promise<DetectionResult[]> {
+		const results: DetectionResult[] = [];
+		const signatures = this.registry.list();
+
+		// Create dependency map
+		const dependencies = new Set<string>();
+		if (packageJson?.dependencies) {
+			for (const dep of Object.keys(packageJson.dependencies)) {
+				dependencies.add(dep);
+			}
+		}
+		if (packageJson?.devDependencies) {
+			for (const dep of Object.keys(packageJson.devDependencies)) {
+				dependencies.add(dep);
+			}
+		}
+
+		// Create file name set
+		const fileNames = new Set<string>();
+		for (const file of scanResult.files) {
+			fileNames.add(basename(file.path));
+			fileNames.add(extname(file.path).slice(1)); // Extension without dot
+		}
+
+		// Create config set
+		const configNames = new Set<string>();
+		for (const config of scanResult.configs) {
+			configNames.add(config.name);
+		}
+
+		// Check each signature
+		for (const signature of signatures) {
+			const matchedSignals = this.matchSignature(signature, {
+				dependencies,
+				fileNames,
+				configNames,
+				scanResult,
+			});
+
+			if (matchedSignals.length > 0) {
+				const confidence = this.calculateConfidence(matchedSignals, signature);
+
+				if (confidence >= this.config.confidenceThreshold) {
+					results.push({
+						framework: {
+							id: signature.id,
+							name: signature.name,
+							category: signature.category,
+							description: signature.description,
+							tags: signature.tags ?? [],
+						},
+						confidence,
+						signals: matchedSignals,
+						version: packageJson?.dependencies?.[signature.id],
+					});
+				}
+			}
+		}
+
+		// Sort by confidence
+		results.sort((a, b) => b.confidence - a.confidence);
+
+		// Resolve implications
+		if (this.config.resolveImplications) {
+			this.resolveImplications(results, signatures);
+		}
+
+		return results;
+	}
+
+	/**
+	 * Match signature against scan data
+	 */
+	private matchSignature(
+		signature: FrameworkSignature,
+		data: {
+			dependencies: Set<string>;
+			fileNames: Set<string>;
+			configNames: Set<string>;
+			scanResult: ScanResult;
+		},
+	): MatchedSignal[] {
+		const matches: MatchedSignal[] = [];
+
+		for (const signal of signature.signals) {
+			let matched = false;
+			let matchValue = "";
+
+			switch (signal.type) {
+				case "package":
+				case "dependency":
+					// Check if dependency exists
+					if (data.dependencies.has(signal.pattern)) {
+						matched = true;
+						matchValue = signal.pattern;
+					}
+					break;
+
+				case "file":
+					// Check if file exists
+					if (data.fileNames.has(signal.pattern)) {
+						matched = true;
+						matchValue = signal.pattern;
+					}
+					break;
+
+				case "config":
+					// Check if config exists
+					if (data.configNames.has(signal.pattern)) {
+						matched = true;
+						matchValue = signal.pattern;
+					}
+					break;
+
+				case "directory":
+					// Check if directory exists
+					for (const file of data.scanResult.files) {
+						if (file.path.includes(signal.pattern)) {
+							matched = true;
+							matchValue = signal.pattern;
+							break;
+						}
+					}
+					break;
+
+				case "import":
+					// Check if import pattern exists in code
+					for (const config of data.scanResult.configs) {
+						if (config.content?.includes(signal.pattern)) {
+							matched = true;
+							matchValue = signal.pattern;
+							break;
+						}
+					}
+					break;
+			}
+
+			if (matched) {
+				matches.push({
+					signal,
+					match: matchValue,
+					weight: signal.weight,
+				});
+			}
+		}
+
+		return matches;
+	}
+
+	/**
+	 * Calculate confidence score
+	 */
+	private calculateConfidence(
+		matchedSignals: MatchedSignal[],
+		signature: FrameworkSignature,
+	): number {
+		if (signature.signals.length === 0) return 0;
+
+		const totalWeight = matchedSignals.reduce((sum, m) => sum + m.weight, 0);
+		const maxWeight = signature.signals.reduce((sum, s) => sum + s.weight, 0);
+
+		return maxWeight > 0 ? totalWeight / maxWeight : 0;
+	}
+
+	/**
+	 * Determine primary framework
+	 */
+	private determinePrimaryFramework(
+		results: DetectionResult[],
+	): DetectionResult | undefined {
+		if (results.length === 0) return undefined;
+
+		// Return the highest confidence result
+		return results[0];
+	}
+
+	/**
+	 * Detect programming language
+	 */
+	private detectLanguage(scanResult: ScanResult): string | undefined {
+		const extCounts: Record<string, number> = {};
+
+		for (const file of scanResult.files) {
+			const ext = extname(file.path).toLowerCase();
+			if (ext) {
+				extCounts[ext] = (extCounts[ext] ?? 0) + 1;
+			}
+		}
+
+		// Language detection based on extensions
+		const langMap: Record<string, string> = {
+			".ts": "TypeScript",
+			".tsx": "TypeScript",
+			".js": "JavaScript",
+			".jsx": "JavaScript",
+			".py": "Python",
+			".java": "Java",
+			".go": "Go",
+			".rs": "Rust",
+			".rb": "Ruby",
+			".php": "PHP",
+			".cs": "C#",
+			".cpp": "C++",
+			".c": "C",
+			".swift": "Swift",
+			".kt": "Kotlin",
+			".dart": "Dart",
+		};
+
+		let maxCount = 0;
+		let detectedLang = "";
+
+		for (const [ext, lang] of Object.entries(langMap)) {
+			if ((extCounts[ext] ?? 0) > maxCount) {
+				maxCount = extCounts[ext] ?? 0;
+				detectedLang = lang;
+			}
+		}
+
+		return detectedLang || undefined;
+	}
+
+	/**
+	 * Detect package manager
+	 */
+	private detectPackageManager(
+		scanResult: ScanResult,
+	): "npm" | "yarn" | "pnpm" | "bun" | undefined {
+		const names = new Set(scanResult.configs.map((c) => c.name));
+
+		if (names.has("pnpm-lock.yaml")) return "pnpm";
+		if (names.has("yarn.lock")) return "yarn";
+		if (names.has("bun.lockb")) return "bun";
+		if (names.has("package-lock.json")) return "npm";
+
+		return undefined;
+	}
+
+	/**
+	 * Resolve framework implications
+	 */
+	private resolveImplications(
+		results: DetectionResult[],
+		signatures: FrameworkSignature[],
+	): void {
+		for (const result of results) {
+			const signature = signatures.find((s) => s.id === result.framework.id);
+			if (!signature?.implies) continue;
+
+			for (const impliedId of signature.implies) {
+				// Check if already detected
+				if (results.some((r) => r.framework.id === impliedId)) continue;
+
+				// Check if signature exists
+				const impliedSig = signatures.find((s) => s.id === impliedId);
+				if (!impliedSig) continue;
+
+				// Add implied framework with reduced confidence
+				results.push({
+					framework: {
+						id: impliedSig.id,
+						name: impliedSig.name,
+						category: impliedSig.category,
+						description: impliedSig.description,
+						tags: impliedSig.tags ?? [],
+					},
+					confidence: result.confidence * 0.8, // Reduced confidence for implied
+					signals: [],
+					metadata: { implied: true, from: result.framework.id },
+				});
+			}
+		}
+
+		// Re-sort after adding implied frameworks
+		results.sort((a, b) => b.confidence - a.confidence);
+	}
+
+	/**
+	 * Get config type
+	 */
+	private getConfigType(configName: string): string {
+		if (configName.endsWith(".json")) return "json";
+		if (configName.endsWith(".js") || configName.endsWith(".mjs"))
+			return "javascript";
+		if (configName.endsWith(".ts")) return "typescript";
+		if (configName.endsWith(".yml") || configName.endsWith(".yaml"))
+			return "yaml";
+		if (configName.endsWith(".toml")) return "toml";
+		if (configName.endsWith(".xml")) return "xml";
+		return "unknown";
+	}
+
+	/**
+	 * Clear cache
+	 */
+	clearCache(): void {
+		this.scanCache.clear();
+	}
+
+	/**
+	 * Get registry
+	 */
+	getRegistry(): SignatureRegistry {
+		return this.registry;
+	}
+}
+
+// --- Factory Function ------------------------------------------------------
+
+/**
+ * Create a framework detector
+ */
+export function createFrameworkDetector(
+	config?: DetectorConfig,
+): FrameworkDetector {
+	return new FrameworkDetector(config);
+}

package/packages/framework-detector/src/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Framework Detector
+ *
+ * Intelligent framework detection system with confidence scoring.
+ */
+
+// --- Detector ----------------------------------------------------------
+
+export {
+	FrameworkDetector,
+	createFrameworkDetector,
+} from "./detector.js";
+
+// --- Signatures --------------------------------------------------------
+
+export {
+	SignatureRegistry,
+	getDefaultSignatures,
+} from "./signatures/registry.js";
+
+// --- Types -----------------------------------------------------------
+
+export {
+	SDK_VERSION,
+	type FrameworkCategory,
+	type FrameworkSignature,
+	type DetectionSignal,
+	type SignalType,
+	type DetectionResult,
+	type FrameworkInfo,
+	type MatchedSignal,
+	type ProjectAnalysis,
+	type ScannedFile,
+	type PackageManager,
+	type FilePattern,
+	type ProjectType,
+	type VersionDetectionResult,
+	type VersionParser,
+	type ScanOptions,
+	type ScanResult,
+	type PackageJson,
+	type ConfigFile,
+	type WatchEvent,
+	type WatcherOptions,
+	type DetectorConfig,
+} from "./types.js";