pi-harness-runtime 0.10.11 → 0.10.12

package/packages/code-review/src/engine.ts

@@ -0,0 +1,408 @@
+/**
+ * Code Review Engine - Engine
+ *
+ * Main code review engine with rule matching and multi-pass analysis.
+ */
+
+import { randomBytes } from "node:crypto";
+import type {
+	CodeIssue,
+	IssueCategory,
+	ReportOptions,
+	ReviewFile,
+	ReviewRequest,
+	ReviewResult,
+	ReviewRule,
+	ReviewStats,
+	RuleSet,
+} from "./types.js";
+import { TextReporter } from "./reports/text.js";
+import { HtmlReporter } from "./reports/html.js";
+import { MarkdownReporter } from "./reports/markdown.js";
+
+// --- Default Rules --------------------------------------------------------
+
+const DEFAULT_RULES: ReviewRule[] = [
+	// Security rules
+	{
+		id: "security/no-eval",
+		name: "No eval()",
+		severity: "error",
+		category: "security",
+		description: "Avoid using eval() as it can execute arbitrary code",
+		pattern: "\\beval\\s*\\(",
+		message: "Use of eval() is a security risk",
+		suggestion: "Use Function() constructor or JSON.parse() instead",
+	},
+	{
+		id: "security/no-inner-html",
+		name: "No innerHTML",
+		severity: "warning",
+		category: "security",
+		description: "Avoid innerHTML to prevent XSS attacks",
+		pattern: "\\.innerHTML\\s*=",
+		message: "innerHTML can lead to XSS vulnerabilities",
+		suggestion: "Use textContent or sanitize HTML before insertion",
+	},
+	{
+		id: "security/no-dynamic-selector",
+		name: "No dynamic SQL selectors",
+		severity: "error",
+		category: "security",
+		description: "Avoid dynamic SQL selectors to prevent injection",
+		pattern: "(SELECT|INSERT|UPDATE|DELETE)\\s+.*\\$\\{",
+		message: "Dynamic SQL can lead to injection attacks",
+		suggestion: "Use parameterized queries instead",
+	},
+
+	// Performance rules
+	{
+		id: "performance/no-inner-loop",
+		name: "No nested loops",
+		severity: "info",
+		category: "performance",
+		description: "Nested loops can lead to O(n²) complexity",
+		pattern: "for\\s*\\([^)]*\\)\\s*\\{[^}]*for\\s*\\(",
+		message: "Nested loop detected - consider optimizing",
+		suggestion: "Use a hash map or set for O(1) lookups",
+	},
+	{
+		id: "performance/no-sync",
+		name: "No synchronous file I/O",
+		severity: "warning",
+		category: "performance",
+		description: "Avoid synchronous I/O in async code",
+		pattern: "(readFileSync|writeFileSync|readSync)\\s*\\(",
+		message: "Synchronous I/O blocks the event loop",
+		suggestion: "Use async/await with fs/promises",
+	},
+
+	// Best practice rules
+	{
+		id: "best-practice/no-console",
+		name: "No console statements",
+		severity: "info",
+		category: "best-practice",
+		description: "Remove console statements before production",
+		pattern: "\\bconsole\\.(log|debug|info|warn|error)\\s*\\(",
+		message: "Console statement found",
+		suggestion: "Use a proper logging library in production",
+	},
+	{
+		id: "best-practice/no-any",
+		name: "No any type",
+		severity: "warning",
+		category: "typescript",
+		description: "Avoid using 'any' type",
+		pattern: ":\\s*any\\b",
+		message: "Use of 'any' defeats TypeScript type checking",
+		suggestion: "Use 'unknown' and narrow the type safely",
+	},
+	{
+		id: "best-practice/no-deprecated",
+		name: "No deprecated APIs",
+		severity: "warning",
+		category: "best-practice",
+		description: "Check for deprecated API usage",
+		pattern: "/@(deprecated|deprecated|@deprecated)/i",
+		message: "Deprecated API usage detected",
+	},
+
+	// Style rules
+	{
+		id: "style/no-magic-numbers",
+		name: "No magic numbers",
+		severity: "info",
+		category: "style",
+		description: "Avoid magic numbers in code",
+		pattern: "(?<!\\w)\\d{2,}(?!\\w)",
+		message: "Magic number detected - use a named constant",
+		suggestion: "Define a constant with a descriptive name",
+	},
+	{
+		id: "style/no-todo",
+		name: "No TODO comments",
+		severity: "hint",
+		category: "style",
+		description: "TODO comments should be tracked in issues",
+		pattern: "(TODO|FIXME|HACK|XXX):?",
+		message: "TODO/FIXME comment found",
+		suggestion: "Create a tracked issue for this task",
+	},
+];
+
+// --- Code Review Engine ----------------------------------------------------
+
+export class CodeReviewEngine {
+	private rules: ReviewRule[] = [];
+	private ruleSets: Map<string, RuleSet> = new Map();
+	private customMatchers: Map<string, (file: ReviewFile) => CodeIssue[]> =
+		new Map();
+
+	constructor() {
+		// Load default rules
+		this.rules = [...DEFAULT_RULES];
+	}
+
+	/**
+	 * Add a rule
+	 */
+	addRule(rule: ReviewRule): void {
+		const existingIndex = this.rules.findIndex((r) => r.id === rule.id);
+		if (existingIndex >= 0) {
+			this.rules[existingIndex] = rule;
+		} else {
+			this.rules.push(rule);
+		}
+	}
+
+	/**
+	 * Add multiple rules
+	 */
+	addRules(rules: ReviewRule[]): void {
+		for (const rule of rules) {
+			this.addRule(rule);
+		}
+	}
+
+	/**
+	 * Add a rule set
+	 */
+	addRuleSet(set: RuleSet): void {
+		this.ruleSets.set(set.name, set);
+		if (set.extends) {
+			for (const parentName of set.extends) {
+				const parent = this.ruleSets.get(parentName);
+				if (parent) {
+					this.rules.push(...parent.rules);
+				}
+			}
+		}
+		this.rules.push(...set.rules);
+	}
+
+	/**
+	 * Register custom matcher
+	 */
+	registerCustomMatcher(
+		name: string,
+		matcher: (file: ReviewFile) => CodeIssue[],
+	): void {
+		this.customMatchers.set(name, matcher);
+	}
+
+	/**
+	 * Get enabled rules
+	 */
+	getRules(): ReviewRule[] {
+		return this.rules.filter((r) => r.enabled !== false);
+	}
+
+	/**
+	 * Review files
+	 */
+	async review(request: ReviewRequest): Promise<ReviewResult> {
+		const startTime = Date.now();
+		const files = request.files ?? [];
+		const issues: CodeIssue[] = [];
+
+		// Get rules to apply
+		const rules = request.rules?.length
+			? request.rules.filter((r) => r.enabled !== false)
+			: this.getRules().filter((r) => r.enabled !== false);
+
+		// Apply rules to each file
+		for (const file of files) {
+			const fileIssues = this.applyRules(file, rules);
+			issues.push(...fileIssues);
+		}
+
+		// Apply custom matchers
+		for (const [, matcher] of this.customMatchers) {
+			for (const file of files) {
+				const matcherIssues = matcher(file);
+				issues.push(...matcherIssues);
+			}
+		}
+
+		// Generate summary
+		const summary = this.generateSummary(issues);
+
+		const result: ReviewResult = {
+			id: this.generateId(),
+			timestamp: new Date().toISOString(),
+			durationMs: Date.now() - startTime,
+			issues,
+			summary,
+			stats: this.generateStats(files, issues),
+		};
+
+		return result;
+	}
+
+	/**
+	 * Apply rules to a file
+	 */
+	private applyRules(file: ReviewFile, rules: ReviewRule[]): CodeIssue[] {
+		const issues: CodeIssue[] = [];
+
+		for (const rule of rules) {
+			if (rule.pattern) {
+				const pattern =
+					rule.pattern instanceof RegExp
+						? rule.pattern
+						: new RegExp(rule.pattern, rule.patternFlags ?? "g");
+
+				// Find all matches
+				let match: RegExpExecArray | null;
+				while ((match = pattern.exec(file.content)) !== null) {
+					const lineInfo = this.getLineInfo(file.content, match.index);
+					issues.push(this.createIssue(rule, file.path, lineInfo, match[0]));
+				}
+			}
+		}
+
+		return issues;
+	}
+
+	/**
+	 * Get line and column info for a position
+	 */
+	private getLineInfo(
+		content: string,
+		position: number,
+	): { line: number; column: number; lineContent: string } {
+		const lines = content.substring(0, position).split("\n");
+		const line = lines.length;
+		const column = lines[lines.length - 1].length + 1;
+		const allLines = content.split("\n");
+		return {
+			line,
+			column,
+			lineContent: allLines[line - 1] ?? "",
+		};
+	}
+
+	/**
+	 * Create an issue from a rule match
+	 */
+	private createIssue(
+		rule: ReviewRule,
+		file: string,
+		lineInfo: { line: number; column: number; lineContent: string },
+		_matchedCode: string,
+	): CodeIssue {
+		return {
+			id: `${rule.id}-${this.generateId()}`,
+			severity: rule.severity,
+			category: rule.category,
+			title: rule.name,
+			message: rule.message ?? rule.description,
+			file,
+			line: lineInfo.line,
+			column: lineInfo.column,
+			rule: rule.id,
+			ruleUrl: rule.url,
+			suggestion: rule.suggestion,
+			code: lineInfo.lineContent.trim(),
+			fix: rule.suggestion,
+		};
+	}
+
+	/**
+	 * Generate issue summary
+	 */
+	private generateSummary(issues: CodeIssue[]): {
+		total: number;
+		errors: number;
+		warnings: number;
+		info: number;
+		hints: number;
+		byCategory: Record<IssueCategory, number>;
+		byFile: Record<string, number>;
+	} {
+		const summary = {
+			total: issues.length,
+			errors: 0,
+			warnings: 0,
+			info: 0,
+			hints: 0,
+			byCategory: {} as Record<IssueCategory, number>,
+			byFile: {} as Record<string, number>,
+		};
+
+		for (const issue of issues) {
+			switch (issue.severity) {
+				case "error":
+					summary.errors++;
+					break;
+				case "warning":
+					summary.warnings++;
+					break;
+				case "info":
+					summary.info++;
+					break;
+				case "hint":
+					summary.hints++;
+					break;
+			}
+
+			summary.byCategory[issue.category] =
+				(summary.byCategory[issue.category] ?? 0) + 1;
+			summary.byFile[issue.file] = (summary.byFile[issue.file] ?? 0) + 1;
+		}
+
+		return summary;
+	}
+
+	/**
+	 * Generate review statistics
+	 */
+	private generateStats(files: ReviewFile[], issues: CodeIssue[]): ReviewStats {
+		const linesReviewed = files.reduce(
+			(sum, f) => sum + f.content.split("\n").length,
+			0,
+		);
+
+		return {
+			filesReviewed: files.length,
+			linesReviewed,
+			issuesFound: issues.length,
+			aiSuggestions: 0,
+			rulesMatched: this.rules.filter((r) => r.enabled !== false).length,
+		};
+	}
+
+	/**
+	 * Generate unique ID
+	 */
+	private generateId(): string {
+		return randomBytes(8).toString("hex");
+	}
+
+	/**
+	 * Generate report
+	 */
+	generateReport(result: ReviewResult, options: ReportOptions): string {
+		switch (options.format) {
+			case "text":
+				return new TextReporter().generate(result, options);
+			case "html":
+				return new HtmlReporter().generate(result, options);
+			case "markdown":
+				return new MarkdownReporter().generate(result, options);
+			case "json":
+			default:
+				return JSON.stringify(result, null, 2);
+		}
+	}
+}
+
+// --- Factory Function ----------------------------------------------------
+
+/**
+ * Create a code review engine
+ */
+export function createCodeReviewEngine(): CodeReviewEngine {
+	return new CodeReviewEngine();
+}

