pi-harness-runtime 1.1.439 → 1.1.441

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

@@ -1,302 +0,0 @@
-/**
- * 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/test/provider.test.ts

@@ -1,142 +0,0 @@
-/**
- * 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 },
-	);
-});