pi-harness-runtime 1.1.440 → 1.1.441

package/packages/wiki/test/basic.test.ts

@@ -1,242 +0,0 @@
-/**
- * Wiki Package Basic Tests
- */
-
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-
-// Set feature flag for tests
-process.env.HARNESS_KNOWLEDGE_WIKI = "1";
-
-import { createWikiManager, wikiExists } from "../dist/index.js";
-
-const TEST_DIR = join("/tmp", "wiki-test-" + Date.now());
-
-describe("Wiki Manager", () => {
-  let wiki: ReturnType<typeof createWikiManager>;
-
-  before(async () => {
-    // Clean up any existing test directory
-    rmSync(TEST_DIR, { recursive: true, force: true });
-    mkdirSync(TEST_DIR, { recursive: true });
-    wiki = createWikiManager(TEST_DIR, "test-project");
-  });
-
-  after(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  describe("Initialization", () => {
-    it("should initialize wiki structure", () => {
-      // WikiStorage constructor creates structure, so initialize() may see existing
-      const result = wiki.initialize();
-      // Either freshly created or already existed
-      assert.ok(result.created || result.existing);
-      assert.ok(existsSync(join(TEST_DIR, "wiki")));
-      assert.ok(existsSync(join(TEST_DIR, "wiki", "knowledge")));
-      assert.ok(existsSync(join(TEST_DIR, "wiki", "raw")));
-      assert.ok(existsSync(join(TEST_DIR, "wiki", ".harness")));
-      assert.ok(existsSync(join(TEST_DIR, "wiki", "SCHEMA.md")));
-    });
-
-    it("should detect existing wiki on subsequent calls", () => {
-      const result = wiki.initialize();
-      assert.strictEqual(result.created, false);
-      assert.ok(result.existing);
-    });
-
-    it("should check if wiki is initialized", () => {
-      assert.strictEqual(wiki.isInitialized(), true);
-    });
-  });
-
-  describe("Page Operations", () => {
-    it("should create a page", () => {
-      const page = wiki.createPage({
-        title: "Test Concept",
-        kind: "concept",
-        body: "# Test Concept\n\nThis is a test concept.",
-      });
-
-      assert.ok(page.frontmatter.id.startsWith("page-"));
-      assert.strictEqual(page.frontmatter.title, "Test Concept");
-      assert.strictEqual(page.frontmatter.kind, "concept");
-      assert.strictEqual(page.frontmatter.status, "proposed");
-      assert.ok(page.body.includes("test concept"));
-    });
-
-    it("should load a page", () => {
-      const created = wiki.createPage({
-        title: "Load Test",
-        kind: "decision",
-        body: "# Load Test\n\nTesting load functionality.",
-      });
-
-      const loaded = wiki.loadPage(created.frontmatter.id);
-      assert.ok(loaded);
-      assert.strictEqual(loaded!.frontmatter.title, "Load Test");
-    });
-
-    it("should update a page", () => {
-      const created = wiki.createPage({
-        title: "Update Test",
-        kind: "reference",
-        body: "# Update Test\n\nOriginal content.",
-      });
-
-      const updated = wiki.updatePage(created.frontmatter.id, {
-        status: "verified",
-        body: "# Update Test\n\nUpdated content.",
-      });
-
-      assert.strictEqual(updated.frontmatter.status, "verified");
-      assert.ok(updated.body.includes("Updated"));
-    });
-
-    it("should delete a page", () => {
-      const created = wiki.createPage({
-        title: "Delete Test",
-        kind: "plan",
-        body: "# Delete Test\n\nWill be deleted.",
-      });
-
-      wiki.deletePage(created.frontmatter.id);
-      const loaded = wiki.loadPage(created.frontmatter.id);
-      assert.strictEqual(loaded, null);
-    });
-
-    it("should get all pages", () => {
-      const pages = wiki.getAllPages();
-      assert.ok(pages.length >= 0);
-    });
-  });
-
-  describe("Search", () => {
-    it("should search pages by title", () => {
-      // Create a page with known title
-      wiki.createPage({
-        title: "Searchable Concept",
-        kind: "concept",
-        body: "This page is about searching functionality.",
-      });
-
-      const results = wiki.search("Searchable");
-      assert.ok(results.length > 0);
-      assert.strictEqual(results[0].page.title, "Searchable Concept");
-    });
-
-    it("should search pages by body content", () => {
-      const results = wiki.search("functionality");
-      assert.ok(results.some(r => r.page.title === "Searchable Concept"));
-    });
-
-    it("should get page index", () => {
-      const index = wiki.getIndex();
-      assert.ok(Array.isArray(index));
-    });
-  });
-
-  describe("Source Ingestion", () => {
-    it("should ingest a source file", async () => {
-      // Create a test file
-      const testFile = join(TEST_DIR, "test-source.md");
-      const { writeFileSync } = await import("node:fs");
-      writeFileSync(testFile, "# Test Source\n\nThis is a test source file.", "utf8");
-
-      const { snapshot, operation } = wiki.ingestSource(testFile);
-
-      assert.ok(snapshot.id.startsWith("snap-"));
-      assert.strictEqual(snapshot.originalPath, testFile);
-      assert.ok(snapshot.contentHash);
-      assert.ok(operation.status === "pending" || operation.status === "success");
-    });
-
-    it("should get snapshot by ID", async () => {
-      // First ingest
-      const testFile = join(TEST_DIR, "test-snapshot.md");
-      const { writeFileSync } = await import("node:fs");
-      writeFileSync(testFile, "# Test Snapshot\n\nContent.", "utf8");
-
-      const { snapshot } = wiki.ingestSource(testFile);
-      const loaded = wiki.getSnapshot(snapshot.id);
-
-      assert.ok(loaded);
-      assert.strictEqual(loaded!.id, snapshot.id);
-    });
-  });
-
-  describe("Lint", () => {
-    it("should run lint checks", () => {
-      // Create a page without verification
-      wiki.createPage({
-        title: "Unverified Page",
-        kind: "decision",
-        body: "This page needs verification.",
-      });
-
-      const findings = wiki.lint();
-
-      // Should find pages without verification evidence
-      const evidenceFindings = findings.filter(f => f.category === "evidence");
-      assert.ok(evidenceFindings.length >= 0);
-    });
-  });
-
-  describe("Staged Changes", () => {
-    it("should stage a change", () => {
-      const page = wiki.createPage({
-        title: "Staged Page",
-        kind: "concept",
-        body: "# Staged Page\n\nOriginal.",
-      });
-
-      // Use any non-empty revision for testing
-      const revision = "test-revision-hash";
-
-      const change = wiki.stageChange(
-        page.frontmatter.id,
-        revision,
-        `---\nid: ${page.frontmatter.id}\ntitle: Staged Page\nkind: concept\nprojectId: test\nstatus: proposed\ncreatedAt: ${new Date().toISOString()}\nupdatedAt: ${new Date().toISOString()}\nsources: []\nrelatedPages: []\n---\n\n# Staged Page\n\nUpdated.`
-      );
-
-      assert.strictEqual(change.pageId, page.frontmatter.id);
-    });
-
-    it("should get staged change", () => {
-      const pages = wiki.getAllPages();
-      const stagedPage = pages.find(p => p.frontmatter.title === "Staged Page");
-      assert.ok(stagedPage);
-
-      const change = wiki.getStagedChange(stagedPage!.frontmatter.id);
-      assert.ok(change, "Staged change should exist");
-    });
-  });
-
-  describe("Operations", () => {
-    it("should get recent operations", () => {
-      const operations = wiki.getRecentOperations();
-      assert.ok(Array.isArray(operations));
-      // Operations should exist after initialization and page operations
-      assert.ok(operations.length >= 0);
-    });
-  });
-});
-
-describe("Wiki Exists Check", () => {
-  it("should detect existing wiki", () => {
-    const testDir = join("/tmp", "wiki-exists-test-" + Date.now());
-    mkdirSync(testDir, { recursive: true });
-    mkdirSync(join(testDir, "wiki", "knowledge"), { recursive: true });
-
-    assert.strictEqual(wikiExists(testDir), true);
-
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  it("should detect non-existing wiki", () => {
-    assert.strictEqual(wikiExists("/tmp/nonexistent-wiki-path"), false);
-  });
-});

package/packages/workspace-scanner/test/scanner.test.ts

@@ -1,43 +0,0 @@
-/// <reference types="node" />
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { deepStrictEqual, equal } from "node:assert";
-import { join } from "node:path";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { WorkspaceScanner } from "../src/scanner.js";
-
-describe("WorkspaceScanner", () => {
-	const testDir = join(tmpdir(), "ws-test-" + Date.now());
-	beforeEach(() => mkdirSync(testDir, { recursive: true }));
-	afterEach(() => rmSync(testDir, { recursive: true, force: true }));
-
-	it("detects package.json", async () => {
-		writeFileSync(
-			join(testDir, "package.json"),
-			JSON.stringify({ name: "test" }),
-		);
-		const scanner = new WorkspaceScanner(testDir);
-		const snap = await scanner.scan();
-		equal(snap.hasNode, true);
-	});
-
-	it("skips git when requested", async () => {
-		const scanner = new WorkspaceScanner(testDir);
-		const snap = await scanner.scan({ skipGit: true });
-		deepStrictEqual(snap.git, null);
-	});
-
-	it("skips config when requested", async () => {
-		const scanner = new WorkspaceScanner(testDir);
-		const snap = await scanner.scan({ skipConfig: true });
-		deepStrictEqual(snap.project, {});
-		equal(snap.configFiles.length, 0);
-	});
-
-	it("detects env files", async () => {
-		writeFileSync(join(testDir, ".env.local"), "SECRET=x");
-		const scanner = new WorkspaceScanner(testDir);
-		const snap = await scanner.scan({ skipConfig: false });
-		equal(snap.envFiles.includes(".env.local"), true);
-	});
-});

package/packages/worktree/test/worktree.test.ts

@@ -1,163 +0,0 @@
-/**
- * Worktree Manager Tests
- */
-
-import { describe, it, expect, beforeEach, vi } from "bun:test";
-import { WorktreeManager } from "../src/worktree.js";
-
-// The file system and the command runner are injected: a module mock would
-// replace `node:fs` for every test file that runs later in the same process.
-const mockExecSync = vi.fn().mockReturnValue("/mocked/path/worktrees/test-wt");
-const mockExistsSync = vi.fn().mockReturnValue(false);
-const mockMkdirSync = vi.fn();
-const mockWriteFileSync = vi.fn();
-const mockReadFileSync = vi.fn().mockReturnValue("[]");
-
-const mockFileSystem = {
-	existsSync: mockExistsSync,
-	mkdirSync: mockMkdirSync,
-	writeFileSync: mockWriteFileSync,
-	readFileSync: mockReadFileSync,
-};
-
-function createManager(options: { rootDir?: string; baseBranch?: string } = {}): WorktreeManager {
-	return new WorktreeManager({
-		rootDir: options.rootDir ?? "/tmp/test-repo",
-		baseBranch: options.baseBranch ?? "main",
-		fs: mockFileSystem,
-		exec: (command, execOptions) => mockExecSync(command, execOptions),
-	});
-}
-
-describe("WorktreeManager", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		mockExecSync.mockReturnValue("/mocked/path/worktrees/test-wt");
-		mockExistsSync.mockReturnValue(false);
-		mockReadFileSync.mockReturnValue("[]");
-	});
-
-	describe("constructor", () => {
-		it("creates instance with rootDir", () => {
-			const manager = createManager();
-			expect(manager).toBeDefined();
-		});
-	});
-
-	describe("create", () => {
-		it("creates a worktree with name", async () => {
-			const manager = createManager();
-			const result = await manager.create({ name: "test-wt" });
-			expect(result.name).toBe("test-wt");
-			expect(result.branch).toBe("worktree/test-wt");
-			expect(result.status).toBe("active");
-		});
-
-		it("sanitizes name", async () => {
-			const manager = createManager();
-			const result = await manager.create({ name: "my worktree!" });
-			expect(result.name).toBe("my-worktree-");
-		});
-
-		it("uses custom branch if provided", async () => {
-			const manager = createManager();
-			const result = await manager.create({
-				name: "my-wt",
-				branch: "feature/my-branch",
-			});
-			expect(result.branch).toBe("feature/my-branch");
-		});
-
-		it("stores jobId and taskId", async () => {
-			const manager = createManager();
-			const result = await manager.create({
-				name: "job-wt",
-				jobId: "job-123",
-				taskId: "task-456",
-			});
-			expect(result.jobId).toBe("job-123");
-			expect(result.taskId).toBe("task-456");
-		});
-
-		it("sets createdAt timestamp", async () => {
-			const manager = createManager();
-			const before = Date.now();
-			const result = await manager.create({ name: "time-wt" });
-			const after = Date.now();
-			const created = Date.parse(result.createdAt);
-			expect(created >= before && created <= after).toBe(true);
-		});
-	});
-
-	describe("list", () => {
-		it("returns empty array when no worktrees", async () => {
-			const manager = createManager();
-			const result = await manager.list();
-			expect(result).toEqual([]);
-		});
-	});
-
-	describe("get", () => {
-		it("returns null for unknown worktree", async () => {
-			const manager = createManager();
-			const result = await manager.get("nonexistent");
-			expect(result).toBeNull();
-		});
-	});
-
-	describe("getByJob", () => {
-		it("returns null when no worktree for job", async () => {
-			const manager = createManager();
-			const result = await manager.getByJob("unknown-job");
-			expect(result).toBeNull();
-		});
-	});
-
-	describe("remove", () => {
-		it("throws for unknown worktree", async () => {
-			const manager = createManager();
-			await expect(manager.remove("nonexistent")).rejects.toThrow();
-		});
-	});
-
-	describe("prune", () => {
-		it("returns pruned worktrees", async () => {
-			const manager = createManager();
-			mockExecSync.mockReturnValue("worktree /mocked/path/worktrees/test-wt");
-			const result = await manager.prune();
-			expect(Array.isArray(result)).toBe(true);
-		});
-	});
-
-	describe("getUncommitted", () => {
-		it("parses numstat output", async () => {
-			const manager = createManager();
-			mockExecSync.mockReturnValue("10\t5\tfile.ts\n20\t0\tnew.ts\n");
-
-			const diffs = await manager.getUncommitted(
-				"/mocked/path/worktrees/test-wt",
-			);
-			expect(diffs.length).toBe(2);
-			expect(diffs[0].file).toBe("file.ts");
-			expect(diffs[0].insertions).toBe(10);
-			expect(diffs[0].deletions).toBe(5);
-		});
-	});
-
-	describe("markMerged", () => {
-		it("marks worktree as merged", async () => {
-			const manager = createManager();
-			await manager.create({ name: "merge-wt" });
-			await manager.markMerged("merge-wt");
-			// Should not throw
-		});
-	});
-
-	describe("metadata persistence", () => {
-		it("saves worktree to .worktrees.json", async () => {
-			const manager = createManager();
-			await manager.create({ name: "persist-wt" });
-			expect(mockWriteFileSync).toHaveBeenCalled();
-		});
-	});
-});