pi-harness-runtime 0.10.43 → 1.1.1

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

@@ -0,0 +1,302 @@
+/**
+ * Code Review Engine - Tests
+ */
+
+import { describe, it, expect } from "bun:test";
+import { createCodeReviewEngine, SDK_VERSION } from "../src/index.js";
+
+describe("CodeReviewEngine", () => {
+	describe("SDK_VERSION", () => {
+		it("should export SDK_VERSION", () => {
+			expect(SDK_VERSION).toBeDefined();
+			expect(typeof SDK_VERSION).toBe("string");
+		});
+	});
+
+	describe("createCodeReviewEngine", () => {
+		it("should create a code review engine instance", () => {
+			const engine = createCodeReviewEngine();
+			expect(engine).toBeDefined();
+		});
+	});
+
+	describe("default rules", () => {
+		const engine = createCodeReviewEngine();
+
+		it("should have default rules", () => {
+			const rules = engine.getRules();
+			expect(rules.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe("code review", () => {
+		const engine = createCodeReviewEngine();
+
+		it("should detect eval usage", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `const result = eval(userInput);`,
+					},
+				],
+			});
+
+			expect(result.issues.some((i) => i.rule === "security/no-eval")).toBe(
+				true,
+			);
+		});
+
+		it("should detect console statements", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `console.log("debug");`,
+					},
+				],
+			});
+
+			expect(
+				result.issues.some((i) => i.rule === "best-practice/no-console"),
+			).toBe(true);
+		});
+
+		it("should detect innerHTML usage", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `element.innerHTML = "<b>bold</b>";`,
+					},
+				],
+			});
+
+			expect(
+				result.issues.some((i) => i.rule === "security/no-inner-html"),
+			).toBe(true);
+		});
+
+		it("should detect sync file I/O", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `const data = fs.readFileSync("file.txt");`,
+					},
+				],
+			});
+
+			expect(result.issues.some((i) => i.rule === "performance/no-sync")).toBe(
+				true,
+			);
+		});
+
+		it("should return summary statistics", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `console.log("test");`,
+					},
+				],
+			});
+
+			expect(result.summary).toBeDefined();
+			expect(result.summary.total).toBeGreaterThanOrEqual(0);
+		});
+
+		it("should return review statistics", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `const x = 1;`,
+					},
+				],
+			});
+
+			expect(result.stats).toBeDefined();
+			expect(result.stats.filesReviewed).toBe(1);
+			expect(result.stats.linesReviewed).toBeGreaterThan(0);
+		});
+	});
+
+	describe("custom rules", () => {
+		const engine = createCodeReviewEngine();
+
+		it("should add custom rules", () => {
+			engine.addRule({
+				id: "custom/no-bad-words",
+				name: "No bad words",
+				severity: "warning",
+				category: "style",
+				description: "Avoid certain words",
+				pattern: "\\bTODO\\b",
+			});
+
+			const rules = engine.getRules();
+			expect(rules.some((r) => r.id === "custom/no-bad-words")).toBe(true);
+		});
+
+		it("should add multiple rules", () => {
+			engine.addRules([
+				{
+					id: "custom/rule-1",
+					name: "Rule 1",
+					severity: "info",
+					category: "style",
+					description: "Test rule 1",
+					pattern: "test1",
+				},
+				{
+					id: "custom/rule-2",
+					name: "Rule 2",
+					severity: "info",
+					category: "style",
+					description: "Test rule 2",
+					pattern: "test2",
+				},
+			]);
+
+			const rules = engine.getRules();
+			expect(rules.some((r) => r.id === "custom/rule-1")).toBe(true);
+			expect(rules.some((r) => r.id === "custom/rule-2")).toBe(true);
+		});
+
+		it("should apply custom rules", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `TODO: Fix this later`,
+					},
+				],
+			});
+
+			expect(result.issues.some((i) => i.rule === "style/no-todo")).toBe(true);
+		});
+	});
+
+	describe("custom matchers", () => {
+		const engine = createCodeReviewEngine();
+
+		it("should register custom matcher", async () => {
+			engine.registerCustomMatcher("complexity", (file) => {
+				const issues = [];
+				if (file.content.includes("function veryLongFunctionName")) {
+					issues.push({
+						id: "complex/function-name",
+						severity: "warning",
+						category: "maintainability",
+						title: "Long function name",
+						message: "Function name is very long",
+						file: file.path,
+					});
+				}
+				return issues;
+			});
+
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `function veryLongFunctionNameThatDoesALotOfStuff() {}`,
+					},
+				],
+			});
+
+			expect(result.issues.some((i) => i.id === "complex/function-name")).toBe(
+				true,
+			);
+		});
+	});
+
+	describe("reports", () => {
+		const engine = createCodeReviewEngine();
+
+		it("should generate JSON report", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `console.log("test");`,
+					},
+				],
+			});
+
+			const report = engine.generateReport(result, { format: "json" });
+			expect(typeof report).toBe("string");
+			expect(() => JSON.parse(report)).not.toThrow();
+		});
+
+		it("should generate text report", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `console.log("test");`,
+					},
+				],
+			});
+
+			const report = engine.generateReport(result, { format: "text" });
+			expect(typeof report).toBe("string");
+			expect(report).toContain("CODE REVIEW REPORT");
+		});
+
+		it("should generate markdown report", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `console.log("test");`,
+					},
+				],
+			});
+
+			const report = engine.generateReport(result, { format: "markdown" });
+			expect(typeof report).toBe("string");
+			expect(report).toContain("# Code Review Report");
+		});
+
+		it("should generate HTML report", async () => {
+			const result = await engine.review({
+				files: [
+					{
+						path: "test.js",
+						content: `console.log("test");`,
+					},
+				],
+			});
+
+			const report = engine.generateReport(result, { format: "html" });
+			expect(typeof report).toBe("string");
+			expect(report).toContain("<!DOCTYPE html>");
+		});
+	});
+
+	describe("rule sets", () => {
+		const engine = createCodeReviewEngine();
+
+		it("should add rule set", () => {
+			engine.addRuleSet({
+				name: "strict-security",
+				description: "Strict security rules",
+				rules: [
+					{
+						id: "strict/no-eval",
+						name: "No eval (strict)",
+						severity: "error",
+						category: "security",
+						description: "eval is forbidden",
+						pattern: "\\beval\\s*\\(",
+					},
+				],
+			});
+
+			const rules = engine.getRules();
+			expect(rules.some((r) => r.id === "strict/no-eval")).toBe(true);
+		});
+	});
+});

