pi-harness-runtime 0.5.0 → 0.6.3-beta.13

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

@@ -0,0 +1,282 @@
+/**
+ * Rule Discovery
+ *
+ * Discovers and parses project rules from AGENTS.md, RULES.md, etc.
+ */
+
+import { readFile } from "node:fs/promises";
+import { join, dirname, basename } from "node:path";
+import type { ProjectRule, RuleSection, RulePriority } from "./types.js";
+
+/**
+ * Rule file metadata.
+ */
+export interface RuleFile {
+	/** Absolute path to rule file */
+	path: string;
+	/** File name without path */
+	name: string;
+	/** Parsed content */
+	content: string;
+	/** Whether user explicitly created this file */
+	userDefined: boolean;
+}
+
+/**
+ * Priority mapping from file names.
+ */
+const PRIORITY_MAP: Record<string, RulePriority> = {
+	"AGENTS.md": "mandatory",
+	"CLAUDE.md": "mandatory",
+	".claude.md": "mandatory",
+	"RULES.md": "mandatory",
+	"PROJECT_RULES.md": "mandatory",
+	"CONTRIBUTING.md": "advisory",
+};
+
+/**
+ * Parse markdown content into rule sections.
+ */
+function parseMarkdownSections(
+	content: string,
+	filePath: string,
+): RuleSection[] {
+	const sections: RuleSection[] = [];
+	const lines = content.split("\n");
+
+	let currentSection: RuleSection | null = null;
+	let currentContent: string[] = [];
+	let lineNumber = 0;
+
+	for (const line of lines) {
+		lineNumber++;
+
+		// Check for heading
+		const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+		if (headingMatch) {
+			// Save previous section
+			if (currentSection) {
+				currentSection.content = currentContent.join("\n").trim();
+				sections.push(currentSection);
+			}
+
+			// Start new section
+			currentSection = {
+				id: `section-${sections.length + 1}`,
+				title: headingMatch[2].trim(),
+				content: "",
+				line: lineNumber,
+			};
+			currentContent = [];
+		} else if (currentSection) {
+			currentContent.push(line);
+		}
+	}
+
+	// Save last section
+	if (currentSection) {
+		currentSection.content = currentContent.join("\n").trim();
+		sections.push(currentSection);
+	}
+
+	return sections;
+}
+
+/**
+ * Parse a rule file and extract structured content.
+ */
+export async function parseRuleFile(file: RuleFile): Promise<ProjectRule> {
+	const sections = parseMarkdownSections(file.content, file.path);
+	const priority = PRIORITY_MAP[file.name] || "advisory";
+
+	return {
+		id: `rule-${basename(file.path, ".md")}`,
+		source: file.path,
+		priority,
+		content: file.content,
+		sections,
+		userDefined: file.userDefined,
+	};
+}
+
+/**
+ * Discover rule files in a repository.
+ */
+export async function discoverRuleFiles(
+	rootPath: string,
+	fs: {
+		exists(path: string): Promise<boolean>;
+		readFile(path: string): Promise<string>;
+		readDir(path: string): Promise<string[]>;
+		isDirectory(path: string): Promise<boolean>;
+	},
+	fileNames: string[] = [
+		"AGENTS.md",
+		"RULES.md",
+		"PROJECT_RULES.md",
+		"CONTRIBUTING.md",
+		".claude.md",
+		"CLAUDE.md",
+	],
+): Promise<RuleFile[]> {
+	const rules: RuleFile[] = [];
+
+	// Check for rules at root level
+	for (const fileName of fileNames) {
+		const filePath = join(rootPath, fileName);
+		try {
+			if (await fs.exists(filePath)) {
+				const content = await fs.readFile(filePath);
+				rules.push({
+					path: filePath,
+					name: fileName,
+					content,
+					userDefined: true,
+				});
+			}
+		} catch {
+			// File might not be readable, skip
+		}
+	}
+
+	// Check for rules in .github/ or docs/ directories
+	const subdirs = [".github", "docs", ".claude"];
+	for (const subdir of subdirs) {
+		const subdirPath = join(rootPath, subdir);
+		try {
+			if (await fs.isDirectory(subdirPath)) {
+				const entries = await fs.readDir(subdirPath);
+				for (const entry of entries) {
+					if (entry.endsWith(".md") || entry.endsWith(".txt")) {
+						const filePath = join(subdirPath, entry);
+						try {
+							const content = await fs.readFile(filePath);
+							rules.push({
+								path: filePath,
+								name: entry,
+								content,
+								userDefined: false,
+							});
+						} catch {
+							// Skip unreadable files
+						}
+					}
+				}
+			}
+		} catch {
+			// Directory not accessible, skip
+		}
+	}
+
+	return rules;
+}
+
+/**
+ * Merge multiple rule files into a coherent set.
+ * Later rules override earlier ones for conflicting sections.
+ */
+export function mergeRules(
+	ruleFiles: RuleFile[],
+	prioritizeUserDefined = true,
+): ProjectRule[] {
+	// Sort by priority and user-defined status
+	const sorted = [...ruleFiles].sort((a, b) => {
+		if (prioritizeUserDefined) {
+			if (a.userDefined !== b.userDefined) {
+				return a.userDefined ? -1 : 1;
+			}
+		}
+		const priorityA = PRIORITY_MAP[a.name] || "advisory";
+		const priorityB = PRIORITY_MAP[b.name] || "advisory";
+		const priorityOrder: Record<RulePriority, number> = {
+			mandatory: 0,
+			advisory: 1,
+			convention: 2,
+		};
+		return priorityOrder[priorityA] - priorityOrder[priorityB];
+	});
+
+	// Parse and return rules
+	return sorted.map((file) => ({
+		id: `rule-${basename(file.path, ".md")}`,
+		source: file.path,
+		priority: PRIORITY_MAP[file.name] || "advisory",
+		content: file.content,
+		sections: parseMarkdownSections(file.content, file.path),
+		userDefined: file.userDefined,
+	}));
+}
+
+/**
+ * Extract commands from rules.
+ * Looks for command patterns like `npm run`, `bun test`, etc.
+ */
+export function extractCommandsFromRules(rules: ProjectRule[]): {
+	permitted: string[];
+	prohibited: string[];
+} {
+	const permitted: string[] = [];
+	const prohibited: string[] = [];
+
+	const commandPattern = /`([^`]+)`/g;
+	const permitPattern = /permi(ted|ssion)|allow|can\s+run|may\s+execute/i;
+	const prohibitPattern =
+		/prohibit|forbid|deny|block|cannot\s+run|may\s+not\s+execute/i;
+
+	for (const rule of rules) {
+		const fullText = rule.content;
+
+		// Check if this rule is about permitting or prohibiting
+		const isPermit = permitPattern.test(fullText);
+		const isProhibit = prohibitPattern.test(fullText);
+
+		let match;
+		while ((match = commandPattern.exec(fullText)) !== null) {
+			const command = match[1].trim();
+			if (isPermit) {
+				if (!permitted.includes(command)) {
+					permitted.push(command);
+				}
+			}
+			if (isProhibit) {
+				if (!prohibited.includes(command)) {
+					prohibited.push(command);
+				}
+			}
+		}
+	}
+
+	return { permitted, prohibited };
+}
+
+/**
+ * Extract key-value metadata from rules.
+ */
+export function extractMetadataFromRules(
+	rules: ProjectRule[],
+): Record<string, string> {
+	const metadata: Record<string, string> = {};
+
+	for (const rule of rules) {
+		for (const section of rule.sections) {
+			// Look for key: value patterns
+			const kvPattern = /^\*\*([^*]+):\*\*\s*(.+)$/gm;
+			let match;
+			while ((match = kvPattern.exec(section.content)) !== null) {
+				const key = match[1].trim().toLowerCase().replace(/\s+/g, "_");
+				const value = match[2].trim();
+				metadata[key] = value;
+			}
+
+			// Also check for list items with key: value
+			const listPattern = /^- \*\*([^*]+):\*\*\s*(.+)$/gm;
+			while ((match = listPattern.exec(section.content)) !== null) {
+				const key = match[1].trim().toLowerCase().replace(/\s+/g, "_");
+				const value = match[2].trim();
+				metadata[key] = value;
+			}
+		}
+	}
+
+	return metadata;
+}

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

@@ -0,0 +1,355 @@
+/**
+ * Detection Signals
+ *
+ * Generic detection signals for common project types.
+ * These are used by the analyzer when no specific plugin matches.
+ */
+
+import type {
+	DetectionSignal,
+	FrameworkCategory,
+	FrameworkAnalyzerPlugin,
+	ReadonlyFileSystem,
+	DetectionResult,
+} from "./types.js";
+
+// ─── Signal Definitions ────────────────────────────────────────────────
+
+export interface SignalDefinition {
+	/** Signal identifier */
+	id: string;
+	/** File path pattern to match */
+	pattern: string;
+	/** Signal weight (0-1) */
+	weight: number;
+	/** Associated framework category */
+	framework: FrameworkCategory;
+	/** Additional metadata */
+	metadata?: Record<string, string>;
+}
+
+/**
+ * Standard detection signals for common frameworks.
+ */
+export const GENERIC_SIGNALS: SignalDefinition[] = [
+	// Frappe signals
+	{ id: "frappe_hooks", pattern: "apps.txt", weight: 0.8, framework: "frappe" },
+	{ id: "frappe_sites", pattern: "sites/", weight: 0.7, framework: "frappe" },
+	{ id: "frappe_bench", pattern: "Procfile", weight: 0.5, framework: "frappe" },
+	{
+		id: "frappe_app",
+		pattern: "pyproject.toml",
+		weight: 0.4,
+		framework: "frappe",
+		metadata: { python: "true" },
+	},
+
+	// Frappe SPA signals
+	{
+		id: "frappe_spa_frontend",
+		pattern: "frontend/",
+		weight: 0.6,
+		framework: "frappe_spa",
+	},
+	{
+		id: "frappe_spa_vite",
+		pattern: "vite.config.*",
+		weight: 0.5,
+		framework: "frappe_spa",
+	},
+	{
+		id: "frappe_spa_typescript",
+		pattern: "tsconfig.json",
+		weight: 0.3,
+		framework: "frappe_spa",
+	},
+
+	// Next.js signals
+	{
+		id: "next_config",
+		pattern: "next.config.*",
+		weight: 0.9,
+		framework: "nextjs",
+	},
+	{ id: "next_app_dir", pattern: "app/", weight: 0.7, framework: "nextjs" },
+	{ id: "next_pages", pattern: "pages/", weight: 0.6, framework: "nextjs" },
+	{
+		id: "next_package",
+		pattern: "package.json",
+		weight: 0.3,
+		framework: "nextjs",
+		metadata: { hasNext: "true" },
+	},
+
+	// React signals
+	{
+		id: "react_index",
+		pattern: "src/index.*",
+		weight: 0.7,
+		framework: "react",
+	},
+	{ id: "react_app", pattern: "src/App.*", weight: 0.6, framework: "react" },
+	{
+		id: "react_package",
+		pattern: "package.json",
+		weight: 0.3,
+		framework: "react",
+		metadata: { hasReact: "true" },
+	},
+
+	// Vite signals
+	{
+		id: "vite_config",
+		pattern: "vite.config.*",
+		weight: 0.8,
+		framework: "vite",
+	},
+	{ id: "vite_entry", pattern: "index.html", weight: 0.5, framework: "vite" },
+	{
+		id: "vite_tsconfig",
+		pattern: "tsconfig.json",
+		weight: 0.3,
+		framework: "vite",
+	},
+
+	// Django signals
+	{
+		id: "django_manage",
+		pattern: "manage.py",
+		weight: 0.9,
+		framework: "django",
+	},
+	{
+		id: "django_settings",
+		pattern: "settings.py",
+		weight: 0.7,
+		framework: "django",
+	},
+	{
+		id: "django_requirements",
+		pattern: "requirements.txt",
+		weight: 0.5,
+		framework: "django",
+	},
+
+	// Laravel signals
+	{
+		id: "laravel_artisan",
+		pattern: "artisan",
+		weight: 0.9,
+		framework: "laravel",
+	},
+	{
+		id: "laravel_composer",
+		pattern: "composer.json",
+		weight: 0.6,
+		framework: "laravel",
+	},
+	{
+		id: "laravel_database",
+		pattern: "database/",
+		weight: 0.5,
+		framework: "laravel",
+	},
+
+	// Express signals
+	{
+		id: "express_package",
+		pattern: "package.json",
+		weight: 0.4,
+		framework: "express",
+		metadata: { hasExpress: "true" },
+	},
+	{
+		id: "express_index",
+		pattern: "index.js",
+		weight: 0.5,
+		framework: "express",
+	},
+	{ id: "express_app", pattern: "app.js", weight: 0.5, framework: "express" },
+
+	// FastAPI signals
+	{ id: "fastapi_main", pattern: "main.py", weight: 0.6, framework: "fastapi" },
+	{
+		id: "fastapi_requirements",
+		pattern: "requirements.txt",
+		weight: 0.4,
+		framework: "fastapi",
+	},
+	{
+		id: "fastapi_uvicorn",
+		pattern: "package.json",
+		weight: 0.3,
+		framework: "fastapi",
+		metadata: { hasFastAPI: "true" },
+	},
+];
+
+// ─── Signal Scanner ───────────────────────────────────────────────────
+
+/**
+ * Scan for detection signals in the filesystem.
+ */
+export async function scanSignals(
+	fs: ReadonlyFileSystem,
+	signals: SignalDefinition[] = GENERIC_SIGNALS,
+): Promise<DetectionSignal[]> {
+	const results: DetectionSignal[] = [];
+
+	for (const signal of signals) {
+		try {
+			// Handle glob patterns
+			if (signal.pattern.includes("*")) {
+				const matches = await fs.glob(signal.pattern);
+				for (const match of matches) {
+					results.push({
+						type: signal.id,
+						path: match,
+						weight: signal.weight,
+						value: signal.metadata?.value,
+					});
+				}
+			} else {
+				// Handle exact file match
+				if (await fs.exists(signal.pattern)) {
+					results.push({
+						type: signal.id,
+						path: signal.pattern,
+						weight: signal.weight,
+						value: signal.metadata?.value,
+					});
+				}
+			}
+		} catch {
+			// Ignore errors for individual signals
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Group signals by framework category.
+ */
+export function groupSignalsByFramework(
+	signals: DetectionSignal[],
+	frameworkMap: Map<FrameworkCategory, SignalDefinition[]>,
+): Map<FrameworkCategory, DetectionSignal[]> {
+	const grouped = new Map<FrameworkCategory, DetectionSignal[]>();
+
+	for (const signal of signals) {
+		const definition = GENERIC_SIGNALS.find((s) => s.id === signal.type);
+		if (definition) {
+			const existing = grouped.get(definition.framework) || [];
+			existing.push(signal);
+			grouped.set(definition.framework, existing);
+		}
+	}
+
+	return grouped;
+}
+
+/**
+ * Calculate confidence score from signals.
+ */
+export function calculateSignalConfidence(
+	signals: DetectionSignal[],
+	requiredSignals: number,
+): number {
+	if (signals.length === 0) return 0;
+
+	const totalWeight = signals.reduce((sum, s) => sum + s.weight, 0);
+	const maxPossibleWeight = requiredSignals * 1.0; // Assuming max weight of 1.0 per signal
+
+	return Math.min(1, totalWeight / maxPossibleWeight);
+}
+
+// ─── Generic Framework Detector ──────────────────────────────────────
+
+/**
+ * Generic framework detector using signal-based detection.
+ */
+export class GenericFrameworkDetector {
+	private signals: SignalDefinition[];
+	private signalsPerFramework: Map<FrameworkCategory, SignalDefinition[]>;
+
+	constructor(signals: SignalDefinition[] = GENERIC_SIGNALS) {
+		this.signals = signals;
+		this.signalsPerFramework = new Map();
+
+		// Group signals by framework
+		for (const signal of signals) {
+			const existing = this.signalsPerFramework.get(signal.framework) || [];
+			existing.push(signal);
+			this.signalsPerFramework.set(signal.framework, existing);
+		}
+	}
+
+	/**
+	 * Detect frameworks using signals.
+	 */
+	async detect(fs: ReadonlyFileSystem): Promise<DetectionResult[]> {
+		const allSignals = await scanSignals(fs, this.signals);
+		const grouped = groupSignalsByFramework(
+			allSignals,
+			this.signalsPerFramework,
+		);
+		const results: DetectionResult[] = [];
+
+		for (const [framework, signals] of grouped) {
+			const definitions = this.signalsPerFramework.get(framework) || [];
+			const requiredCount = Math.max(2, Math.ceil(definitions.length * 0.3));
+			const confidence = calculateSignalConfidence(signals, requiredCount);
+
+			if (confidence > 0.2) {
+				results.push({
+					category: framework,
+					confidence,
+					signals,
+					version: undefined,
+				});
+			}
+		}
+
+		// Sort by confidence descending
+		results.sort((a, b) => b.confidence - a.confidence);
+
+		return results;
+	}
+}
+
+// ─── Composite Plugin ──────────────────────────────────────────────────
+
+/**
+ * Create a composite plugin from generic signals and custom plugins.
+ */
+export function createCompositePlugin(
+	customPlugins: FrameworkAnalyzerPlugin[],
+): FrameworkAnalyzerPlugin {
+	const detector = new GenericFrameworkDetector();
+
+	return {
+		id: "composite",
+		version: "1.0.0",
+		priority: 1000, // Lowest priority
+
+		async detect(fs) {
+			const results = await detector.detect(fs);
+			if (results.length === 0) return null;
+			return results[0]; // Return highest confidence
+		},
+
+		async analyze(_root, detection, fs) {
+			// Try custom plugins first
+			for (const plugin of customPlugins) {
+				if (plugin.priority < 1000) {
+					const result = await plugin.analyze(_root, detection, fs);
+					if (Object.keys(result).length > 0) {
+						return result;
+					}
+				}
+			}
+			return {};
+		},
+	};
+}