package/packages/code-review/src/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Code Review Engine
+ *
+ * Automated code review with pattern-based rules, multi-file analysis,
+ * and configurable reporting.
+ */
+
+// --- Engine ------------------------------------------------------------
+
+export { CodeReviewEngine, createCodeReviewEngine } from "./engine.js";
+
+// --- Reporters ---------------------------------------------------------
+
+export { TextReporter } from "./reports/text.js";
+export { HtmlReporter } from "./reports/html.js";
+export { MarkdownReporter } from "./reports/markdown.js";
+
+// --- Types ------------------------------------------------------------
+
+export {
+	SDK_VERSION,
+	type IssueSeverity,
+	type IssueCategory,
+	type FocusArea,
+	type CodeIssue,
+	type IssueSummary,
+	type ReviewFile,
+	type DiffChange,
+	type ReviewRequest,
+	type ReviewResult,
+	type ReviewStats,
+	type ReviewConfig,
+	type ReviewRule,
+	type RuleSet,
+	type AIProviderConfig,
+	type AISuggestion,
+	type AIReviewRequest,
+	type AIReviewResponse,
+	type ReportFormat,
+	type ReportOptions,
+	type ReviewHistoryEntry,
+	type LinterResult,
+	type LinterConfig,
+	type GitDiff,
+	type ChangedFile,
+} from "./types.js";

