opencodekit 0.15.12 → 0.15.14

package/dist/template/.opencode/tool/grep-search.ts

@@ -0,0 +1,135 @@
+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;
+}
+
+interface GrepResponse {
+	hits: { hits: SearchResult[] };
+	time: number;
+}
+
+export default tool({
+	description: `Search real-world code examples from GitHub repositories via grep.app.
+
+Use when:
+- Implementing unfamiliar APIs - see how others use a library
+- Looking for production patterns - find real-world examples
+- 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"
+
+Examples:
+  grep_search({ query: "getServerSession", language: "TypeScript" })
+  grep_search({ query: "CORS(", language: "Python", repo: "flask" })
+  grep_search({ 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}
+**File**: ${filePath}
+\`\`\`
+${cleanCode}
+\`\`\``;
+			});
+
+			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}`;
+		}
+	},
+});

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

@@ -0,0 +1,240 @@
+import { tool } from "@opencode-ai/plugin";
+
+/**
+ * Oracle Tool - Get second opinions from alternative AI models
+ *
+ * Uses ProxyPal to access various models for:
+ * - Validating complex architectural decisions
+ * - Cross-checking debugging hypotheses
+ * - Getting alternative perspectives on tricky problems
+ * - Breaking out of reasoning ruts
+ */
+
+// Default to Gemini 3 Pro for deep reasoning (has thinking capability)
+const DEFAULT_MODEL = "gpt-5.2-codex";
+
+// Available oracle models with their strengths
+const ORACLE_MODELS: Record<string, { name: string; strength: string }> = {
+  "gpt-5.2-codex": {
+    name: "GPT-5.2 Codex",
+    strength: "Strong code understanding and generation",
+  },
+  "gemini-3-pro-preview": {
+    name: "Gemini 3 Pro",
+    strength: "Deep reasoning with thinking capability",
+  },
+};
+
+interface OracleRequest {
+  question: string;
+  context?: string;
+  model?: string;
+  mode?: "validate" | "alternative" | "critique" | "brainstorm";
+}
+
+interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+interface ChatResponse {
+  choices?: Array<{
+    message?: {
+      content?: string;
+    };
+  }>;
+  error?: {
+    message?: string;
+  };
+}
+
+const SYSTEM_PROMPTS: Record<string, string> = {
+  validate: `You are a validation oracle. Your job is to critically examine the reasoning, approach, or solution presented to you. 
+
+Look for:
+- Logical flaws or gaps in reasoning
+- Edge cases that weren't considered
+- Assumptions that may not hold
+- Better alternatives if they exist
+
+Be direct and specific. If the approach is sound, say so briefly. If there are issues, explain them clearly.`,
+
+  alternative: `You are an alternative perspective oracle. Your job is to suggest completely different approaches to the problem.
+
+Focus on:
+- Different architectural patterns
+- Alternative technologies or libraries
+- Unconventional but valid solutions
+- Trade-offs the user may not have considered
+
+Don't just validate - actively look for different ways to solve the problem.`,
+
+  critique: `You are a critical review oracle. Your job is to stress-test ideas and find weaknesses.
+
+Examine:
+- Security implications
+- Performance concerns
+- Maintainability issues
+- Scalability problems
+- Edge cases and failure modes
+
+Be constructively critical. Point out problems but suggest how to address them.`,
+
+  brainstorm: `You are a brainstorming oracle. Your job is to expand on ideas and generate new possibilities.
+
+Generate:
+- Extensions to the proposed approach
+- Creative variations
+- Combinations with other techniques
+- Future-proofing considerations
+
+Be generative and expansive. Build on the ideas presented.`,
+};
+
+export default tool({
+  description: `Get a second opinion from a different AI model for complex reasoning tasks.
+
+Use when:
+- Validating architectural decisions before implementing
+- Cross-checking debugging hypotheses
+- Getting alternative perspectives on tricky problems
+- Breaking out of reasoning ruts or confirmation bias
+
+Modes:
+- validate: Check if reasoning is sound (default)
+- alternative: Get completely different approaches
+- critique: Stress-test ideas for weaknesses
+- brainstorm: Expand and generate new possibilities
+
+Models available:
+${Object.entries(ORACLE_MODELS)
+  .map(([id, info]) => `- ${id}: ${info.strength}`)
+  .join("\n")}
+
+Examples:
+  oracle({ question: "Is JWT the right choice for this API?", context: "Building a microservices auth system" })
+  oracle({ question: "Review this debugging approach", mode: "critique" })
+  oracle({ question: "What other ways could we implement caching?", mode: "alternative", model: "gpt-5.2-codex" })
+`,
+  args: {
+    question: tool.schema
+      .string()
+      .describe("The question or problem to get a second opinion on"),
+    context: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Additional context about the problem, constraints, or current approach",
+      ),
+    model: tool.schema
+      .string()
+      .optional()
+      .describe(
+        `Model to use for oracle (default: ${DEFAULT_MODEL}). Options: ${Object.keys(ORACLE_MODELS).join(", ")}`,
+      ),
+    mode: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Oracle mode: validate (default), alternative, critique, or brainstorm",
+      ),
+  },
+  execute: async (args) => {
+    const {
+      question,
+      context,
+      model = DEFAULT_MODEL,
+      mode = "validate",
+    } = args as OracleRequest;
+
+    if (!question || question.trim() === "") {
+      return "Error: question is required";
+    }
+
+    // Validate model
+    const modelInfo = ORACLE_MODELS[model];
+    if (!modelInfo) {
+      return `Error: Unknown model "${model}". Available models: ${Object.keys(ORACLE_MODELS).join(", ")}`;
+    }
+
+    // Validate mode
+    const validModes = ["validate", "alternative", "critique", "brainstorm"];
+    if (!validModes.includes(mode)) {
+      return `Error: Unknown mode "${mode}". Available modes: ${validModes.join(", ")}`;
+    }
+
+    // Get system prompt for mode
+    const systemPrompt = SYSTEM_PROMPTS[mode];
+
+    // Build user message
+    let userMessage = question;
+    if (context) {
+      userMessage = `Context:\n${context}\n\nQuestion:\n${question}`;
+    }
+
+    const messages: ChatMessage[] = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage },
+    ];
+
+    // Call ProxyPal API
+    const PROXYPAL_BASE = "http://127.0.0.1:8317/v1";
+
+    try {
+      const response = await fetch(`${PROXYPAL_BASE}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer proxypal-local",
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          temperature: 0.7,
+          max_tokens: 4096,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return `Error: Oracle API returned ${response.status}: ${errorText}`;
+      }
+
+      const data = (await response.json()) as ChatResponse;
+
+      if (data.error) {
+        return `Error: ${data.error.message || "Unknown error from oracle"}`;
+      }
+
+      const content = data.choices?.[0]?.message?.content;
+      if (!content) {
+        return "Error: Oracle returned empty response";
+      }
+
+      // Format response with metadata
+      return `## Oracle Response (${modelInfo.name})
+**Mode**: ${mode}
+**Strength**: ${modelInfo.strength}
+
+---
+
+${content}
+
+---
+*Second opinion from ${model}*`;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (
+        message.includes("ECONNREFUSED") ||
+        message.includes("fetch failed")
+      ) {
+        return `Error: Cannot connect to ProxyPal at ${PROXYPAL_BASE}.
+
+To start ProxyPal, run: proxypal start`;
+      }
+
+      return `Error: Oracle query failed: ${message}`;
+    }
+  },
+});

package/package.json

@@ -1,8 +1,15 @@
 {
 	"name": "opencodekit",
-	"version": "0.15.12",
+	"version": "0.15.14",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
-	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
+	"keywords": [
+		"agents",
+		"cli",
+		"mcp",
+		"opencode",
+		"opencodekit",
+		"template"
+	],
 	"license": "MIT",
 	"author": "OpenCodeKit",
 	"repository": {
@@ -12,7 +19,10 @@
 	"bin": {
 		"ock": "dist/index.js"
 	},
-	"files": ["dist", "README.md"],
+	"files": [
+		"dist",
+		"README.md"
+	],
 	"type": "module",
 	"publishConfig": {
 		"access": "public",
@@ -56,5 +66,7 @@
 	"engines": {
 		"bun": ">=1.3.2"
 	},
-	"trustedDependencies": ["@beads/bd"]
+	"trustedDependencies": [
+		"@beads/bd"
+	]
 }