opencodekit 0.14.5 → 0.15.0

package/dist/template/.opencode/plugin/truncator.ts

@@ -9,54 +9,51 @@
 import type { Plugin } from "@opencode-ai/plugin";
 
 export const TruncatorPlugin: Plugin = async ({ client }) => {
-	const sessionContext = new Map<string, number>();
-
-	return {
-		event: async ({ event }) => {
-			const props = event.properties as Record<string, unknown>;
-
-			if (event.type === "session.updated") {
-				const info = props?.info as Record<string, unknown> | undefined;
-				const tokenStats = (info?.tokens || props?.tokens) as
-					| { used: number; limit: number }
-					| undefined;
-				const sessionId = (info?.id || props?.sessionID) as string | undefined;
-
-				if (sessionId && tokenStats?.used && tokenStats?.limit) {
-					sessionContext.set(
-						sessionId,
-						Math.round((tokenStats.used / tokenStats.limit) * 100),
-					);
-				}
-			}
-
-			if (event.type === "session.deleted") {
-				const sessionId = props?.sessionID as string | undefined;
-				if (sessionId) {
-					sessionContext.delete(sessionId);
-				}
-			}
-		},
-
-		"tool.execute.after": async (input, output) => {
-			const pct = sessionContext.get(input.sessionID) || 0;
-			if (pct < 70) return; // Only warn under pressure
-
-			// Thresholds get tighter as context fills up
-			const threshold = pct >= 95 ? 5000 : pct >= 85 ? 10000 : 20000;
-			const outputStr = output.output || "";
-
-			if (outputStr.length > threshold) {
-				await client.app
-					.log({
-						body: {
-							service: "truncator",
-							level: pct >= 95 ? "warn" : "info",
-							message: `Large output from ${input.tool}: ${outputStr.length} chars (threshold: ${threshold}, context: ${pct}%)`,
-						},
-					})
-					.catch(() => {});
-			}
-		},
-	};
+  const sessionContext = new Map<string, number>();
+
+  return {
+    event: async ({ event }) => {
+      const props = event.properties as Record<string, unknown>;
+
+      if (event.type === "session.updated") {
+        const info = props?.info as Record<string, unknown> | undefined;
+        const tokenStats = (info?.tokens || props?.tokens) as
+          | { used: number; limit: number }
+          | undefined;
+        const sessionId = (info?.id || props?.sessionID) as string | undefined;
+
+        if (sessionId && tokenStats?.used && tokenStats?.limit) {
+          sessionContext.set(sessionId, Math.round((tokenStats.used / tokenStats.limit) * 100));
+        }
+      }
+
+      if (event.type === "session.deleted") {
+        const sessionId = props?.sessionID as string | undefined;
+        if (sessionId) {
+          sessionContext.delete(sessionId);
+        }
+      }
+    },
+
+    "tool.execute.after": async (input, output) => {
+      const pct = sessionContext.get(input.sessionID) || 0;
+      if (pct < 70) return; // Only warn under pressure
+
+      // Thresholds get tighter as context fills up
+      const threshold = pct >= 95 ? 5000 : pct >= 85 ? 10000 : 20000;
+      const outputStr = output.output || "";
+
+      if (outputStr.length > threshold) {
+        await client.app
+          .log({
+            body: {
+              service: "truncator",
+              level: pct >= 95 ? "warn" : "info",
+              message: `Large output from ${input.tool}: ${outputStr.length} chars (threshold: ${threshold}, context: ${pct}%)`,
+            },
+          })
+          .catch(() => {});
+      }
+    },
+  };
 };

package/dist/template/.opencode/plugin/tsconfig.json

@@ -1,16 +1,16 @@
 {
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "NodeNext",
-		"moduleResolution": "nodenext",
-		"allowSyntheticDefaultImports": true,
-		"esModuleInterop": true,
-		"strict": true,
-		"noImplicitAny": false,
-		"skipLibCheck": true,
-		"forceConsistentCasingInFileNames": true,
-		"types": ["node"]
-	},
-	"include": ["**/*.ts"],
-	"exclude": ["node_modules"]
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules"]
 }

package/dist/template/.opencode/skill/chrome-devtools/mcp.json