package/packages/code-review/src/reports/html.ts

@@ -0,0 +1,143 @@
+/**
+ * Code Review Engine - HTML Reporter
+ *
+ * Generate HTML format reports.
+ */
+
+import type { CodeIssue, ReportOptions, ReviewResult } from "../types.js";
+
+export class HtmlReporter {
+	/**
+	 * Generate HTML report
+	 */
+	generate(result: ReviewResult, options: ReportOptions): string {
+		return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Code Review Report - ${result.id}</title>
+	<style>
+		* { box-sizing: border-box; margin: 0; padding: 0; }
+		body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; background: #f5f5f5; }
+		.container { max-width: 1200px; margin: 0 auto; padding: 20px; }
+		header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 10px; margin-bottom: 20px; }
+		header h1 { font-size: 2rem; margin-bottom: 10px; }
+		header .meta { opacity: 0.9; font-size: 0.9rem; }
+		.summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-bottom: 20px; }
+		.summary-card { background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+		.summary-card h3 { font-size: 0.9rem; color: #666; margin-bottom: 5px; }
+		.summary-card .value { font-size: 2rem; font-weight: bold; }
+		.summary-card.errors .value { color: #e74c3c; }
+		.summary-card.warnings .value { color: #f39c12; }
+		.summary-card.info .value { color: #3498db; }
+		.issues { background: white; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); overflow: hidden; }
+		.issue { padding: 15px 20px; border-bottom: 1px solid #eee; }
+		.issue:last-child { border-bottom: none; }
+		.issue-header { display: flex; align-items: center; gap: 10px; margin-bottom: 10px; }
+		.severity-badge { padding: 4px 12px; border-radius: 20px; font-size: 0.75rem; font-weight: bold; text-transform: uppercase; }
+		.severity-badge.error { background: #fde8e8; color: #e74c3c; }
+		.severity-badge.warning { background: #fef3e2; color: #f39c12; }
+		.severity-badge.info { background: #e8f4fd; color: #3498db; }
+		.severity-badge.hint { background: #f0f0f0; color: #666; }
+		.category { color: #666; font-size: 0.85rem; }
+		.issue-title { font-weight: 600; margin-bottom: 5px; }
+		.issue-location { color: #888; font-size: 0.85rem; margin-bottom: 10px; }
+		.issue-message { color: #555; margin-bottom: 10px; }
+		.issue-code { background: #f8f9fa; padding: 10px; border-radius: 5px; font-family: 'Monaco', 'Menlo', monospace; font-size: 0.85rem; overflow-x: auto; }
+		.issue-suggestion { background: #e8f5e9; padding: 10px; border-radius: 5px; margin-top: 10px; color: #2e7d32; }
+		.empty-state { text-align: center; padding: 60px; color: #666; }
+		.empty-state .icon { font-size: 4rem; margin-bottom: 20px; }
+		footer { text-align: center; padding: 20px; color: #888; font-size: 0.85rem; }
+	</style>
+</head>
+<body>
+	<div class="container">
+		<header>
+			<h1>Code Review Report</h1>
+			<div class="meta">
+				<p>Review ID: ${result.id}</p>
+				<p>Generated: ${new Date(result.timestamp).toLocaleString()}</p>
+				<p>Duration: ${result.durationMs}ms</p>
+			</div>
+		</header>
+
+		<div class="summary">
+			<div class="summary-card">
+				<h3>Files Reviewed</h3>
+				<div class="value">${result.stats.filesReviewed}</div>
+			</div>
+			<div class="summary-card">
+				<h3>Lines Reviewed</h3>
+				<div class="value">${result.stats.linesReviewed}</div>
+			</div>
+			<div class="summary-card errors">
+				<h3>Errors</h3>
+				<div class="value">${result.summary.errors}</div>
+			</div>
+			<div class="summary-card warnings">
+				<h3>Warnings</h3>
+				<div class="value">${result.summary.warnings}</div>
+			</div>
+			<div class="summary-card info">
+				<h3>Info</h3>
+				<div class="value">${result.summary.info}</div>
+			</div>
+		</div>
+
+		<div class="issues">
+			${
+				result.issues.length > 0
+					? result.issues
+							.map((issue) => this.renderIssue(issue, options))
+							.join("\n")
+					: `
+			<div class="empty-state">
+				<div class="icon">✓</div>
+				<h2>No Issues Found</h2>
+				<p>Your code passed all automated checks!</p>
+			</div>
+			`
+			}
+		</div>
+
+		<footer>
+			<p>Generated by pi-harness-runtime Code Review Engine</p>
+		</footer>
+	</div>
+</body>
+</html>`;
+	}
+
+	/**
+	 * Render a single issue
+	 */
+	private renderIssue(issue: CodeIssue, options: ReportOptions): string {
+		const location = issue.file + (issue.line ? `:${issue.line}` : "");
+
+		return `
+		<div class="issue">
+			<div class="issue-header">
+				<span class="severity-badge ${issue.severity}">${issue.severity}</span>
+				<span class="category">${issue.category}</span>
+			</div>
+			<div class="issue-title">${this.escapeHtml(issue.title)}</div>
+			<div class="issue-location">${this.escapeHtml(location)} ${issue.rule ? `• Rule: ${this.escapeHtml(issue.rule)}` : ""}</div>
+			<div class="issue-message">${this.escapeHtml(issue.message)}</div>
+			${issue.code && options.includeCode !== false ? `<div class="issue-code">${this.escapeHtml(issue.code)}</div>` : ""}
+			${issue.suggestion && options.includeSuggestions !== false ? `<div class="issue-suggestion"><strong>Suggestion:</strong> ${this.escapeHtml(issue.suggestion)}</div>` : ""}
+		</div>`;
+	}
+
+	/**
+	 * Escape HTML
+	 */
+	private escapeHtml(text: string): string {
+		return text
+			.replace(/&/g, "&amp;")
+			.replace(/</g, "&lt;")
+			.replace(/>/g, "&gt;")
+			.replace(/"/g, "&quot;")
+			.replace(/'/g, "&#039;");
+	}
+}