pi-harness-runtime 0.10.43 → 1.1.1

package/packages/code-generation/test/generator.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Code Generation Pipeline - Tests
+ */
+
+import { describe, expect, it } from "bun:test";
+import { SDK_VERSION, createCodeGenerator, createFaker } from "../src/index.js";
+
+describe("CodeGeneration", () => {
+	describe("SDK_VERSION", () => {
+		it("should export SDK_VERSION", () => {
+			expect(SDK_VERSION).toBeDefined();
+			expect(typeof SDK_VERSION).toBe("string");
+		});
+	});
+
+	describe("createFaker", () => {
+		it("should create faker instance", () => {
+			const faker = createFaker(12345);
+			expect(faker).toBeDefined();
+		});
+
+		it("should generate consistent data with seed", () => {
+			const faker1 = createFaker(12345);
+			const faker2 = createFaker(12345);
+
+			expect(faker1.firstName()).toBe(faker2.firstName());
+		});
+
+		it("should generate different data without seed", () => {
+			const faker1 = createFaker();
+			const faker2 = createFaker();
+
+			// May or may not be different (random)
+			expect(typeof faker1.firstName()).toBe("string");
+			expect(typeof faker2.firstName()).toBe("string");
+		});
+	});
+
+	describe("Faker data generation", () => {
+		const faker = createFaker(12345);
+
+		it("should generate names", () => {
+			expect(typeof faker.firstName()).toBe("string");
+			expect(typeof faker.lastName()).toBe("string");
+			expect(typeof faker.fullName()).toBe("string");
+		});
+
+		it("should generate email", () => {
+			const email = faker.email();
+			expect(email).toContain("@");
+			expect(email).toContain(".");
+		});
+
+		it("should generate uuid", () => {
+			const uuid = faker.uuid();
+			expect(uuid).toMatch(/^[0-9a-f-]+$/);
+		});
+
+		it("should generate phone", () => {
+			const phone = faker.phone();
+			expect(phone).toMatch(/\d/);
+		});
+
+		it("should generate addresses", () => {
+			expect(typeof faker.address()).toBe("string");
+			expect(typeof faker.city()).toBe("string");
+			expect(typeof faker.country()).toBe("string");
+			expect(typeof faker.zipCode()).toBe("string");
+		});
+
+		it("should generate company info", () => {
+			expect(typeof faker.company()).toBe("string");
+			expect(typeof faker.department()).toBe("string");
+			expect(typeof faker.jobTitle()).toBe("string");
+		});
+
+		it("should generate text", () => {
+			expect(typeof faker.word()).toBe("string");
+			expect(typeof faker.sentence()).toBe("string");
+			expect(typeof faker.paragraph()).toBe("string");
+		});
+
+		it("should generate numbers within range", () => {
+			const num = faker.number(10, 20);
+			expect(num).toBeGreaterThanOrEqual(10);
+			expect(num).toBeLessThanOrEqual(20);
+		});
+
+		it("should generate boolean", () => {
+			const bool = faker.boolean();
+			expect(typeof bool).toBe("boolean");
+		});
+	});
+
+	describe("createCodeGenerator", () => {
+		it("should create code generator instance", () => {
+			const generator = createCodeGenerator();
+			expect(generator).toBeDefined();
+		});
+
+		it("should create with custom config", () => {
+			const generator = createCodeGenerator({
+				seed: 12345,
+				verbose: true,
+			});
+			expect(generator).toBeDefined();
+		});
+	});
+
+	describe("code generation", () => {
+		const generator = createCodeGenerator({
+			seed: 12345,
+		});
+
+		it("should generate code from template", async () => {
+			const result = await generator.generate({
+				template: {
+					id: "test",
+					name: "Test",
+					description: "Test template",
+					content: "Hello, <%= name %>!",
+					engine: "ejs",
+				},
+				variables: { name: "World" },
+			});
+
+			expect(result.success).toBe(true);
+			expect(result.files[0].content).toContain("Hello, World!");
+		});
+
+		it("should generate with multiple variables", async () => {
+			const result = await generator.generate({
+				template: {
+					id: "test2",
+					name: "Test2",
+					description: "Test template 2",
+					content: "User: <%= firstName %> <%= lastName %>",
+					engine: "ejs",
+				},
+				variables: { firstName: "John", lastName: "Doe" },
+			});
+
+			expect(result.success).toBe(true);
+			expect(result.files[0].content).toContain("John Doe");
+		});
+
+		it("should return errors for missing template", async () => {
+			const result = await generator.generate({
+				schemaId: "non-existent",
+				variables: {},
+			});
+
+			expect(result.success).toBe(false);
+			expect(result.errors.length).toBeGreaterThan(0);
+		});
+
+		it("should validate required variables", async () => {
+			const result = await generator.generate({
+				template: {
+					id: "required",
+					name: "Required",
+					description: "Required vars",
+					content: "Hello <%= name %>",
+					engine: "ejs",
+					variables: [{ name: "name", type: "string", required: true }],
+				},
+				variables: {},
+			});
+
+			expect(result.success).toBe(false);
+		});
+
+		it("should support dry run", async () => {
+			const result = await generator.generate({
+				template: {
+					id: "dry-run",
+					name: "DryRun",
+					description: "Dry run test",
+					content: "Test",
+					engine: "ejs",
+				},
+				variables: {},
+				dryRun: true,
+			});
+
+			expect(result.dryRun).toBe(true);
+		});
+
+		it("should calculate generation time", async () => {
+			const result = await generator.generate({
+				template: {
+					id: "timing",
+					name: "Timing",
+					description: "Timing test",
+					content: "Test content",
+					engine: "ejs",
+				},
+				variables: {},
+			});
+
+			expect(result.durationMs).toBeGreaterThanOrEqual(0);
+		});
+	});
+
+	describe("schema registration", () => {
+		const generator = createCodeGenerator();
+
+		it("should register schemas", () => {
+			generator.registerSchema({
+				name: "User",
+				fields: [{ name: "name", type: "string" }],
+			});
+
+			const schema = generator.getSchema("User");
+			expect(schema).toBeDefined();
+			expect(schema?.name).toBe("User");
+		});
+
+		it("should generate using registered schema", async () => {
+			generator.registerSchema({
+				id: "registered",
+				name: "Product",
+				description: "Product schema",
+				fields: [
+					{ name: "name", type: "string" },
+					{ name: "price", type: "number" },
+				],
+			});
+
+			const result = await generator.generate({
+				schemaId: "registered",
+				variables: {},
+			});
+
+			expect(result.success).toBe(true);
+		});
+	});
+});

