pi-harness-runtime 1.1.445 → 1.1.446

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

@@ -1,329 +0,0 @@
-/**
- * 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

@@ -1,239 +0,0 @@
-/**
- * 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

@@ -1,123 +0,0 @@
-/**
- * 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

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