opencodekit 0.23.2 → 0.23.4

package/dist/template/.opencode/tool/grepsearch.ts

@@ -3,19 +3,19 @@ import { tool } from "@opencode-ai/plugin";
 const GREP_APP_API = "https://grep.app/api/search";
 
 interface SearchResult {
-	repo: string;
-	path: string;
-	content: { snippet: string };
-	total_matches: string;
+  repo: string;
+  path: string;
+  content: { snippet: string };
+  total_matches: string;
 }
 
 interface GrepResponse {
-	hits: { hits: SearchResult[] };
-	time: number;
+  hits: { hits: SearchResult[] };
+  time: number;
 }
 
 export default tool({
-	description: `Search real-world code examples from GitHub repositories via grep.app. Replaces asking "how do others use X?" — use this for finding production patterns and real-world API usage.
+  description: `Search real-world code examples from GitHub repositories via grep.app. Replaces asking "how do others use X?" — use this for finding production patterns and real-world API usage.
 
 WHEN: Implementing unfamiliar APIs, looking for production patterns, understanding library integrations.
 SKIP: Searching your own codebase (use grep/srcwalk), looking up docs (use context7), general research (use websearch).
@@ -31,113 +31,102 @@ Use when:
 - Understanding library integrations - see how things work together
 
 IMPORTANT: Search for **literal code patterns**, not keywords:
-✅ Good: "useState(", "import React from", "async function"
-❌ Bad: "react tutorial", "best practices", "how to use"
+Good: "useState(", "import React from", "async function"
 
+Bad: "react tutorial", "best practices", "how to use"
 Examples:
   grepsearch({ query: "getServerSession", language: "TypeScript" })
   grepsearch({ query: "CORS(", language: "Python", repo: "flask" })
   grepsearch({ query: "export async function POST", path: "route.ts" })
 `,
-	args: {
-		query: tool.schema
-			.string()
-			.describe("Code pattern to search for (literal text)"),
-		language: tool.schema
-			.string()
-			.optional()
-			.describe("Filter by language: TypeScript, TSX, Python, Go, Rust, etc."),
-		repo: tool.schema
-			.string()
-			.optional()
-			.describe("Filter by repo: 'owner/repo' or partial match"),
-		path: tool.schema
-			.string()
-			.optional()
-			.describe("Filter by file path: 'src/', '.test.ts', etc."),
-		limit: tool.schema
-			.number()
-			.optional()
-			.describe("Max results to return (default: 10, max: 20)"),
-	},
-	execute: async (args) => {
-		const { query, language, repo, path, limit = 10 } = args;
-
-		if (!query || query.trim() === "") {
-			return "Error: query is required";
-		}
-
-		// Build URL with proper filter parameters
-		// grep.app uses filter[lang][0]=TypeScript format, NOT inline lang:TypeScript
-		const url = new URL(GREP_APP_API);
-		url.searchParams.set("q", query);
-
-		// Add language filter (grep.app uses filter[lang][0] format)
-		if (language) {
-			url.searchParams.set("filter[lang][0]", language);
-		}
-
-		// Add repo filter
-		if (repo) {
-			url.searchParams.set("filter[repo][0]", repo);
-		}
-
-		// Add path filter
-		if (path) {
-			url.searchParams.set("filter[path][0]", path);
-		}
-
-		try {
-			const response = await fetch(url.toString(), {
-				headers: {
-					Accept: "application/json",
-					"User-Agent": "OpenCode/1.0",
-				},
-			});
-
-			if (!response.ok) {
-				return `Error: grep.app API returned ${response.status}`;
-			}
-
-			const data = (await response.json()) as GrepResponse;
-
-			if (!data.hits?.hits?.length) {
-				return `No results found for: ${query}${language ? ` (${language})` : ""}`;
-			}
-
-			const maxResults = Math.min(limit, 20);
-			const results = data.hits.hits.slice(0, maxResults);
-
-			const formatted = results.map((hit, i) => {
-				const repoName = hit.repo || "unknown";
-				const filePath = hit.path || "unknown";
-				const snippet = hit.content?.snippet || "";
-
-				// Clean up HTML from snippet and extract text
-				const cleanCode = snippet
-					.replace(/<[^>]*>/g, "") // Remove HTML tags
-					.replace(/&lt;/g, "<")
-					.replace(/&gt;/g, ">")
-					.replace(/&amp;/g, "&")
-					.replace(/&quot;/g, '"')
-					.split("\n")
-					.slice(0, 8)
-					.join("\n")
-					.trim();
-
-				return `## ${i + 1}. ${repoName}
+  args: {
+    query: tool.schema.string().describe("Code pattern to search for (literal text)"),
+    language: tool.schema
+      .string()
+      .optional()
+      .describe("Filter by language: TypeScript, TSX, Python, Go, Rust, etc."),
+    repo: tool.schema.string().optional().describe("Filter by repo: 'owner/repo' or partial match"),
+    path: tool.schema.string().optional().describe("Filter by file path: 'src/', '.test.ts', etc."),
+    limit: tool.schema.number().optional().describe("Max results to return (default: 10, max: 20)"),
+  },
+  execute: async (args) => {
+    const { query, language, repo, path, limit = 10 } = args;
+
+    if (!query || query.trim() === "") {
+      return "Error: query is required";
+    }
+
+    // Build URL with proper filter parameters
+    // grep.app uses filter[lang][0]=TypeScript format, NOT inline lang:TypeScript
+    const url = new URL(GREP_APP_API);
+    url.searchParams.set("q", query);
+
+    // Add language filter (grep.app uses filter[lang][0] format)
+    if (language) {
+      url.searchParams.set("filter[lang][0]", language);
+    }
+
+    // Add repo filter
+    if (repo) {
+      url.searchParams.set("filter[repo][0]", repo);
+    }
+
+    // Add path filter
+    if (path) {
+      url.searchParams.set("filter[path][0]", path);
+    }
+
+    try {
+      const response = await fetch(url.toString(), {
+        headers: {
+          Accept: "application/json",
+          "User-Agent": "OpenCode/1.0",
+        },
+      });
+
+      if (!response.ok) {
+        return `Error: grep.app API returned ${response.status}`;
+      }
+
+      const data = (await response.json()) as GrepResponse;
+
+      if (!data.hits?.hits?.length) {
+        return `No results found for: ${query}${language ? ` (${language})` : ""}`;
+      }
+
+      const maxResults = Math.min(limit, 20);
+      const results = data.hits.hits.slice(0, maxResults);
+
+      const formatted = results.map((hit, i) => {
+        const repoName = hit.repo || "unknown";
+        const filePath = hit.path || "unknown";
+        const snippet = hit.content?.snippet || "";
+
+        // Clean up HTML from snippet and extract text
+        const cleanCode = snippet
+          .replace(/<[^>]*>/g, "") // Remove HTML tags
+          .replace(/&lt;/g, "<")
+          .replace(/&gt;/g, ">")
+          .replace(/&amp;/g, "&")
+          .replace(/&quot;/g, '"')
+          .split("\n")
+          .slice(0, 8)
+          .join("\n")
+          .trim();
+
+        return `## ${i + 1}. ${repoName}
 **File**: ${filePath}
 \`\`\`
 ${cleanCode}
 \`\`\``;
-			});
+      });
 
-			return `Found ${data.hits.hits.length} results (showing ${results.length}) in ${data.time}ms:
+      return `Found ${data.hits.hits.length} results (showing ${results.length}) in ${data.time}ms:
 
 ${formatted.join("\n\n")}`;
-		} catch (error: unknown) {
-			const message = error instanceof Error ? error.message : String(error);
-			return `Error searching grep.app: ${message}`;
-		}
-	},
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `Error searching grep.app: ${message}`;
+    }
+  },
 });

package/dist/template/.opencode/workflows/audit-pattern.md

@@ -0,0 +1,51 @@
+# audit-pattern
+
+Find all occurrences of a code pattern in the codebase, review each match for correctness/security/edge-cases, and produce prioritized remediation recommendations. Use for cross-cutting concerns like auth checks, error handling, or API patterns.
+
+## Args
+
+- `pattern` (required) — The code pattern to search for
+
+## Phases
+
+### Phase 1: discover
+
+- **Agent:** @explore
+- **Concurrency:** 1
+- **Prompt:**
+
+Search the codebase for the pattern: {pattern}. Use grep or csearch to find every occurrence. List each file with line numbers, grouped by subdirectory. If the pattern has common variations, include those too. Return results in this format:
+
+## Directory: [path]
+- `file.ts:42` — [brief context]
+- `file.ts:87` — [brief context]
+
+Keep each entry under 50 words.
+
+### Phase 2: audit
+
+- **Depends on:** Phase 1
+- **Agent:** @review
+- **Concurrency:** Dynamic (estimate ~10 occurrences per agent, min 2, max 15)
+- **Prompt:**
+
+Review the following files for the pattern '{pattern}': {phase_1_output}. For each occurrence check: correctness, edge cases, security implications, error handling, and adherence to project conventions. Return findings in this format:
+
+## File: [path:line]
+- **Severity:** [critical/important/minor]
+- **Issue:** [description]
+- **Recommendation:** [fix suggestion]
+
+Keep each finding under 100 words.
+
+## Final Synthesis (Main Agent)
+
+After Phase 2 completes, synthesize the audit findings directly from {phase_2_output}.
+
+Produce:
+1. **Issues ranked by severity** — Critical, important, minor with file:line references
+2. **Affected scope** — Count of files and occurrences
+3. **Recommended fixes** — Specific fix suggestions per issue
+4. **Correct patterns** — Patterns that are already correct and should be preserved
+
+Group findings by subdirectory. Keep the report under 1500 words.

package/dist/template/.opencode/workflows/batch-implement.md

@@ -0,0 +1,82 @@
+# batch-implement
+
+Take a plan with independent tasks and dispatch one subagent per task in parallel. Each task result is reviewed, then merged. Use for multi-file feature implementation where tasks don't share file dependencies.
+
+## Args
+
+- `plan` (required) — The implementation plan or PRD
+
+## Phases
+
+### Phase 1: plan-review
+
+- **Agent:** @review
+- **Concurrency:** 1
+- **Prompt:**
+
+Review this implementation plan for task independence: {plan}. Verify that the tasks don't edit the same files. If any tasks have overlapping file dependencies, flag them as conflicts. Return the list of tasks grouped by dependency in this format:
+
+## Independent Tasks (can run in parallel)
+- **Task 1:** [description]
+  - Files: [list]
+- **Task 2:** [description]
+  - Files: [list]
+
+## Dependent Tasks (must run sequentially)
+- **Task 3:** [description]
+  - Depends on: [task names]
+  - Files: [list]
+
+Keep each task description under 100 words.
+
+### Phase 2: implement
+
+- **Depends on:** Phase 1
+- **Agent:** @general
+- **Concurrency:** Dynamic (1 agent per task, min 2, max 10)
+- **Prompt:**
+
+Implement the following task from the plan: {phase_1_output}. Write production-quality code following project conventions. Include type definitions, error handling, and unit tests. Keep changes scoped to the task — do not refactor unrelated code. Return a summary in this format:
+
+## Task: [name]
+- **Files modified:** [list]
+- **Tests added:** [list]
+- **Key changes:** [brief summary]
+
+Keep the summary under 200 words.
+
+### Phase 3: verify
+
+- **Depends on:** Phase 2
+- **Agent:** @review
+- **Concurrency:** Dynamic (~3 implementations per agent, min 2, max 8)
+- **Prompt:**
+
+Review this implementation: {phase_2_output}. Check: correctness against the task requirements, test coverage, edge case handling, type safety, and lint compliance. Return findings in this format:
+
+## Task: [name]
+- **Status:** [pass/fail]
+- **Issues:** [list with file:line refs]
+- **Recommendations:** [list]
+
+Keep each finding under 100 words.
+
+## Final Merge (Main Agent)
+
+After Phase 3 completes, merge the verified implementations directly from {phase_3_output}.
+
+Ensure:
+- No duplicate imports
+- Consistent naming conventions
+- Proper module boundaries
+- No broken imports between modules
+
+Report any merge conflicts or integration issues. Return a summary:
+
+## Merge Summary
+- **Tasks merged:** [count]
+- **Files modified:** [list]
+- **Integration issues:** [list or 'none']
+- **Next steps:** [list]
+
+Keep the summary under 500 words.

package/dist/template/.opencode/workflows/deep-research.md

@@ -0,0 +1,58 @@
+# deep-research
+
+Fan out web searches across multiple angles on a question, cross-check sources for contradictions, and produce a cited report with confidence levels. Use when you need multi-source verification or current-events coverage.
+
+## Args
+
+- `question` (required) — The research question or topic
+
+## Phases
+
+### Phase 1: research
+
+- **Agent:** @scout
+- **Concurrency:** Dynamic (1 agent per distinct angle, min 3, max 10)
+- **Prompt:**
+
+Search for different perspectives on the question: {question}. Cover opposing viewpoints, authoritative sources, and recent developments. For each finding, include the URL and publication date. Return findings grouped by angle in this format:
+
+## Angle: [angle name]
+- **Finding:** [summary]
+- **Source:** [URL]
+- **Date:** [publication date]
+- **Confidence:** [high/medium/low]
+
+Keep each finding under 200 words.
+
+### Phase 2: cross-check
+
+- **Depends on:** Phase 1
+- **Agent:** @review
+- **Concurrency:** Dynamic (estimate ~5 findings per agent, min 2, max 10)
+- **Prompt:**
+
+Cross-check these findings: {phase_1_output}. Flag contradictions between sources, identify confirmable facts with supporting citations, and note where sources disagree or lack evidence. Return a verified fact set in this format:
+
+## Verified Facts
+- **Fact:** [statement]
+- **Confidence:** [high/medium/low]
+- **Supporting sources:** [list of URLs]
+
+## Contradictions
+- **Claim A:** [statement]
+- **Claim B:** [contradicting statement]
+- **Resolution:** [which is more credible and why]
+
+Keep each item under 150 words.
+
+## Final Synthesis (Main Agent)
+
+After Phase 2 completes, synthesize the final report directly from {phase_2_output}.
+
+Write a final cited report using markdown with sections:
+1. **Executive Summary** — Brief overview of key findings
+2. **Key Findings** — Detailed findings with inline citations
+3. **Contradictions & Uncertainties** — Areas of disagreement or low confidence
+4. **Sources** — Complete list of all sources consulted
+
+Annotate each claim with confidence level (high/medium/low). Keep the report under 2000 words.

package/dist/template/.opencode/workflows/development-lifecycle-workflow.md

@@ -0,0 +1,129 @@
+# development-lifecycle-workflow
+
+Multi-agent workflow that chains the development lifecycle phases with parallelism. Uses specialized agents (scouts, reviewers, planners) and composes with the batch-implement workflow for parallel implementation.
+
+## Args
+
+- `feature` (required) — The feature or change to implement
+
+## Phases
+
+### Phase 1: Research Approaches
+
+- **Agent:** @scout
+- **Concurrency:** Dynamic (1 agent per approach, min 2, max 5)
+- **Prompt:**
+
+Research different approaches to implementing: {feature}. For each approach, analyze:
+1. Technical feasibility
+2. Trade-offs and risks
+3. Implementation complexity
+4. Dependencies and constraints
+
+Return findings in this format:
+
+## Approach 1: [name]
+- **Description:** [summary]
+- **Pros:** [list]
+- **Cons:** [list]
+- **Complexity:** [low/medium/high]
+- **Risks:** [list]
+
+Keep each approach under 300 words.
+
+### Phase 2: Validate Requirements
+
+- **Depends on:** Phase 1
+- **Agent:** @review
+- **Concurrency:** Dynamic (1 agent per approach, min 1, max 5)
+- **Prompt:**
+
+Review these approaches: {phase_1_output}. Validate the requirements and constraints for each approach. Check for:
+1. Technical accuracy
+2. Feasibility given project constraints
+3. Alignment with existing patterns
+4. Missing considerations
+
+Return validated requirements in this format:
+
+## Validated Requirements
+- **Approach 1:** [validated requirements]
+- **Approach 2:** [validated requirements]
+- **Approach 3:** [validated requirements]
+
+## Recommendations
+- **Recommended approach:** [which approach and why]
+- **Critical constraints:** [list]
+
+Keep each section under 200 words.
+
+### Phase 3: Create Implementation Plan
+
+- **Depends on:** Phase 2
+- **Agent:** @plan
+- **Concurrency:** 1
+- **Prompt:**
+
+Based on the validated requirements: {phase_2_output}, create a detailed implementation plan for the recommended approach. Break down into independent tasks that can be implemented in parallel.
+
+Return the plan in this format:
+
+## Implementation Plan
+
+### Overview
+[Brief description of the approach]
+
+### Tasks
+- **Task 1:** [description]
+  - Files: [list]
+  - Dependencies: [none or task names]
+- **Task 2:** [description]
+  - Files: [list]
+  - Dependencies: [none or task names]
+
+Keep each task description under 100 words.
+
+### Phase 4: Parallel Implementation
+
+- **Depends on:** Phase 3
+- **Workflow:** batch-implement
+- **Args:** plan from Phase 3
+
+Execute the batch-implement workflow with the implementation plan from Phase 3. This will:
+1. Review the plan for task independence
+2. Implement tasks in parallel
+3. Verify each implementation
+4. Merge the results
+
+### Phase 5: Verify Different Aspects
+
+- **Depends on:** Phase 4
+- **Agent:** @review
+- **Concurrency:** 3 (one per aspect: correctness, code-quality, performance-security)
+- **Prompt:**
+
+Verify the implementation from different aspects: {phase_4_output}. Each reviewer should focus on a different aspect:
+
+**Reviewer 1: Correctness**
+- Verify all requirements are met
+- Check for logic errors
+- Validate edge cases
+
+**Reviewer 2: Code Quality**
+- Check for code style and patterns
+- Identify code smells
+- Verify test coverage
+
+**Reviewer 3: Performance & Security**
+- Check for performance bottlenecks
+- Identify security vulnerabilities
+- Validate error handling
+
+Return findings in this format:
+
+## Aspect: [correctness/code-quality/performance-security]
+- **Status:** [pass/fail]
+- **Issues:** [list with file:line refs]
+- **Recommendations:** [list]
+
+Keep each finding under 150 words.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencodekit",
-  "version": "0.23.2",
+  "version": "0.23.4",
   "description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
   "keywords": [
     "agents",

package/dist/template/.opencode/command/clarify.md

@@ -1,46 +0,0 @@
----
-description: Reduce ambiguity before planning or implementation
-argument-hint: "<request> [--quick|--deep]"
-agent: build
----
-
-# Clarify: $ARGUMENTS
-
-Reduce ambiguity before planning or implementation. Use when the request is real but still fuzzy.
-
-## Load Skills
-
-```typescript
-skill({ name: "brainstorming" });
-```
-
-## Parse Arguments
-
-| Argument | Default | Description |
-|---|---|---|
-| `<request>`            | required | Freeform request text                     |
-| `--quick` | false | Minimize to 1-3 high-leverage questions |
-| `--deep` | false | Cover non-goals, risks, interfaces, success criteria |
-
-**Mode rules:** Default → make next command obvious. `--quick` → 1-3 questions. `--deep` → exhaustive. `--deep` wins if both appear.
-
-## When to Use / Not Use
-
-**Use:** Request is fuzzy, scope unclear, multiple interpretations of "done," `/plan` would be premature because main decision is unresolved.  
-**Skip:** Request is specific enough to plan directly, task is mechanical, ambiguity is only about codebase facts you can inspect.
-
-## Core Rules
-
-- **Inspect first, ask second** — never ask for codebase facts you can discover directly
-- **One question at a time** — each must reduce a real ambiguity
-- **Prefer structured choices** (multiple choice, yes/no)
-- **Surface non-goals explicitly** — what should *not* change is as important as what should
-- **Stop once the next command is obvious**
-
-## Process
-
-1. Read request, identify unknowns blocking execution
-2. Search memory, check existing patterns
-3. Ask questions one at a time, resolve before next
-4. Surface non-goals and constraints
-5. Recommend next command: `/plan`, `/create`, `/ship`, or `/design`

package/dist/template/.opencode/command/commit.md

@@ -1,53 +0,0 @@
----
-description: Create a well-structured conventional commit from staged or unstaged changes
-argument-hint: "[--all] [--amend] [message override]"
-agent: build
----
-
-# Commit: $ARGUMENTS
-
-Create a well-structured conventional commit from current changes.
-
-## Load Skills
-
-```typescript
-skill({ name: "verification-before-completion" });
-```
-
-## Process
-
-### Phase 1: Inspect Changes
-
-```bash
-git status --short
-git diff --cached --stat   # if staged
-git diff --stat            # if unstaged
-```
-
-### Phase 2: Review Diffs
-
-Read each changed file. Look for:
-- Debug code, console.log, TODOs that should be resolved
-- Accidental changes outside scope
-- Missing error handling or edge cases
-
-### Phase 3: Construct Commit
-
-Format: `type(scope): description`
-
-Types: `feat` (feature), `fix` (bug), `test` (test-only), `refactor` (no behavior change), `chore` (config/tooling), `docs`, `style`, `perf`.
-
-### Phase 4: Commit
-
-```bash
-git add <files>    # stage specific files — never git add .
-git commit -m "type(scope): description
-
-- bullet points of key changes"
-```
-
-### Phase 5: Verify
-
-```bash
-git log --oneline -3
-```