package/packages/code-review/README.md

@@ -0,0 +1,312 @@
+# @pi/code-review
+
+Automated code review engine with pattern-based rules, multi-file analysis, and configurable reporting.
+
+## Features
+
+- **Pattern-Based Rules** - Define custom rules with regex patterns
+- **Multi-File Analysis** - Review entire projects at once
+- **Multiple Report Formats** - Text, HTML, Markdown, and JSON
+- **Configurable Severity** - Filter by error, warning, info, hint
+- **Category Organization** - Security, performance, correctness, style, etc.
+- **Git Integration Ready** - Review diffs and changed files
+- **Custom Matchers** - Register custom analysis functions
+- **Rule Sets** - Group and reuse rule collections
+
+## Installation
+
+```bash
+npm install @pi/code-review
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { createCodeReviewEngine } from "@pi/code-review";
+
+const engine = createCodeReviewEngine();
+
+// Create review request
+const request = {
+  files: [
+    {
+      path: "src/index.ts",
+      content: `const result = eval(userInput);
+console.log("Debug:", result);
+const x: any = value;
+`
+    }
+  ]
+};
+
+// Run review
+const result = await engine.review(request);
+
+console.log(`Found ${result.summary.total} issues`);
+console.log(`Errors: ${result.summary.errors}`);
+console.log(`Warnings: ${result.summary.warnings}`);
+```
+
+### Generate Reports
+
+```typescript
+import { createCodeReviewEngine, ReportFormat } from "@pi/code-review";
+
+// Generate text report
+const textReport = engine.generateReport(result, {
+  format: "text",
+  includeCode: true,
+  groupByFile: true,
+});
+
+console.log(textReport);
+
+// Generate HTML report
+const htmlReport = engine.generateReport(result, {
+  format: "html",
+  includeSuggestions: true,
+});
+
+await writeFile("report.html", htmlReport);
+
+// Generate Markdown report
+const mdReport = engine.generateReport(result, {
+  format: "markdown",
+  includeSummary: true,
+});
+```
+
+### Custom Rules
+
+```typescript
+import { createCodeReviewEngine } from "@pi/code-review";
+
+const engine = createCodeReviewEngine();
+
+// Add custom rule
+engine.addRule({
+  id: "custom/no-passwords",
+  name: "No hardcoded passwords",
+  severity: "error",
+  category: "security",
+  description: "Avoid hardcoded passwords in code",
+  pattern: "password\\s*=\\s*['\"][^'\"]+['\"]",
+  message: "Hardcoded password detected",
+  suggestion: "Use environment variables instead"
+});
+
+// Add multiple rules
+engine.addRules([
+  {
+    id: "custom/secure-random",
+    name: "Use crypto.randomUUID",
+    severity: "info",
+    category: "best-practice",
+    description: "Use crypto.randomUUID for UUIDs",
+    pattern: "uuid\\(|UUID\\.generate\\(",
+    suggestion: "Use crypto.randomUUID() instead"
+  }
+]);
+```
+
+### Rule Sets
+
+```typescript
+import { createCodeReviewEngine } from "@pi/code-review";
+
+const engine = createCodeReviewEngine();
+
+// Create rule set
+engine.addRuleSet({
+  name: "security-strict",
+  description: "Strict security rules for production code",
+  rules: [
+    {
+      id: "security/no-eval",
+      name: "No eval()",
+      severity: "error",
+      category: "security",
+      description: "Avoid eval()",
+      pattern: "\\beval\\s*\\(",
+      message: "eval() is forbidden",
+      suggestion: "Use Function() or JSON.parse() instead"
+    },
+    // ... more rules
+  ],
+  tags: ["security", "production"]
+});
+```
+
+### Custom Matchers
+
+```typescript
+import { createCodeReviewEngine, ReviewFile, CodeIssue } from "@pi/code-review";
+
+const engine = createCodeReviewEngine();
+
+// Register custom matcher
+engine.registerCustomMatcher("complexity", (file: ReviewFile) => {
+  const issues: CodeIssue[] = [];
+  const lines = file.content.split('\n');
+  
+  // Check for complex functions
+  let bracketCount = 0;
+  let functionStart = -1;
+  
+  lines.forEach((line, index) => {
+    if (line.includes('function') || line.includes('=>')) {
+      functionStart = index;
+      bracketCount = 0;
+    }
+    bracketCount += (line.match(/{/g) || []).length;
+    bracketCount -= (line.match(/}/g) || []).length;
+    
+    if (bracketCount === 0 && functionStart >= 0 && index - functionStart > 50) {
+      issues.push({
+        id: `complex-function-${index}`,
+        severity: "warning",
+        category: "maintainability",
+        title: "Complex function",
+        message: `Function at line ${functionStart + 1} has ${index - functionStart} lines`,
+        file: file.path,
+        line: functionStart + 1,
+        suggestion: "Consider breaking this into smaller functions"
+      });
+      functionStart = -1;
+    }
+  });
+  
+  return issues;
+});
+```
+
+### Git Diff Review
+
+```typescript
+import { createCodeReviewEngine } from "@pi/code-review";
+
+const engine = createCodeReviewEngine();
+
+// Review a diff
+const result = await engine.review({
+  diff: [
+    {
+      type: "modified",
+      path: "src/index.ts",
+      oldContent: "...",
+      newContent: "...",
+      oldLines: 10,
+      newLines: 15
+    }
+  ]
+});
+```
+
+## Default Rules
+
+The engine includes these built-in rules:
+
+### Security
+- `security/no-eval` - Warns against eval() usage
+- `security/no-inner-html` - Warns against innerHTML usage
+- `security/no-dynamic-selector` - Warns against dynamic SQL
+
+### Performance
+- `performance/no-inner-loop` - Flags nested loops
+- `performance/no-sync` - Warns against sync file I/O
+
+### Best Practices
+- `best-practice/no-console` - Warns against console statements
+- `best-practice/no-any` - Warns against TypeScript any type
+- `best-practice/no-deprecated` - Flags deprecated API usage
+
+### Style
+- `style/no-magic-numbers` - Warns against magic numbers
+- `style/no-todo` - Flags TODO/FIXME comments
+
+## API Reference
+
+### CodeReviewEngine
+
+```typescript
+const engine = createCodeReviewEngine(options?);
+```
+
+### Methods
+
+```typescript
+// Add a rule
+engine.addRule(rule: ReviewRule): void;
+
+// Add multiple rules
+engine.addRules(rules: ReviewRule[]): void;
+
+// Add a rule set
+engine.addRuleSet(set: RuleSet): void;
+
+// Register custom matcher
+engine.registerCustomMatcher(name: string, matcher: (file) => CodeIssue[]): void;
+
+// Get enabled rules
+engine.getRules(): ReviewRule[];
+
+// Review files
+engine.review(request: ReviewRequest): Promise<ReviewResult>;
+
+// Generate report
+engine.generateReport(result: ReviewResult, options: ReportOptions): string;
+```
+
+### Report Options
+
+```typescript
+interface ReportOptions {
+  format: "text" | "json" | "html" | "markdown";
+  includeCode?: boolean;
+  includeSuggestions?: boolean;
+  includeStats?: boolean;
+  includeSummary?: boolean;
+  groupByFile?: boolean;
+  groupBySeverity?: boolean;
+  color?: boolean;
+}
+```
+
+### Review Rule
+
+```typescript
+interface ReviewRule {
+  id: string;
+  name: string;
+  severity: "error" | "warning" | "info" | "hint";
+  category: "security" | "performance" | "correctness" | "maintainability" | "style" | "best-practice";
+  description: string;
+  pattern?: string | RegExp;
+  patternFlags?: string;
+  message?: string;
+  suggestion?: string;
+  url?: string;
+  enabled?: boolean;
+  tags?: string[];
+}
+```
+
+## Architecture
+
+```
++---------------------------------------------------------+
+|                  CodeReviewEngine                        |
+|  +--------------+  +--------------+  +--------------+  |
+|  | Rule Engine |  | Custom       |  | Report       |  |
+|  |             |--| Matchers     |--| Generator    |  |
+|  +--------------+  +--------------+  +--------------+  |
+|         |                                      |        |
+|         ▼                                      ▼        |
+|  +--------------+                     +--------------+  |
+|  | Pattern     |                     | Text|Html|Md  |  |
+|  | Matcher     |                     | Reporters    |  |
+|  +--------------+                     +--------------+  |
++---------------------------------------------------------+
+```

package/packages/code-review/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@pi/code-review",
+  "version": "0.10.30",
+  "description": "Automated code review engine for pi-harness-runtime",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "keywords": [
+    "pi",
+    "harness",
+    "runtime",
+    "code-review",
+    "linting"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^7.0.2"
+  }
+}