pi-harness-runtime 1.1.440 → 1.1.441

package/packages/mcp-adapter/test/server.test.ts

@@ -1,91 +0,0 @@
-/**
- * MCP Adapter Tests (RFC-0068)
- */
-
-import { describe, it, expect } from "bun:test";
-import { HARNESS_TOOLS, handleToolCall } from "../src/tools.js";
-import type { MCPServerOptions } from "../src/types.js";
-
-describe("MCP Tools", () => {
-	it("exposes 4 harness tools", () => {
-		expect(HARNESS_TOOLS).toHaveLength(4);
-		const names = HARNESS_TOOLS.map((t) => t.name);
-		expect(names).toContain("analyze_workspace");
-		expect(names).toContain("search_memory");
-		expect(names).toContain("list_skills");
-		expect(names).toContain("invoke_skill");
-	});
-
-	it("analyze_workspace tool has correct schema", () => {
-		const tool = HARNESS_TOOLS.find((t) => t.name === "analyze_workspace")!;
-		expect(tool.inputSchema).toBeDefined();
-		const schema = tool.inputSchema as { properties: Record<string, unknown> };
-		expect(schema.properties.path).toBeDefined();
-	});
-
-	it("analyze_workspace returns error for non-existent path", async () => {
-		const result = await handleToolCall("analyze_workspace", {
-			path: "/nonexistent/path/12345",
-		});
-		expect(result.isError).toBe(true);
-		expect(result.content[0].text).toContain("does not exist");
-	});
-
-	it("analyze_workspace detects frameworks in temp dir", async () => {
-		const { mkdirSync, writeFileSync, rmSync } = await import("node:fs");
-		const os = await import("os");
-		const path = await import("node:path");
-		const tmp = os.tmpdir();
-		const testDir = path.join(tmp, "mcp-test-" + Date.now());
-		mkdirSync(testDir);
-		writeFileSync(path.join(testDir, "package.json"), "{}");
-
-		const result = await handleToolCall("analyze_workspace", { path: testDir });
-		rmSync(testDir, { recursive: true });
-
-		expect(result.isError).toBeUndefined();
-		const parsed = JSON.parse(result.content[0].text);
-		expect(parsed.frameworks).toContain("node");
-	});
-
-	it("search_memory returns stub response", async () => {
-		const result = await handleToolCall("search_memory", {
-			query: "frappe",
-			limit: 3,
-		});
-		expect(result.isError).toBeUndefined();
-		const parsed = JSON.parse(result.content[0].text);
-		expect(parsed.note).toContain("runtime integration");
-	});
-
-	it("list_skills returns stub response", async () => {
-		const result = await handleToolCall("list_skills", {});
-		expect(result.isError).toBeUndefined();
-		const parsed = JSON.parse(result.content[0].text);
-		expect(parsed.note).toContain("runtime integration");
-	});
-
-	it("invoke_skill returns stub response", async () => {
-		const result = await handleToolCall("invoke_skill", {
-			name: "test-skill",
-			trigger: { type: "keyword", value: "test" },
-		});
-		expect(result.isError).toBeUndefined();
-		const parsed = JSON.parse(result.content[0].text);
-		expect(parsed.skill).toBe("test-skill");
-	});
-
-	it("unknown tool returns error", async () => {
-		const result = await handleToolCall("unknown_tool");
-		expect(result.isError).toBe(true);
-		expect(result.content[0].text).toContain("Unknown tool");
-	});
-});
-
-describe("MCPServerOptions", () => {
-	it("has correct defaults", () => {
-		const opts: MCPServerOptions = {};
-		expect(opts.name).toBeUndefined();
-		expect(opts.version).toBeUndefined();
-	});
-});

package/packages/memory-engine/test/engine.test.ts