package/packages/codex-adapter/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@pi/codex-adapter",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "OpenAI Codex provider adapter for pi-harness",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "openai": "^7.4.0"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}

package/packages/codex-adapter/test/provider.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Codex Adapter Tests (RFC-0070)
+ */
+
+import { describe, it, expect } from "bun:test";
+import { CodexProvider } from "../src/provider.js";
+import { ExecutionSandbox } from "../src/executor.js";
+import { DEFAULT_TOOLS } from "../src/types.js";
+
+describe("CodexProvider", () => {
+	it("creates provider with API key", () => {
+		const provider = new CodexProvider({ apiKey: "sk-test-key" });
+		expect(provider.id).toBe("codex");
+		expect(provider.name).toBe("OpenAI Codex");
+		expect(provider.provider).toBeDefined();
+	});
+
+	it("creates provider with custom config", () => {
+		const provider = new CodexProvider({
+			apiKey: "sk-test",
+			model: "o3",
+			maxTokens: 4096,
+			temperature: 0.5,
+		});
+		expect(provider).toBeDefined();
+	});
+
+	it("throws without API key", () => {
+		expect(() => new CodexProvider({ apiKey: "" })).toThrow();
+		expect(() => new CodexProvider({ apiKey: "   " })).toThrow();
+	});
+
+	it("healthCheck returns false for invalid key", async () => {
+		const provider = new CodexProvider({
+			apiKey: "sk-invalid-key-for-health-check-test",
+			timeout: 5000,
+		});
+		const healthy = await provider.healthCheck();
+		expect(healthy).toBe(false);
+	});
+
+	it("estimateCost calculates correctly for gpt-4o", () => {
+		const provider = new CodexProvider({ apiKey: "sk-test" });
+		const cost = provider.estimateCost(1000, 500);
+		// gpt-4o: 1000/1M * $2.5 + 500/1M * $10 = $0.0025 + $0.005 = $0.0075
+		expect(cost).toBeCloseTo(0.0075, 4);
+	});
+
+	it("estimateCost calculates correctly for o4-mini", () => {
+		const provider = new CodexProvider({ apiKey: "sk-test", model: "o4-mini" });
+		const cost = provider.estimateCost(1000, 500);
+		// o4-mini: 1000/1M * $1 + 500/1M * $4 = $0.001 + $0.002 = $0.003
+		expect(cost).toBeCloseTo(0.003, 4);
+	});
+});
+
+describe("DEFAULT_TOOLS", () => {
+	it("has 4 default tools", () => {
+		expect(DEFAULT_TOOLS).toHaveLength(4);
+		const names = DEFAULT_TOOLS.map((t) => t.name);
+		expect(names).toContain("Read");
+		expect(names).toContain("Write");
+		expect(names).toContain("Bash");
+		expect(names).toContain("WebSearch");
+	});
+
+	it("all tools have required fields", () => {
+		for (const tool of DEFAULT_TOOLS) {
+			expect(tool.type).toBe("function");
+			expect(typeof tool.name).toBe("string");
+			expect(typeof tool.description).toBe("string");
+			expect(tool.parameters).toBeDefined();
+			expect(tool.parameters.type).toBe("object");
+		}
+	});
+});
+
+describe("ExecutionSandbox", () => {
+	it("creates sandbox with defaults", () => {
+		const sandbox = new ExecutionSandbox();
+		expect(sandbox).toBeDefined();
+	});
+
+	it("creates sandbox with custom config", () => {
+		const sandbox = new ExecutionSandbox({
+			timeout: 10000,
+			memoryLimitMB: 256,
+			cwd: "/tmp",
+			env: { TEST: "1" },
+		});
+		expect(sandbox).toBeDefined();
+	});
+
+	it("executes echo command", async () => {
+		const sandbox = new ExecutionSandbox({ timeout: 5000 });
+		const result = await sandbox.execute("echo 'hello world'");
+		expect(result.exitCode).toBe(0);
+		expect(result.stdout.trim()).toBe("hello world");
+		expect(result.durationMs).toBeGreaterThan(0);
+		expect(result.durationMs).toBeLessThan(5000);
+	});
+
+	it("captures stderr", async () => {
+		const sandbox = new ExecutionSandbox({ timeout: 5000 });
+		const result = await sandbox.execute("echo 'error' >&2");
+		expect(result.stderr.trim()).toBe("error");
+	});
+
+	it("handles non-zero exit code", async () => {
+		const sandbox = new ExecutionSandbox({ timeout: 5000 });
+		const result = await sandbox.execute("exit 42");
+		expect(result.exitCode).toBe(42);
+	});
+
+	it("executeCode runs python", async () => {
+		const sandbox = new ExecutionSandbox({ timeout: 5000 });
+		const result = await sandbox.executeCode("print(2 + 2)", "python");
+		expect(result.exitCode).toBe(0);
+		expect(result.stdout.trim()).toBe("4");
+	});
+
+	it("executeCode runs javascript", async () => {
+		const sandbox = new ExecutionSandbox({ timeout: 5000 });
+		const result = await sandbox.executeCode(
+			"console.log(2 + 2)",
+			"javascript",
+		);
+		expect(result.exitCode).toBe(0);
+		expect(result.stdout.trim()).toBe("4");
+	});
+
+	it(
+		"respects timeout",
+		async () => {
+			const sandbox = new ExecutionSandbox({ timeout: 500 });
+			const result = await sandbox.execute("sleep 5");
+			expect(result.exitCode).toBe(-1);
+			expect(result.durationMs).toBeGreaterThan(400);
+		},
+		{ timeout: 10000 },
+	);
+});

package/packages/config-capture/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@moocoding/config-capture",
+  "version": "0.10.30",
+  "description": "Auto-capture API-fetched configuration values to AGENTS.md",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "keywords": [
+    "pi-extension",
+    "config",
+    "documentation",
+    "dns",
+    "routes"
+  ],
+  "author": "MooCoding",
+  "license": "MIT"
+}

package/packages/context-compiler/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pi/context-compiler",
+  "version": "0.10.30",
+  "description": "Bounded context selection 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"
+    }
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@pi-harness/requirement-compiler": "workspace:*",
+    "@pi-harness/task-compiler": "workspace:*",
+    "@pi-harness/types": "workspace:*"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0",
+    "@biomejs/biome": "^2.5.3",
+    "@types/node": "^20.0.0"
+  }
+}