@@ -1,19 +1,19 @@
 {
-	"chrome-devtools": {
-		"command": "npx",
-		"args": ["-y", "chrome-devtools-mcp@latest", "--stdio"],
-		"includeTools": [
-			"take_snapshot",
-			"take_screenshot",
-			"navigate_page",
-			"new_page",
-			"list_pages",
-			"click",
-			"fill",
-			"hover",
-			"press_key",
-			"evaluate_script",
-			"wait_for"
-		]
-	}
+  "chrome-devtools": {
+    "command": "npx",
+    "args": ["-y", "chrome-devtools-mcp@latest", "--stdio"],
+    "includeTools": [
+      "take_snapshot",
+      "take_screenshot",
+      "navigate_page",
+      "new_page",
+      "list_pages",
+      "click",
+      "fill",
+      "hover",
+      "press_key",
+      "evaluate_script",
+      "wait_for"
+    ]
+  }
 }

package/dist/template/.opencode/skill/condition-based-waiting/SKILL.md

@@ -27,12 +27,14 @@ digraph when_to_use {
 ```
 
 **Use when:**
+
 - Tests have arbitrary delays (`setTimeout`, `sleep`, `time.sleep()`)
 - Tests are flaky (pass sometimes, fail under load)
 - Tests timeout when run in parallel
 - Waiting for async operations to complete
 
 **Don't use when:**
+
 - Testing actual timing behavior (debounce, throttle intervals)
 - Always document WHY if using arbitrary timeout
 
@@ -40,7 +42,7 @@ digraph when_to_use {
 
 ```typescript
 // ❌ BEFORE: Guessing at timing
-await new Promise(r => setTimeout(r, 50));
+await new Promise((r) => setTimeout(r, 50));
 const result = getResult();
 expect(result).toBeDefined();
 
@@ -52,22 +54,23 @@ expect(result).toBeDefined();
 
 ## Quick Patterns
 
-| Scenario | Pattern |
-|----------|---------|
-| Wait for event | `waitFor(() => events.find(e => e.type === 'DONE'))` |
-| Wait for state | `waitFor(() => machine.state === 'ready')` |
-| Wait for count | `waitFor(() => items.length >= 5)` |
-| Wait for file | `waitFor(() => fs.existsSync(path))` |
-| Complex condition | `waitFor(() => obj.ready && obj.value > 10)` |
+| Scenario          | Pattern                                              |
+| ----------------- | ---------------------------------------------------- |
+| Wait for event    | `waitFor(() => events.find(e => e.type === 'DONE'))` |
+| Wait for state    | `waitFor(() => machine.state === 'ready')`           |
+| Wait for count    | `waitFor(() => items.length >= 5)`                   |
+| Wait for file     | `waitFor(() => fs.existsSync(path))`                 |
+| Complex condition | `waitFor(() => obj.ready && obj.value > 10)`         |
 
 ## Implementation
 
 Generic polling function:
+
 ```typescript
 async function waitFor<T>(
   condition: () => T | undefined | null | false,
   description: string,
-  timeoutMs = 5000
+  timeoutMs = 5000,
 ): Promise<T> {
   const startTime = Date.now();
 
@@ -79,7 +82,7 @@ async function waitFor<T>(
       throw new Error(`Timeout waiting for ${description} after ${timeoutMs}ms`);
     }
 
-    await new Promise(r => setTimeout(r, 10)); // Poll every 10ms
+    await new Promise((r) => setTimeout(r, 10)); // Poll every 10ms
   }
 }
 ```
@@ -101,12 +104,13 @@ See @example.ts for complete implementation with domain-specific helpers (`waitF
 
 ```typescript
 // Tool ticks every 100ms - need 2 ticks to verify partial output
-await waitForEvent(manager, 'TOOL_STARTED'); // First: wait for condition
-await new Promise(r => setTimeout(r, 200));   // Then: wait for timed behavior
+await waitForEvent(manager, "TOOL_STARTED"); // First: wait for condition
+await new Promise((r) => setTimeout(r, 200)); // Then: wait for timed behavior
 // 200ms = 2 ticks at 100ms intervals - documented and justified
 ```
 
 **Requirements:**
+
 1. First wait for triggering condition
 2. Based on known timing (not guessing)
 3. Comment explaining WHY
@@ -114,6 +118,7 @@ await new Promise(r => setTimeout(r, 200));   // Then: wait for timed behavior
 ## Real-World Impact
 
 From debugging session (2025-10-03):
+
 - Fixed 15 flaky tests across 3 files
 - Pass rate: 60% → 100%
 - Execution time: 40% faster

package/dist/template/.opencode/skill/condition-based-waiting/example.ts

@@ -18,33 +18,29 @@ import type { LaceEvent, LaceEventType } from "~/threads/types";
  *   await waitForEvent(threadManager, agentThreadId, 'TOOL_RESULT');
  */
 export function waitForEvent(
-	threadManager: ThreadManager,
-	threadId: string,
-	eventType: LaceEventType,
-	timeoutMs = 5000,
+  threadManager: ThreadManager,
+  threadId: string,
+  eventType: LaceEventType,
+  timeoutMs = 5000,
 ): Promise<LaceEvent> {
-	return new Promise((resolve, reject) => {
-		const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
 
-		const check = () => {
-			const events = threadManager.getEvents(threadId);
-			const event = events.find((e) => e.type === eventType);
+    const check = () => {
+      const events = threadManager.getEvents(threadId);
+      const event = events.find((e) => e.type === eventType);
 
-			if (event) {
-				resolve(event);
-			} else if (Date.now() - startTime > timeoutMs) {
-				reject(
-					new Error(
-						`Timeout waiting for ${eventType} event after ${timeoutMs}ms`,
-					),
-				);
-			} else {
-				setTimeout(check, 10); // Poll every 10ms for efficiency
-			}
-		};
+      if (event) {
+        resolve(event);
+      } else if (Date.now() - startTime > timeoutMs) {
+        reject(new Error(`Timeout waiting for ${eventType} event after ${timeoutMs}ms`));
+      } else {
+        setTimeout(check, 10); // Poll every 10ms for efficiency
+      }
+    };
 
-		check();
-	});
+    check();
+  });
 }
 
 /**
@@ -62,34 +58,34 @@ export function waitForEvent(
  *   await waitForEventCount(threadManager, agentThreadId, 'AGENT_MESSAGE', 2);
  */
 export function waitForEventCount(
-	threadManager: ThreadManager,
-	threadId: string,
-	eventType: LaceEventType,
-	count: number,
-	timeoutMs = 5000,
+  threadManager: ThreadManager,
+  threadId: string,
+  eventType: LaceEventType,
+  count: number,
+  timeoutMs = 5000,
 ): Promise<LaceEvent[]> {
-	return new Promise((resolve, reject) => {
-		const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
 
-		const check = () => {
-			const events = threadManager.getEvents(threadId);
-			const matchingEvents = events.filter((e) => e.type === eventType);
+    const check = () => {
+      const events = threadManager.getEvents(threadId);
+      const matchingEvents = events.filter((e) => e.type === eventType);
 
-			if (matchingEvents.length >= count) {
-				resolve(matchingEvents);
-			} else if (Date.now() - startTime > timeoutMs) {
-				reject(
-					new Error(
-						`Timeout waiting for ${count} ${eventType} events after ${timeoutMs}ms (got ${matchingEvents.length})`,
-					),
-				);
-			} else {
-				setTimeout(check, 10);
-			}
-		};
+      if (matchingEvents.length >= count) {
+        resolve(matchingEvents);
+      } else if (Date.now() - startTime > timeoutMs) {
+        reject(
+          new Error(
+            `Timeout waiting for ${count} ${eventType} events after ${timeoutMs}ms (got ${matchingEvents.length})`,
+          ),
+        );
+      } else {
+        setTimeout(check, 10);
+      }
+    };
 
-		check();
-	});
+    check();
+  });
 }
 
 /**
@@ -113,32 +109,30 @@ export function waitForEventCount(
  *   );
  */
 export function waitForEventMatch(
-	threadManager: ThreadManager,
-	threadId: string,
-	predicate: (event: LaceEvent) => boolean,
-	description: string,
-	timeoutMs = 5000,
+  threadManager: ThreadManager,
+  threadId: string,
+  predicate: (event: LaceEvent) => boolean,
+  description: string,
+  timeoutMs = 5000,
 ): Promise<LaceEvent> {
-	return new Promise((resolve, reject) => {
-		const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
 
-		const check = () => {
-			const events = threadManager.getEvents(threadId);
-			const event = events.find(predicate);
+    const check = () => {
+      const events = threadManager.getEvents(threadId);
+      const event = events.find(predicate);
 
-			if (event) {
-				resolve(event);
-			} else if (Date.now() - startTime > timeoutMs) {
-				reject(
-					new Error(`Timeout waiting for ${description} after ${timeoutMs}ms`),
-				);
-			} else {
-				setTimeout(check, 10);
-			}
-		};
+      if (event) {
+        resolve(event);
+      } else if (Date.now() - startTime > timeoutMs) {
+        reject(new Error(`Timeout waiting for ${description} after ${timeoutMs}ms`));
+      } else {
+        setTimeout(check, 10);
+      }
+    };
 
-		check();
-	});
+    check();
+  });
 }
 
 // Usage example from actual debugging session:

package/dist/template/.opencode/skill/defense-in-depth/SKILL.md

@@ -17,6 +17,7 @@ Single validation: "We fixed the bug"
 Multiple layers: "We made the bug impossible"
 
 Different layers catch different cases:
+
 - Entry validation catches most bugs
 - Business logic catches edge cases
 - Environment guards prevent context-specific dangers
@@ -25,12 +26,13 @@ Different layers catch different cases:
 ## The Four Layers
 
 ### Layer 1: Entry Point Validation
+
 **Purpose:** Reject obviously invalid input at API boundary
 
 ```typescript
 function createProject(name: string, workingDirectory: string) {
-  if (!workingDirectory || workingDirectory.trim() === '') {
-    throw new Error('workingDirectory cannot be empty');
+  if (!workingDirectory || workingDirectory.trim() === "") {
+    throw new Error("workingDirectory cannot be empty");
   }
   if (!existsSync(workingDirectory)) {
     throw new Error(`workingDirectory does not exist: ${workingDirectory}`);
@@ -43,31 +45,31 @@ function createProject(name: string, workingDirectory: string) {
 ```
 
 ### Layer 2: Business Logic Validation
+
 **Purpose:** Ensure data makes sense for this operation
 
 ```typescript
 function initializeWorkspace(projectDir: string, sessionId: string) {
   if (!projectDir) {
-    throw new Error('projectDir required for workspace initialization');
+    throw new Error("projectDir required for workspace initialization");
   }
   // ... proceed
 }
 ```
 
 ### Layer 3: Environment Guards
+
 **Purpose:** Prevent dangerous operations in specific contexts
 
 ```typescript
 async function gitInit(directory: string) {
   // In tests, refuse git init outside temp directories
-  if (process.env.NODE_ENV === 'test') {
+  if (process.env.NODE_ENV === "test") {
     const normalized = normalize(resolve(directory));
     const tmpDir = normalize(resolve(tmpdir()));
 
     if (!normalized.startsWith(tmpDir)) {
-      throw new Error(
-        `Refusing git init outside temp dir during tests: ${directory}`
-      );
+      throw new Error(`Refusing git init outside temp dir during tests: ${directory}`);
     }
   }
   // ... proceed
@@ -75,12 +77,13 @@ async function gitInit(directory: string) {
 ```
 
 ### Layer 4: Debug Instrumentation
+
 **Purpose:** Capture context for forensics
 
 ```typescript
 async function gitInit(directory: string) {
   const stack = new Error().stack;
-  logger.debug('About to git init', {
+  logger.debug("About to git init", {
     directory,
     cwd: process.cwd(),
     stack,
@@ -103,12 +106,14 @@ When you find a bug:
 Bug: Empty `projectDir` caused `git init` in source code
 
 **Data flow:**
+
 1. Test setup → empty string
 2. `Project.create(name, '')`
 3. `WorkspaceManager.createWorkspace('')`
 4. `git init` runs in `process.cwd()`
 
 **Four layers added:**
+
 - Layer 1: `Project.create()` validates not empty/exists/writable
 - Layer 2: `WorkspaceManager` validates projectDir not empty
 - Layer 3: `WorktreeManager` refuses git init outside tmpdir in tests
@@ -119,6 +124,7 @@ Bug: Empty `projectDir` caused `git init` in source code
 ## Key Insight
 
 All four layers were necessary. During testing, each layer caught bugs the others missed:
+
 - Different code paths bypassed entry validation
 - Mocks bypassed business logic checks
 - Edge cases on different platforms needed environment guards

package/dist/template/.opencode/skill/dispatching-parallel-agents/SKILL.md

@@ -32,12 +32,14 @@ digraph when_to_use {
 ```
 
 **Use when:**
+
 - 3+ test files failing with different root causes
 - Multiple subsystems broken independently
 - Each problem can be understood without context from others
 - No shared state between investigations
 
 **Don't use when:**
+
 - Failures are related (fix one might fix others)
 - Need to understand full system state
 - Agents would interfere with each other
@@ -47,6 +49,7 @@ digraph when_to_use {
 ### 1. Identify Independent Domains
 
 Group failures by what's broken:
+
 - File A tests: Tool approval flow
 - File B tests: Batch completion behavior
 - File C tests: Abort functionality
@@ -56,6 +59,7 @@ Each domain is independent - fixing tool approval doesn't affect abort tests.
 ### 2. Create Focused Agent Tasks
 
 Each agent gets:
+
 - **Specific scope:** One test file or subsystem
 - **Clear goal:** Make these tests pass
 - **Constraints:** Don't change other code
@@ -65,15 +69,16 @@ Each agent gets:
 
 ```typescript
 // In Claude Code / AI environment
-Task("Fix agent-tool-abort.test.ts failures")
-Task("Fix batch-completion-behavior.test.ts failures")
-Task("Fix tool-approval-race-conditions.test.ts failures")
+Task("Fix agent-tool-abort.test.ts failures");
+Task("Fix batch-completion-behavior.test.ts failures");
+Task("Fix tool-approval-race-conditions.test.ts failures");
 // All three run concurrently
 ```
 
 ### 4. Review and Integrate
 
 When agents return:
+
 - Read each summary
 - Verify fixes don't conflict
 - Run full test suite
@@ -82,6 +87,7 @@ When agents return:
 ## Agent Prompt Structure
 
 Good agent prompts are:
+
 1. **Focused** - One clear problem domain
 2. **Self-contained** - All context needed to understand the problem
 3. **Specific about output** - What should the agent return?
@@ -133,6 +139,7 @@ Return: Summary of what you found and what you fixed.
 **Scenario:** 6 test failures across 3 files after major refactoring
 
 **Failures:**
+
 - agent-tool-abort.test.ts: 3 failures (timing issues)
 - batch-completion-behavior.test.ts: 2 failures (tools not executing)
 - tool-approval-race-conditions.test.ts: 1 failure (execution count = 0)
@@ -140,6 +147,7 @@ Return: Summary of what you found and what you fixed.
 **Decision:** Independent domains - abort logic separate from batch completion separate from race conditions
 
 **Dispatch:**
+
 ```
 Agent 1 → Fix agent-tool-abort.test.ts
 Agent 2 → Fix batch-completion-behavior.test.ts
@@ -147,6 +155,7 @@ Agent 3 → Fix tool-approval-race-conditions.test.ts
 ```
 
 **Results:**
+
 - Agent 1: Replaced timeouts with event-based waiting
 - Agent 2: Fixed event structure bug (threadId in wrong place)
 - Agent 3: Added wait for async tool execution to complete
@@ -165,6 +174,7 @@ Agent 3 → Fix tool-approval-race-conditions.test.ts
 ## Verification
 
 After agents return:
+
 1. **Review each summary** - Understand what changed
 2. **Check for conflicts** - Did agents edit same code?
 3. **Run full suite** - Verify all fixes work together
@@ -173,6 +183,7 @@ After agents return:
 ## Real-World Impact
 
 From debugging session (2025-10-03):
+
 - 6 failures across 3 files
 - 3 agents dispatched in parallel
 - All investigations completed concurrently

package/dist/template/.opencode/skill/playwright/mcp.json

@@ -1,16 +1,16 @@
 {
-	"playwright": {
-		"command": "npx",
-		"args": ["@playwright/mcp@latest"],
-		"includeTools": [
-			"browser_navigate",
-			"browser_snapshot",
-			"browser_take_screenshot",
-			"browser_click",
-			"browser_type",
-			"browser_fill",
-			"browser_wait_for",
-			"browser_resize"
-		]
-	}
+  "playwright": {
+    "command": "npx",
+    "args": ["@playwright/mcp@latest"],
+    "includeTools": [
+      "browser_navigate",
+      "browser_snapshot",
+      "browser_take_screenshot",
+      "browser_click",
+      "browser_type",
+      "browser_fill",
+      "browser_wait_for",
+      "browser_resize"
+    ]
+  }
 }