@@ -1,456 +0,0 @@
-/**
- * Memory Engine Tests (RFC-0060)
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import {
-	type MemoryEngine,
-	createMemoryEngine,
-	extractLinks,
-	validateConcept,
-} from "../src/index.js";
-import type { WriteConceptRequest } from "../src/index.js";
-
-// Temp directories for filesystem tests
-const tempDirs: string[] = [];
-
-afterEach(async () => {
-	// Clean up temp directories
-	for (const dir of tempDirs) {
-		try {
-			await fs.rm(dir, { recursive: true, force: true });
-		} catch {
-			// ignore
-		}
-	}
-	tempDirs.length = 0;
-});
-
-async function mkdtemp(): Promise<string> {
-	const dir = await fs.mkdtemp(path.join(os.tmpdir(), "memory-engine-"));
-	tempDirs.push(dir);
-	return dir;
-}
-
-describe("MemoryEngine", () => {
-	let engine: MemoryEngine;
-
-	beforeEach(() => {
-		engine = createMemoryEngine();
-	});
-
-	describe("loadBundle", () => {
-		it("loads an empty bundle", async () => {
-			const bundle = await engine.loadBundle("/tmp/knowledge");
-
-			expect(bundle).toBeDefined();
-			expect(bundle.concepts).toEqual([]);
-			expect(bundle.path).toBe("/tmp/knowledge");
-		});
-	});
-
-	describe("writeConcept", () => {
-		it("writes a new concept", async () => {
-			const request: WriteConceptRequest = {
-				type: "Engineering Lesson",
-				title: "Test Lesson",
-				body: "This is a test lesson body",
-				tags: ["test", "lesson"],
-				authority: "generated",
-			};
-
-			const concept = await engine.writeConcept(request);
-
-			expect(concept).toBeDefined();
-			expect(concept.type).toBe("Engineering Lesson");
-			expect(concept.title).toBe("Test Lesson");
-			expect(concept.body).toBe("This is a test lesson body");
-			expect(concept.tags).toContain("test");
-			expect(concept.tags).toContain("lesson");
-			expect(concept.timestamp).toBeDefined();
-		});
-
-		it("generates unique IDs", async () => {
-			const request: WriteConceptRequest = {
-				type: "Test",
-				body: "Test body",
-			};
-
-			const concept1 = await engine.writeConcept(request);
-			const concept2 = await engine.writeConcept(request);
-
-			expect(concept1.id).not.toBe(concept2.id);
-		});
-	});
-
-	describe("validateConcept", () => {
-		it("accepts valid concept with frontmatter and type", () => {
-			const content = `---
-type: Test Type
-title: Test Title
-tags: [test, sample]
----
-
-Body content`;
-
-			const result = validateConcept(content, "test.md");
-
-			expect(result.valid).toBe(true);
-			expect(result.errors).toHaveLength(0);
-		});
-
-		it("rejects concept missing frontmatter", () => {
-			const content = `No frontmatter here`;
-
-			const result = validateConcept(content, "test.md");
-
-			expect(result.valid).toBe(false);
-			expect(
-				result.errors.some((e) => e.message.includes("YAML frontmatter")),
-			).toBe(true);
-		});
-
-		it("rejects concept missing type field", () => {
-			const content = `---
-title: Test Title
----
-
-Body content`;
-
-			const result = validateConcept(content, "test.md");
-
-			expect(result.valid).toBe(false);
-			expect(
-				result.errors.some((e) => e.message.includes("'type' field")),
-			).toBe(true);
-		});
-	});
-
-	describe("search", () => {
-		beforeEach(() => {
-			engine.writeConcept({
-				type: "Lesson",
-				title: "Git Best Practices",
-				body: "Use worktrees for parallel work",
-				tags: ["git", "workflow"],
-				authority: "approved",
-			});
-			engine.writeConcept({
-				type: "Pattern",
-				title: "Error Handling",
-				body: "Handle errors gracefully",
-				tags: ["errors", "best-practices"],
-				authority: "generated",
-			});
-		});
-
-		it("searches by type", () => {
-			const results = engine.search({ types: ["Lesson"] });
-
-			expect(results.length).toBe(1);
-			expect(results[0].concept.type).toBe("Lesson");
-		});
-
-		it("searches by tag", () => {
-			const results = engine.search({ tags: ["git"] });
-
-			expect(results.length).toBe(1);
-			expect(results[0].concept.tags).toContain("git");
-		});
-
-		it("filters by authority", () => {
-			const results = engine.search({ authority: ["approved"] });
-
-			expect(results.length).toBe(1);
-			expect(results[0].concept.metadata.authority).toBe("approved");
-		});
-
-		it("returns empty for no matches", () => {
-			const results = engine.search({ types: ["NonExistent"] });
-
-			expect(results).toHaveLength(0);
-		});
-	});
-
-	describe("promoteFromBlackboard", () => {
-		it("promotes blackboard content with type", () => {
-			const content = "This is blackboard content";
-			const metadata = {
-				type: "Lesson",
-				title: "Promoted Lesson",
-				tags: ["promoted"],
-			};
-
-			const request = engine.promoteFromBlackboard(content, metadata);
-
-			expect(request.type).toBe("Lesson");
-			expect(request.title).toBe("Promoted Lesson");
-			expect(request.body).toBe(content);
-		});
-
-		it("filters secrets from content", () => {
-			const content = `API_KEY=secret123\npassword=mypassword\nusername=test`;
-			const metadata = { type: "Config" };
-
-			const request = engine.promoteFromBlackboard(content, metadata);
-
-			expect(request.body).not.toContain("secret123");
-			expect(request.body).toContain("API_KEY=[REDACTED]");
-		});
-	});
-
-	describe("exportToOkf", () => {
-		it("exports concept to OKF format", async () => {
-			const concept = await engine.writeConcept({
-				type: "Lesson",
-				title: "Export Test",
-				body: "Test body content",
-				tags: ["export"],
-				authority: "approved",
-			});
-
-			const okf = engine.exportToOkf(concept);
-
-			expect(okf).toContain("---");
-			expect(okf).toContain("type: Lesson");
-			expect(okf).toContain("title: Export Test");
-			expect(okf).toContain("authority: approved");
-			expect(okf).toContain("Test body content");
-		});
-
-		it("excludes bundle-level fields from exported frontmatter", async () => {
-			const concept = await engine.writeConcept({
-				type: "Lesson",
-				title: "Bundle Fields Test",
-				body: "Body",
-				authority: "approved",
-			});
-
-			// Simulate bundle-level metadata merged by loadBundle
-			const withBundleMeta = {
-				...concept,
-				metadata: {
-					...concept.metadata,
-					index: "previous-index-content",
-					log: "previous-log-content",
-					directories: ["/some/path"],
-					extra: "should-appear",
-				},
-			};
-
-			const okf = engine.exportToOkf(withBundleMeta);
-
-			expect(okf).not.toContain("index:");
-			expect(okf).not.toContain("log:");
-			expect(okf).not.toContain("directories:");
-			expect(okf).toContain("extra: should-appear");
-		});
-	});
-
-	describe("Filesystem Operations", () => {
-		it("writeConcept persists file to disk", async () => {
-			const dir = await mkdtemp();
-			const e = createMemoryEngine();
-			await e.loadBundle(dir);
-
-			await e.writeConcept({
-				type: "Lesson",
-				title: "Persisted Concept",
-				body: "This was written to disk",
-				tags: ["disk"],
-				authority: "approved",
-			});
-
-			// Verify file was created
-			const files = await fs.readdir(dir);
-			const conceptFile = files.find(
-				(f) => f.endsWith(".md") && f !== "index.md" && f !== "log.md",
-			);
-			expect(conceptFile).toBeDefined();
-
-			const content = await fs.readFile(path.join(dir, conceptFile!), "utf-8");
-			expect(content).toContain("Persisted Concept");
-			expect(content).toContain("This was written to disk");
-		});
-
-		it("loadBundle reads files from disk", async () => {
-			const dir = await mkdtemp();
-
-			// Write a concept file directly
-			await fs.writeFile(
-				path.join(dir, "from-disk.md"),
-				`---
-type: Lesson
-title: From Disk
-tags: [loaded, disk]
-authority: approved
----
-
-This concept was written directly to disk.`,
-				"utf-8",
-			);
-			await fs.writeFile(
-				path.join(dir, "index.md"),
-				"# Knowledge Index",
-				"utf-8",
-			);
-			await fs.writeFile(
-				path.join(dir, "log.md"),
-				"## Log\n- Entry 1",
-				"utf-8",
-			);
-
-			const e = createMemoryEngine();
-			const bundle = await e.loadBundle(dir);
-
-			expect(bundle.concepts.length).toBeGreaterThanOrEqual(1);
-			const loaded = bundle.concepts.find((c) => c.title === "From Disk");
-			expect(loaded).toBeDefined();
-			expect(loaded!.type).toBe("Lesson");
-			expect(loaded!.tags).toContain("loaded");
-			expect(loaded!.body).toContain("directly to disk");
-			expect(bundle.index).toContain("Knowledge Index");
-			expect(bundle.log).toContain("Entry 1");
-		});
-
-		it("loadBundle excludes reserved files (index.md, log.md)", async () => {
-			const dir = await mkdtemp();
-
-			await fs.writeFile(
-				path.join(dir, "index.md"),
-				"# Index Content",
-				"utf-8",
-			);
-			await fs.writeFile(path.join(dir, "log.md"), "# Log Content", "utf-8");
-			await fs.writeFile(
-				path.join(dir, "real-concept.md"),
-				`---
-type: Pattern
-title: Real Concept
----
-
-Body`,
-				"utf-8",
-			);
-
-			const e = createMemoryEngine();
-			const bundle = await e.loadBundle(dir);
-
-			expect(bundle.concepts.some((c) => c.title === "Real Concept")).toBe(
-				true,
-			);
-			expect(bundle.concepts.some((c) => c.id === "index")).toBe(false);
-			expect(bundle.concepts.some((c) => c.id === "log")).toBe(false);
-		});
-
-		it("writeConcept generates slug-based IDs from title", async () => {
-			const dir = await mkdtemp();
-			const e = createMemoryEngine();
-			await e.loadBundle(dir);
-
-			const concept = await e.writeConcept({
-				type: "Lesson",
-				title: "My Test Concept Title",
-				body: "Body",
-			});
-
-			// ID should start with slugified title
-			expect(concept.id).toMatch(/^my-test-concept-title-/);
-		});
-
-		it("rebuildIndex writes index.md to disk", async () => {
-			const dir = await mkdtemp();
-			const e = createMemoryEngine();
-			await e.loadBundle(dir);
-
-			await e.writeConcept({
-				type: "Pattern",
-				title: "Indexed Concept",
-				body: "Body",
-			});
-
-			await e.rebuildIndex(dir);
-
-			const indexContent = await fs.readFile(
-				path.join(dir, "index.md"),
-				"utf-8",
-			);
-			expect(indexContent).toContain("Knowledge Index");
-			expect(indexContent).toContain("Indexed Concept");
-		});
-	});
-});
-
-describe("extractLinks", () => {
-	it("extracts markdown links", () => {
-		const markdown = `
-Check out [the docs](https://example.com/docs).
-
-Also see [another link](https://example.com/other).
-`;
-
-		const links = extractLinks(markdown);
-
-		expect(links).toHaveLength(2);
-		expect(links[0]).toEqual({
-			href: "https://example.com/docs",
-			title: "the docs",
-		});
-		expect(links[1]).toEqual({
-			href: "https://example.com/other",
-			title: "another link",
-		});
-	});
-
-	it("returns empty array for no links", () => {
-		const markdown = "No links here";
-
-		const links = extractLinks(markdown);
-
-		expect(links).toHaveLength(0);
-	});
-});
-
-describe("validateConcept", () => {
-	it("validates concept with all required fields", () => {
-		const content = `---
-type: Test Concept
-title: Valid Concept
-tags: [test, valid]
-authority: approved
----
-
-This is the body.
-`;
-
-		const result = validateConcept(content, "concept.md");
-
-		expect(result.valid).toBe(true);
-		expect(result.errors).toHaveLength(0);
-	});
-
-	it("rejects missing type field", () => {
-		const content = `---
-title: Missing Type
----
-
-Body
-`;
-
-		const result = validateConcept(content, "concept.md");
-
-		expect(result.valid).toBe(false);
-		expect(result.errors.length).toBeGreaterThan(0);
-	});
-
-	it("rejects missing frontmatter", () => {
-		const content = `Just plain text`;
-
-		const result = validateConcept(content, "concept.md");
-
-		expect(result.valid).toBe(false);
-	});
-});