pi-harness-runtime 0.10.43 → 1.1.1

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

@@ -0,0 +1,42 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { 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 });
+		equal(snap.git, null);
+	});
+
+	it("skips config when requested", async () => {
+		const scanner = new WorkspaceScanner(testDir);
+		const snap = await scanner.scan({ skipConfig: true });
+		equal(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/README.md

@@ -0,0 +1,3 @@
+# packages/worktree
+
+Git worktree management will live here.

package/packages/worktree/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/worktree",
+  "version": "0.10.30",
+  "description": "pi-harness-runtime — worktree",
+  "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"
+  },
+  "dependencies": {}
+}

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

@@ -0,0 +1,163 @@
+/**
+ * Worktree Manager Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from "bun:test";
+import { WorktreeManager } from "../src/worktree.js";
+
+// Mock Node.js modules at module level
+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("[]");
+
+vi.mock("node:child_process", () => ({
+	execSync: mockExecSync,
+}));
+
+vi.mock("node:fs", () => ({
+	existsSync: mockExistsSync,
+	mkdirSync: mockMkdirSync,
+	writeFileSync: mockWriteFileSync,
+	readFileSync: mockReadFileSync,
+}));
+
+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 = new WorktreeManager({
+				rootDir: "/tmp/test-repo",
+				baseBranch: "main",
+			});
+			expect(manager).toBeDefined();
+		});
+	});
+
+	describe("create", () => {
+		it("creates a worktree with name", async () => {
+			const manager = new WorktreeManager({
+				rootDir: "/tmp/test-repo",
+				baseBranch: "main",
+			});
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.create({ name: "my worktree!" });
+			expect(result.name).toBe("my-worktree-");
+		});
+
+		it("uses custom branch if provided", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.list();
+			expect(result).toEqual([]);
+		});
+	});
+
+	describe("get", () => {
+		it("returns null for unknown worktree", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.get("nonexistent");
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("getByJob", () => {
+		it("returns null when no worktree for job", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.getByJob("unknown-job");
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("remove", () => {
+		it("throws for unknown worktree", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			await expect(manager.remove("nonexistent")).rejects.toThrow();
+		});
+	});
+
+	describe("prune", () => {
+		it("returns pruned worktrees", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			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 = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			await manager.create({ name: "persist-wt" });
+			expect(mockWriteFileSync).toHaveBeenCalled();
+		});
+	});
+});

package/packages/worktree/worktree.ts

@@ -0,0 +1,293 @@
+/**
+ * Git Worktree Manager — RFC-0005
+ *
+ * Creates isolated workspaces for parallel or recoverable coding tasks.
+ *
+ * Goals:
+ * - avoid branch conflicts
+ * - preserve partial work
+ * - allow reviewer agent to inspect diffs
+ * - allow separate models to work on separate tasks
+ */
+
+import type { WorktreeInfo } from "../../packages/types/src/runtime-types.ts";
+// @ts-expect-error - Bun has built-in Node.js types
+import { execSync } from "node:child_process";
+// @ts-expect-error - Bun has built-in Node.js types
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+// @ts-expect-error - Bun has built-in Node.js types
+import { join, dirname } from "node:path";
+
+export interface WorktreeOptions {
+	rootDir: string;
+	baseBranch?: string;
+}
+
+export interface CreateWorktreeOptions {
+	name: string;
+	branch?: string;
+	jobId?: string;
+	taskId?: string;
+	startPoint?: string;
+}
+
+export interface WorktreeDiff {
+	file: string;
+	status: "added" | "modified" | "deleted" | "renamed";
+	insertions?: number;
+	deletions?: number;
+}
+
+export class WorktreeManager {
+	private readonly rootDir: string;
+	private readonly baseBranch: string;
+	private readonly metaPath: string;
+
+	constructor(options: WorktreeOptions) {
+		this.rootDir = options.rootDir;
+		this.baseBranch = options.baseBranch ?? "main";
+		this.metaPath = join(this.rootDir, ".worktrees.json");
+	}
+
+	/**
+	 * Create a new worktree
+	 */
+	async create(options: CreateWorktreeOptions): Promise<WorktreeInfo> {
+		const name = options.name.replace(/[^a-zA-Z0-9-_]/g, "-");
+		const branch = options.branch ?? `worktree/${name}`;
+		const path = join(this.rootDir, "worktrees", name);
+
+		// Ensure directory exists
+		mkdirSync(dirname(path), { recursive: true });
+
+		// Create git worktree
+		const startPoint = options.startPoint ?? this.baseBranch;
+		const worktreePath = this.execGit([
+			"worktree",
+			"add",
+			"-b",
+			branch,
+			path,
+			startPoint,
+		]);
+
+		// Record metadata
+		const worktree: WorktreeInfo = {
+			name,
+			path: worktreePath,
+			branch,
+			jobId: options.jobId,
+			taskId: options.taskId,
+			createdAt: new Date().toISOString(),
+			status: "active",
+		};
+
+		this.saveWorktree(worktree);
+
+		return worktree;
+	}
+
+	/**
+	 * List all worktrees
+	 */
+	async list(): Promise<WorktreeInfo[]> {
+		if (!existsSync(this.metaPath)) {
+			return [];
+		}
+
+		try {
+			const content = readFileSync(this.metaPath, "utf-8");
+			return JSON.parse(content) as WorktreeInfo[];
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Get worktree by name
+	 */
+	async get(name: string): Promise<WorktreeInfo | null> {
+		const worktrees = await this.list();
+		return worktrees.find((w) => w.name === name) ?? null;
+	}
+
+	/**
+	 * Get worktree by job ID
+	 */
+	async getByJob(jobId: string): Promise<WorktreeInfo | null> {
+		const worktrees = await this.list();
+		return worktrees.find((w) => w.jobId === jobId) ?? null;
+	}
+
+	/**
+	 * Remove a worktree
+	 */
+	async remove(name: string, force: boolean = false): Promise<void> {
+		const worktree = await this.get(name);
+		if (!worktree) {
+			throw new Error(`Worktree ${name} not found`);
+		}
+
+		// Remove git worktree
+		this.execGit(["worktree", "remove", worktree.path, force ? "--force" : ""]);
+
+		// Remove from metadata
+		const worktrees = await this.list();
+		const updated = worktrees.filter((w) => w.name !== name);
+		this.saveAllWorktrees(updated);
+	}
+
+	/**
+	 * Prune stale worktrees
+	 */
+	async prune(): Promise<string[]> {
+		const output = this.execGit(["worktree", "list", "--porcelain"]);
+		const lines = output.split("\n");
+		const pruned: string[] = [];
+
+		// Parse git worktree list
+		const worktreePaths: string[] = [];
+		for (const line of lines) {
+			if (line.startsWith("worktree ")) {
+				worktreePaths.push(line.replace("worktree ", "").trim());
+			}
+		}
+
+		// Check our tracked worktrees
+		const tracked = await this.list();
+		for (const worktree of tracked) {
+			if (!worktreePaths.includes(worktree.path)) {
+				// Git worktree no longer exists
+				worktree.status = "abandoned";
+				pruned.push(worktree.name);
+			}
+		}
+
+		this.saveAllWorktrees(tracked);
+
+		return pruned;
+	}
+
+	/**
+	 * Get diff between worktree and base
+	 */
+	async getDiff(worktreePath: string): Promise<WorktreeDiff[]> {
+		const output = this.execGit(["diff", "--stat", `main...${worktreePath}`], {
+			cwd: worktreePath,
+		});
+
+		const diffs: WorktreeDiff[] = [];
+		const lines = output.split("\n");
+
+		for (const line of lines) {
+			if (!line.includes("|")) continue;
+
+			const [file, stats] = line.split("|").map((s) => s.trim());
+			if (!file || !stats) continue;
+
+			let status: WorktreeDiff["status"] = "modified";
+			if (stats.startsWith("+")) status = "added";
+			else if (stats.startsWith("-")) status = "deleted";
+
+			const match = stats.match(/\+(\d+)/);
+			const insertions = match ? parseInt(match[1], 10) : undefined;
+
+			const delMatch = stats.match(/-(\d+)/);
+			const deletions = delMatch ? parseInt(delMatch[1], 10) : undefined;
+
+			diffs.push({ file, status, insertions, deletions });
+		}
+
+		return diffs;
+	}
+
+	/**
+	 * Get uncommitted changes
+	 */
+	async getUncommitted(worktreePath: string): Promise<WorktreeDiff[]> {
+		const output = this.execGit(["diff", "--numstat"], { cwd: worktreePath });
+
+		const diffs: WorktreeDiff[] = [];
+		const lines = output.split("\n");
+
+		for (const line of lines) {
+			const parts = line.split("\t");
+			if (parts.length < 3) continue;
+
+			const [ins, del, file] = parts;
+			diffs.push({
+				file,
+				status: "modified",
+				insertions: parseInt(ins, 10) || 0,
+				deletions: parseInt(del, 10) || 0,
+			});
+		}
+
+		return diffs;
+	}
+
+	/**
+	 * Mark worktree as merged
+	 */
+	async markMerged(name: string): Promise<void> {
+		const worktrees = await this.list();
+		const worktree = worktrees.find((w) => w.name === name);
+		if (worktree) {
+			worktree.status = "merged";
+			this.saveAllWorktrees(worktrees);
+		}
+	}
+
+	/**
+	 * Execute git command
+	 */
+	private execGit(args: string[], options?: { cwd?: string }): string {
+		try {
+			const cwd = options?.cwd ?? this.rootDir;
+			return execSync(["git", ...args].join(" "), {
+				cwd,
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
+			}).trim();
+		} catch (error) {
+			const e = error as { message?: string };
+			throw new Error(`Git command failed: ${e.message ?? error}`);
+		}
+	}
+
+	/**
+	 * Save worktree to metadata
+	 */
+	private saveWorktree(worktree: WorktreeInfo): void {
+		const current = this.listSync();
+		const idx = current.findIndex((w) => w.name === worktree.name);
+		if (idx >= 0) {
+			current[idx] = worktree;
+		} else {
+			current.push(worktree);
+		}
+		this.saveAllWorktrees(current);
+	}
+
+	/**
+	 * Save all worktrees
+	 */
+	private saveAllWorktrees(worktrees: WorktreeInfo[]): void {
+		mkdirSync(dirname(this.metaPath), { recursive: true });
+		writeFileSync(this.metaPath, JSON.stringify(worktrees, null, 2), "utf-8");
+	}
+
+	/**
+	 * List worktrees synchronously
+	 */
+	private listSync(): WorktreeInfo[] {
+		if (!existsSync(this.metaPath)) {
+			return [];
+		}
+		try {
+			return JSON.parse(readFileSync(this.metaPath, "utf-8")) as WorktreeInfo[];
+		} catch {
+			return [];
+		}
+	}
+}

package/packages/write-review/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@moocoding/write-review",
+  "version": "0.10.30",
+  "description": "Two-agent write-review loop with blackboard coordination",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "keywords": [
+    "pi-extension",
+    "write-review",
+    "blackboard",
+    "multi-agent"
+  ],
+  "author": "MooCoding",
+  "license": "MIT"
+}

package/packages/a2a-adapter/dist/discovery.d.ts

@@ -1,52 +0,0 @@
-/**
- * A2A Discovery Server (RFC-0104)
- *
- * Advertises agent capabilities and handles agent registry.
- */
-import type { AgentSearchCriteria } from "./client.js";
-import type { AgentCard, AgentCapabilities, Skill, Authentication } from "./types.js";
-/**
- * Discovery configuration
- */
-export interface A2ADiscoveryConfig {
-    /** Agent ID */
-    agentId: string;
-    /** Agent URL */
-    url: string;
-    /** Capabilities */
-    capabilities: AgentCapabilities;
-    /** Skills this agent provides */
-    skills: Skill[];
-    /** Authentication */
-    authentication?: Authentication;
-    /** Metadata */
-    metadata?: Record<string, string>;
-}
-/**
- * Start a local A2A discovery agent
- */
-export declare function startDiscoveryAgent(config: A2ADiscoveryConfig): DiscoveryAgent;
-export declare class DiscoveryAgent {
-    private card;
-    constructor(config: A2ADiscoveryConfig);
-    getAgentCard(): AgentCard;
-}
-/**
- * Registry of known agents
- */
-export declare class AgentRegistry {
-    private agents;
-    register(card: AgentCard): void;
-    unregister(name: string): void;
-    list(): AgentCard[];
-    find(criteria: AgentSearchCriteria): AgentCard[];
-}
-/**
- * Load agent card from URL
- */
-export declare function loadAgentCard(url: string): Promise<AgentCard | null>;
-/**
- * Discover agents via seed URLs
- */
-export declare function discoverAgents(seedUrls: string[]): Promise<AgentCard[]>;
-//# sourceMappingURL=discovery.d.ts.map

package/packages/a2a-adapter/dist/discovery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEtF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,eAAe;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,mBAAmB;IACnB,YAAY,EAAE,iBAAiB,CAAC;IAChC,iCAAiC;IACjC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,qBAAqB;IACrB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,eAAe;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,cAAc,CAE9E;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,IAAI,CAAY;IAExB,YAAY,MAAM,EAAE,kBAAkB,EASrC;IAED,YAAY,IAAI,SAAS,CAExB;CACF;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAgC;IAE9C,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAE9B;IAED,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED,IAAI,IAAI,SAAS,EAAE,CAElB;IAED,IAAI,CAAC,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EAAE,CAK/C;CACF;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAQ1E;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAQ7E"}

package/packages/a2a-adapter/dist/discovery.js

@@ -1,76 +0,0 @@
-/**
- * A2A Discovery Server (RFC-0104)
- *
- * Advertises agent capabilities and handles agent registry.
- */
-import { fetch } from "undici";
-import { createAgentCard } from "./agent.js";
-/**
- * Start a local A2A discovery agent
- */
-export function startDiscoveryAgent(config) {
-    return new DiscoveryAgent(config);
-}
-export class DiscoveryAgent {
-    card;
-    constructor(config) {
-        this.card = createAgentCard({
-            name: config.agentId,
-            description: config.skills[0]?.description ?? "Harness Agent",
-            url: config.url,
-            version: "1.0.0",
-            capabilities: config.capabilities,
-            skills: config.skills,
-        });
-    }
-    getAgentCard() {
-        return this.card;
-    }
-}
-/**
- * Registry of known agents
- */
-export class AgentRegistry {
-    agents = new Map();
-    register(card) {
-        this.agents.set(card.name, card);
-    }
-    unregister(name) {
-        this.agents.delete(name);
-    }
-    list() {
-        return Array.from(this.agents.values());
-    }
-    find(criteria) {
-        return this.list().filter((agent) => {
-            if (criteria.skill && !agent.skills.some((s) => s.id === criteria.skill))
-                return false;
-            return true;
-        });
-    }
-}
-/**
- * Load agent card from URL
- */
-export async function loadAgentCard(url) {
-    try {
-        const response = await fetch(`${url}/.well-known/agent.json`);
-        if (!response.ok)
-            return null;
-        return response.json();
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Discover agents via seed URLs
- */
-export async function discoverAgents(seedUrls) {
-    const results = await Promise.all(seedUrls.map(async (url) => {
-        const card = await loadAgentCard(url);
-        return card;
-    }));
-    return results.filter((c) => c !== null);
-}
-//# sourceMappingURL=discovery.js.map

package/packages/a2a-adapter/dist/discovery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"discovery.js","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAqB7C;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAA0B;IAC5D,OAAO,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,OAAO,cAAc;IACjB,IAAI,CAAY;IAExB,YAAY,MAA0B;QACpC,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;YAC1B,IAAI,EAAE,MAAM,CAAC,OAAO;YACpB,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,eAAe;YAC7D,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,OAAO,EAAE,OAAO;YAChB,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC,CAAC;IACL,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,aAAa;IAChB,MAAM,GAAG,IAAI,GAAG,EAAqB,CAAC;IAE9C,QAAQ,CAAC,IAAe;QACtB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,UAAU,CAAC,IAAY;QACrB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,IAAI;QACF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,IAAI,CAAC,QAA6B;QAChC,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;YAClC,IAAI,QAAQ,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAC,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAC;YACvF,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,GAAW;IAC7C,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,GAAG,yBAAyB,CAAC,CAAC;QAC9D,IAAI,CAAC,QAAQ,CAAC,EAAE;YAAE,OAAO,IAAI,CAAC;QAC9B,OAAO,QAAQ,CAAC,IAAI,EAAwB,CAAC;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,QAAkB;IACrD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAA6B,EAAE;QACpD,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CACH,CAAC;IACF,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAkB,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;AAC3D,CAAC"}