pi-harness-runtime 0.10.11 → 0.10.12

package/packages/project-analyzer/src/cache.ts

@@ -0,0 +1,329 @@
+/**
+ * Cache Management
+ *
+ * Provides caching functionality for project analysis results.
+ * Caches are keyed by repository revision and configuration file hashes.
+ */
+
+import { createHash } from "node:crypto";
+import {
+	readFile,
+	writeFile,
+	mkdir,
+	stat,
+	access,
+	constants,
+} from "node:fs/promises";
+import { join, dirname } from "node:path";
+import type { CacheEntry, CacheKey, ProjectProfile } from "./types.js";
+
+/**
+ * Default cache directory.
+ */
+const DEFAULT_CACHE_DIR = join(
+	process.env.HOME || "/tmp",
+	".pi",
+	"harness",
+	"analyzer-cache",
+);
+
+/**
+ * Cache options.
+ */
+export interface CacheOptions {
+	/** Cache directory path */
+	cacheDir?: string;
+	/** Maximum age in milliseconds before cache is considered stale */
+	maxAgeMs?: number;
+	/** Whether to use cache */
+	enabled?: boolean;
+}
+
+/**
+ * Cache manager for project analysis.
+ */
+export class AnalysisCache {
+	private cacheDir: string;
+	private maxAgeMs: number;
+	private enabled: boolean;
+
+	constructor(options: CacheOptions = {}) {
+		this.cacheDir = options.cacheDir || DEFAULT_CACHE_DIR;
+		this.maxAgeMs = options.maxAgeMs || 24 * 60 * 60 * 1000; // 24 hours
+		this.enabled = options.enabled !== false;
+	}
+
+	/**
+	 * Generate cache key from request parameters.
+	 */
+	generateKey(
+		repositoryRoot: string,
+		revision: string,
+		configHash: string,
+	): CacheKey {
+		return {
+			repositoryRoot,
+			revision,
+			configHash,
+		};
+	}
+
+	/**
+	 * Get cache file path for a key.
+	 */
+	private getCachePath(key: CacheKey): string {
+		// Create a safe filename from the key
+		const safeRoot = key.repositoryRoot
+			.replace(/[^a-zA-Z0-9]/g, "_")
+			.slice(0, 50);
+		const safeRevision = key.revision.slice(0, 12);
+		const safeHash = key.configHash.slice(0, 12);
+
+		return join(this.cacheDir, `${safeRoot}_${safeRevision}_${safeHash}.json`);
+	}
+
+	/**
+	 * Calculate hash of content.
+	 */
+	calculateHash(content: string): string {
+		return createHash("sha256").update(content).digest("hex");
+	}
+
+	/**
+	 * Calculate combined hash from multiple files.
+	 */
+	async calculateConfigHash(
+		files: { path: string; content: string }[],
+	): Promise<string> {
+		const combined = files
+			.map((f) => `${f.path}:${this.calculateHash(f.content)}`)
+			.sort()
+			.join("|");
+
+		return this.calculateHash(combined);
+	}
+
+	/**
+	 * Get cached analysis if available and fresh.
+	 */
+	async get(key: CacheKey): Promise<ProjectProfile | null> {
+		if (!this.enabled) return null;
+
+		const cachePath = this.getCachePath(key);
+
+		try {
+			await access(cachePath, constants.R_OK);
+			const statResult = await stat(cachePath);
+
+			// Check if cache is too old
+			const age = Date.now() - statResult.mtimeMs;
+			if (age > this.maxAgeMs) {
+				return null;
+			}
+
+			const content = await readFile(cachePath, "utf-8");
+			const entry: CacheEntry = JSON.parse(content);
+
+			// Verify revision matches
+			if (entry.revision !== key.revision) {
+				return null;
+			}
+
+			// Verify config hash matches
+			if (entry.configHash !== key.configHash) {
+				return null;
+			}
+
+			return entry.profile;
+		} catch {
+			// Cache miss or error
+			return null;
+		}
+	}
+
+	/**
+	 * Store analysis in cache.
+	 */
+	async set(
+		key: CacheKey,
+		profile: ProjectProfile,
+		hashes: {
+			ruleHash: string;
+			manifestHash: string;
+			configHash: string;
+		},
+	): Promise<void> {
+		if (!this.enabled) return;
+
+		const cachePath = this.getCachePath(key);
+
+		const entry: CacheEntry = {
+			profile,
+			ruleHash: hashes.ruleHash,
+			manifestHash: hashes.manifestHash,
+			configHash: hashes.configHash,
+			revision: key.revision,
+			cachedAt: new Date().toISOString(),
+		};
+
+		try {
+			// Ensure cache directory exists
+			await mkdir(dirname(cachePath), { recursive: true });
+
+			await writeFile(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+		} catch {
+			// Cache write failure - non-fatal
+		}
+	}
+
+	/**
+	 * Invalidate cache for a specific repository.
+	 */
+	async invalidate(repositoryRoot: string): Promise<void> {
+		if (!this.enabled) return;
+
+		try {
+			const { readdir, rm } = await import("node:fs/promises");
+
+			const files = await readdir(this.cacheDir);
+			const safeRoot = repositoryRoot
+				.replace(/[^a-zA-Z0-9]/g, "_")
+				.slice(0, 50);
+
+			for (const file of files) {
+				if (file.startsWith(safeRoot)) {
+					await rm(join(this.cacheDir, file));
+				}
+			}
+		} catch {
+			// Invalidation failure - non-fatal
+		}
+	}
+
+	/**
+	 * Clear all cached analyses.
+	 */
+	async clear(): Promise<void> {
+		if (!this.enabled) return;
+
+		try {
+			const { readdir, rm } = await import("node:fs/promises");
+
+			const files = await readdir(this.cacheDir);
+			for (const file of files) {
+				if (file.endsWith(".json")) {
+					await rm(join(this.cacheDir, file));
+				}
+			}
+		} catch {
+			// Clear failure - non-fatal
+		}
+	}
+
+	/**
+	 * Get cache statistics.
+	 */
+	async getStats(): Promise<{
+		entryCount: number;
+		totalSize: number;
+		oldestEntry: string | null;
+		newestEntry: string | null;
+	}> {
+		const stats = {
+			entryCount: 0,
+			totalSize: 0,
+			oldestEntry: null as string | null,
+			newestEntry: null as string | null,
+		};
+
+		if (!this.enabled) return stats;
+
+		try {
+			const { readdir } = await import("node:fs/promises");
+			const files = await readdir(this.cacheDir);
+
+			for (const file of files) {
+				if (file.endsWith(".json")) {
+					const filePath = join(this.cacheDir, file);
+					const statResult = await stat(filePath);
+
+					stats.entryCount++;
+					stats.totalSize += statResult.size;
+
+					const isoDate = statResult.mtime.toISOString();
+					if (!stats.oldestEntry || isoDate < stats.oldestEntry) {
+						stats.oldestEntry = isoDate;
+					}
+					if (!stats.newestEntry || isoDate > stats.newestEntry) {
+						stats.newestEntry = isoDate;
+					}
+				}
+			}
+		} catch {
+			// Stats failure - return partial
+		}
+
+		return stats;
+	}
+}
+
+/**
+ * Create a hash of rule files for cache invalidation.
+ */
+export async function hashRuleFiles(
+	files: { path: string; content: string }[],
+): Promise<string> {
+	const combined = files
+		.map(
+			(f) =>
+				`${f.path}:${createHash("sha256").update(f.content).digest("hex")}`,
+		)
+		.sort()
+		.join("|");
+
+	return createHash("sha256").update(combined).digest("hex");
+}
+
+/**
+ * Create a hash of package manifests for cache invalidation.
+ */
+export async function hashManifestFiles(
+	files: { path: string; content: string }[],
+): Promise<string> {
+	// For manifests, only hash the relevant parts (scripts, dependencies)
+	const relevant = files
+		.map((f) => {
+			try {
+				const parsed = JSON.parse(f.content);
+				const relevant = {
+					scripts: parsed.scripts,
+					dependencies: parsed.dependencies,
+					devDependencies: parsed.devDependencies,
+				};
+				return `${f.path}:${createHash("sha256").update(JSON.stringify(relevant)).digest("hex")}`;
+			} catch {
+				return `${f.path}:${createHash("sha256").update(f.content).digest("hex")}`;
+			}
+		})
+		.sort()
+		.join("|");
+
+	return createHash("sha256").update(relevant).digest("hex");
+}
+
+/**
+ * Create a hash of framework configuration files for cache invalidation.
+ */
+export async function hashFrameworkConfigFiles(
+	files: { path: string; content: string }[],
+): Promise<string> {
+	const combined = files
+		.map(
+			(f) =>
+				`${f.path}:${createHash("sha256").update(f.content).digest("hex")}`,
+		)
+		.sort()
+		.join("|");
+
+	return createHash("sha256").update(combined).digest("hex");
+}

package/packages/project-analyzer/src/command-discovery.ts

@@ -0,0 +1,239 @@
+/**
+ * Command Discovery
+ *
+ * Discovers project commands from package.json, pyproject.toml, and other config files.
+ */
+
+import type { ProjectCommands, PackageManagerType } from "./types.js";
+
+/**
+ * Discovered command entry.
+ */
+export interface DiscoveredCommand {
+	/** Command string */
+	command: string;
+	/** Source file path */
+	source: string;
+	/** Whether this is a primary command */
+	primary: boolean;
+}
+
+/**
+ * Parse npm/yarn/pnpm scripts from package.json.
+ */
+export function parsePackageJsonScripts(
+	packageJson: Record<string, unknown>,
+): DiscoveredCommand[] {
+	const commands: DiscoveredCommand[] = [];
+	const scripts = packageJson.scripts as Record<string, string> | undefined;
+
+	if (!scripts || typeof scripts !== "object") {
+		return commands;
+	}
+
+	const primaryScripts = [
+		"test",
+		"build",
+		"dev",
+		"start",
+		"lint",
+		"typecheck",
+		"format",
+	];
+
+	for (const [name, script] of Object.entries(scripts)) {
+		if (typeof script !== "string") continue;
+
+		commands.push({
+			command: `npm run ${name}`,
+			source: "package.json",
+			primary: primaryScripts.includes(name),
+		});
+
+		// Also add yarn/pnpm equivalents
+		if (script.includes("&&") || script.includes("||")) {
+			// Compound script - might need different runner
+		}
+	}
+
+	return commands;
+}
+
+/**
+ * Parse Python scripts from pyproject.toml or setup.py.
+ */
+export function parsePythonCommands(content: string): DiscoveredCommand[] {
+	const commands: DiscoveredCommand[] = [];
+
+	// Check for pytest configuration
+	if (content.includes("[tool.pytest") || content.includes("[pytest]")) {
+		commands.push({
+			command: "pytest",
+			source: "pyproject.toml",
+			primary: true,
+		});
+	}
+
+	// Check for coverage
+	if (content.includes("coverage")) {
+		commands.push({
+			command: "coverage run -m pytest",
+			source: "pyproject.toml",
+			primary: false,
+		});
+		commands.push({
+			command: "coverage report",
+			source: "pyproject.toml",
+			primary: false,
+		});
+	}
+
+	return commands;
+}
+
+/**
+ * Categorize commands by type.
+ */
+export function categorizeCommands(
+	commands: DiscoveredCommand[],
+): ProjectCommands {
+	const categorized: ProjectCommands = {
+		unitTest: [],
+		integrationTest: [],
+		e2eTest: [],
+		lint: [],
+		typecheck: [],
+		build: [],
+		migrate: [],
+	};
+
+	// Patterns for categorizing
+	const patterns: {
+		category: keyof ProjectCommands;
+		pattern: RegExp;
+	}[] = [
+		// Test patterns
+		{ category: "unitTest", pattern: /\btest\b/i },
+		{ category: "unitTest", pattern: /\bvitest\b/i },
+		{ category: "unitTest", pattern: /\bjest\b/i },
+		{ category: "unitTest", pattern: /\bpytest\b/i },
+		{ category: "unitTest", pattern: /\bbun\s+test\b/i },
+		{ category: "integrationTest", pattern: /\bintegration\b/i },
+		{ category: "e2eTest", pattern: /\be2e\b/i },
+		{ category: "e2eTest", pattern: /\bplaywright\b/i },
+		{ category: "e2eTest", pattern: /\bcypress\b/i },
+
+		// Lint patterns
+		{ category: "lint", pattern: /\blint\b/i },
+		{ category: "lint", pattern: /\beslint\b/i },
+		{ category: "lint", pattern: /\bprettier\b/i },
+		{ category: "lint", pattern: /\bruff\b/i },
+		{ category: "lint", pattern: /\bflake8\b/i },
+		{ category: "lint", pattern: /\bmypy\b/i },
+
+		// Typecheck patterns
+		{ category: "typecheck", pattern: /\btypecheck\b/i },
+		{ category: "typecheck", pattern: /\btsc\b.*--noEmit/i },
+		{ category: "typecheck", pattern: /\bmypy\b/i },
+
+		// Build patterns
+		{ category: "build", pattern: /\bbuild\b/i },
+		{ category: "build", pattern: /\bwebpack\b/i },
+		{ category: "build", pattern: /\bvite\s+build\b/i },
+		{ category: "build", pattern: /\bnext\s+build\b/i },
+		{ category: "build", pattern: /\brollup\b/i },
+		{ category: "build", pattern: /\besbuild\b/i },
+
+		// Migrate patterns
+		{ category: "migrate", pattern: /\bmigrate\b/i },
+		{ category: "migrate", pattern: /\balembic\b/i },
+		{ category: "migrate", pattern: /\bbench\s+migrate\b/i },
+	];
+
+	for (const cmd of commands) {
+		for (const { category, pattern } of patterns) {
+			if (pattern.test(cmd.command)) {
+				if (!categorized[category].includes(cmd.command)) {
+					categorized[category].push(cmd.command);
+				}
+				break;
+			}
+		}
+	}
+
+	return categorized;
+}
+
+/**
+ * Determine the primary package manager from project files.
+ */
+export function detectPackageManager(
+	files: string[],
+): PackageManagerType | null {
+	const managerSignals: Record<PackageManagerType, string[]> = {
+		npm: ["package.json", "package-lock.json"],
+		yarn: ["yarn.lock"],
+		pnpm: ["pnpm-lock.yaml"],
+		bun: ["bun.lockb", "BUN.lockb"],
+		pip: ["requirements.txt", "Pipfile"],
+		poetry: ["pyproject.toml", "poetry.lock"],
+		bench: ["apps.txt", "sites/", "frappe-bench.yaml"],
+	};
+
+	const scores: Record<PackageManagerType, number> = {
+		npm: 0,
+		yarn: 0,
+		pnpm: 0,
+		bun: 0,
+		pip: 0,
+		poetry: 0,
+		bench: 0,
+	};
+
+	for (const file of files) {
+		const fileName = file.split("/").pop() || file;
+		for (const [manager, patterns] of Object.entries(managerSignals)) {
+			for (const pattern of patterns) {
+				if (fileName === pattern || file.endsWith(pattern)) {
+					scores[manager as PackageManagerType]++;
+				}
+			}
+		}
+	}
+
+	// Find highest score
+	let best: PackageManagerType | null = null;
+	let bestScore = 0;
+	for (const [manager, score] of Object.entries(scores)) {
+		if (score > bestScore) {
+			bestScore = score;
+			best = manager as PackageManagerType;
+		}
+	}
+
+	return best;
+}
+
+/**
+ * Parse composer.json scripts for Laravel/PHP.
+ */
+export function parseComposerScripts(
+	composerJson: Record<string, unknown>,
+): DiscoveredCommand[] {
+	const commands: DiscoveredCommand[] = [];
+	const scripts = composerJson.scripts as Record<string, unknown> | undefined;
+
+	if (!scripts || typeof scripts !== "object") {
+		return commands;
+	}
+
+	for (const [name] of Object.entries(scripts)) {
+		commands.push({
+			command: `composer ${name}`,
+			source: "composer.json",
+			primary: name === "test" || name === "lint",
+		});
+	}
+
+	return commands;
+}

package/packages/project-analyzer/src/index.ts

@@ -0,0 +1,123 @@
+/**
+ * Project Analyzer
+ *
+ * A comprehensive project analysis system for pi-harness-runtime.
+ * Detects frameworks, languages, commands, rules, and project structure.
+ */
+
+// --- SDK Version -------------------------------------------------------
+
+export { SDK_VERSION } from "./types.js";
+
+// --- Analyzer ----------------------------------------------------------
+
+export {
+	ProjectAnalyzer,
+	createProjectAnalyzer,
+	detectLanguages,
+	detectTestCapabilities,
+} from "./analyzer.js";
+
+// --- File System Walker -------------------------------------------------
+
+export {
+	FileSystemWalker,
+	createReadonlyFileSystem,
+} from "./walker.js";
+
+// --- Cache -------------------------------------------------------------
+
+export {
+	AnalysisCache,
+	hashRuleFiles,
+	hashManifestFiles,
+	hashFrameworkConfigFiles,
+} from "./cache.js";
+
+// --- Rule Discovery ----------------------------------------------------
+
+export {
+	discoverRuleFiles,
+	mergeRules,
+	extractCommandsFromRules,
+	extractMetadataFromRules,
+} from "./rule-discovery.js";
+
+// --- Command Discovery -------------------------------------------------
+
+export {
+	parsePackageJsonScripts,
+	categorizeCommands,
+	detectPackageManager,
+	parsePythonCommands,
+	parseComposerScripts,
+} from "./command-discovery.js";
+
+// --- Detection Signals -------------------------------------------------
+
+export {
+	GenericFrameworkDetector,
+	scanSignals,
+	groupSignalsByFramework,
+	calculateSignalConfidence,
+	createCompositePlugin,
+	GENERIC_SIGNALS,
+} from "./signals.js";
+
+// --- Plugin Interface --------------------------------------------------
+
+export { GenericFrameworkDetector as CompositePlugin } from "./signals.js";
+
+// --- Types ------------------------------------------------------------
+
+export type {
+	// Core types
+	ProjectProfile,
+	AnalyzeRequest,
+	AnalyzeResult,
+	AnalysisErrorCode,
+	// Framework types
+	FrameworkCategory,
+	DetectedFramework,
+	DetectionSignal,
+	FrameworkAnalyzerPlugin,
+	DetectionResult,
+	ReadonlyFileSystem,
+	// Language types
+	DetectedLanguage,
+	// Package manager types
+	PackageManagerType,
+	PackageManagerProfile,
+	// Application types
+	ApplicationProfile,
+	// Command types
+	ProjectCommands,
+	// Rule types
+	ProjectRule,
+	RuleSection,
+	RulePriority,
+	// Test types
+	TestRunner,
+	TestCapability,
+	// Warning types
+	WarningCode,
+	ProjectWarning,
+	// Configuration types
+	AnalyzerConfig,
+	DEFAULT_ANALYZER_CONFIG,
+	// Cache types
+	CacheEntry,
+	CacheKey,
+} from "./types.js";
+
+// Types from other modules
+export type { DiscoveredCommand } from "./command-discovery.js";
+
+export type { RuleFile } from "./rule-discovery.js";
+
+export type {
+	ScannedFile,
+	ScanResult,
+} from "./walker.js";
+
+export type { CacheOptions } from "./cache.js";

package/packages/project-analyzer/src/plugins/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Framework Analyzer Plugins
+ *
+ * Export all built-in plugins.
+ */
+
+export type {
+	FrameworkAnalyzerPlugin,
+	DetectionResult,
+	ReadonlyFileSystem,
+} from "../types.js";
+
+export {
+	GenericFrameworkDetector,
+	createCompositePlugin,
+} from "../signals.js";