opencode-plugin-search 0.0.3 → 0.0.4

package/README.md

@@ -142,6 +142,16 @@ See [ast-grep rule documentation](https://ast-grep.github.io/guide/rule-config.h
 
 The plugin automatically looks for `sgconfig.yaml` in the project root to support custom languages and rule directories for ast-grep search functionality. See [ast-grep documentation](https://ast-grep.github.io/advanced/custom-language.html) for configuration details.
 
+## Future Plans
+
+See [ROADMAP.md](ROADMAP.md) for detailed plans about upcoming features including:
+
+- **Pre-configured rule library** - Ready-to-use templates for common patterns
+- **Batch query optimization** - Multiple patterns in single calls
+- **Context-aware search** - Richer results with surrounding code context
+- **Semantic search enhancement** - Component usage tracking and dependency analysis
+- **Performance optimizations** - Parallel execution and smart caching
+
 ## Development
 
 ```bash

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -8,6 +9,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -15014,7 +15016,7 @@ var jsYaml = {
   safeDump
 };
 
-// src/utils.ts
+// src/astgrep/utils.ts
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
@@ -15113,7 +15115,7 @@ async function executeAstGrep(command, args, options) {
   return { matches: [], stdout, stderr };
 }
 
-// src/tools.ts
+// src/astgrep/tools.ts
 var patternSchema = tool.schema.union([
   tool.schema.string(),
   tool.schema.object({
@@ -15296,7 +15298,311 @@ ${JSON.stringify({
     }
   });
 }
+// src/websearch/duckduckgo.ts
+async function searchDuckDuckGo(query, options) {
+  try {
+    const response = await fetch(`https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&no_redirect=1`);
+    if (!response.ok) {
+      throw new Error(`DuckDuckGo API error: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const results = [];
+    if (data.Abstract && data.AbstractText) {
+      results.push({
+        title: data.Heading || data.AbstractSource || "Instant Answer",
+        link: data.AbstractURL || "",
+        snippet: data.AbstractText
+      });
+    }
+    if (data.Results && Array.isArray(data.Results)) {
+      data.Results.forEach((item) => {
+        if (item.FirstURL) {
+          results.push({
+            title: item.Text || "",
+            link: item.FirstURL,
+            snippet: ""
+          });
+        }
+      });
+    }
+    if (data.RelatedTopics && Array.isArray(data.RelatedTopics)) {
+      data.RelatedTopics.forEach((item) => {
+        if (item.FirstURL && item.Text) {
+          results.push({
+            title: item.Text.split(" - ")[0] || item.Text,
+            link: item.FirstURL,
+            snippet: item.Text.split(" - ").slice(1).join(" - ") || ""
+          });
+        }
+      });
+    }
+    return results.slice(0, options.limit);
+  } catch (error45) {
+    console.error("DuckDuckGo search error:", error45);
+    throw new Error(`DuckDuckGo search failed: ${error45 instanceof Error ? error45.message : String(error45)}`);
+  }
+}
 
+// src/websearch/google.ts
+async function searchGoogle(query, options) {
+  try {
+    const playwright = await import("playwright");
+    const { chromium } = playwright;
+    const browser = await chromium.launch({
+      headless: options.headless ?? true,
+      args: [
+        "--disable-blink-features=AutomationControlled",
+        "--disable-features=IsolateOrigins,site-per-process",
+        "--disable-site-isolation-trials",
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-accelerated-2d-canvas",
+        "--no-first-run",
+        "--no-zygote",
+        "--disable-gpu",
+        "--hide-scrollbars",
+        "--mute-audio"
+      ],
+      ignoreDefaultArgs: ["--enable-automation"]
+    });
+    try {
+      const context = await browser.newContext({
+        viewport: { width: 1920, height: 1080 },
+        userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        locale: options.locale,
+        timezoneId: "America/New_York"
+      });
+      await context.addInitScript(() => {
+        Object.defineProperty(navigator, "webdriver", { get: () => false });
+        Object.defineProperty(navigator, "plugins", { get: () => [1, 2, 3, 4, 5] });
+        Object.defineProperty(navigator, "languages", { get: () => ["en-US", "en"] });
+        window.chrome = {
+          runtime: {},
+          loadTimes: () => {},
+          csi: () => {},
+          app: {}
+        };
+      });
+      const page = await context.newPage();
+      const googleDomain = options.country ? `https://www.google.${options.country.toLowerCase()}` : "https://www.google.com";
+      await page.goto(googleDomain, { waitUntil: "networkidle", timeout: options.timeout });
+      const currentUrl = page.url();
+      if (currentUrl.includes("sorry") || currentUrl.includes("captcha") || currentUrl.includes("recaptcha")) {
+        throw new Error("Google CAPTCHA detected. Try enabling headless: false or using a different IP.");
+      }
+      const searchInput = await page.waitForSelector('textarea[name="q"], input[name="q"]', {
+        timeout: options.timeout / 2
+      });
+      await searchInput.click();
+      await searchInput.fill(query);
+      await searchInput.press("Enter");
+      await page.waitForLoadState("networkidle", { timeout: options.timeout });
+      const searchUrl = page.url();
+      if (searchUrl.includes("sorry") || searchUrl.includes("captcha") || searchUrl.includes("recaptcha")) {
+        throw new Error("Google CAPTCHA detected after search. Try enabling headless: false or using a different IP.");
+      }
+      const results = await page.evaluate((limit) => {
+        const extracted = [];
+        const seenUrls = new Set;
+        const selectorSets = [
+          { container: "#search div[data-hveid]", title: "h3", snippet: 'div[role="text"]' },
+          { container: "#rso div[data-hveid]", title: "h3", snippet: 'div[style*="webkit-line-clamp"]' },
+          { container: ".g", title: "h3", snippet: "div" },
+          { container: "div[jscontroller][data-hveid]", title: "h3", snippet: 'div[role="text"]' }
+        ];
+        const alternativeSnippetSelectors = ['div[role="text"]', 'div[style*="webkit-line-clamp"]', "div"];
+        for (const selectors of selectorSets) {
+          if (extracted.length >= limit)
+            break;
+          const containers = Array.from(document.querySelectorAll(selectors.container));
+          for (const container of containers) {
+            if (extracted.length >= limit)
+              break;
+            const titleElement = container.querySelector(selectors.title);
+            if (!titleElement)
+              continue;
+            const title = (titleElement.textContent || "").trim();
+            let link = "";
+            const linkInTitle = titleElement.querySelector("a");
+            if (linkInTitle) {
+              link = linkInTitle.href;
+            } else {
+              let current = titleElement;
+              while (current && current.tagName !== "A") {
+                current = current.parentElement;
+              }
+              if (current && current instanceof HTMLAnchorElement) {
+                link = current.href;
+              } else {
+                const containerLink = container.querySelector("a");
+                if (containerLink) {
+                  link = containerLink.href;
+                }
+              }
+            }
+            if (!link || !link.startsWith("http") || seenUrls.has(link))
+              continue;
+            let snippet2 = "";
+            const snippetElement = container.querySelector(selectors.snippet);
+            if (snippetElement) {
+              snippet2 = (snippetElement.textContent || "").trim();
+            } else {
+              for (const altSelector of alternativeSnippetSelectors) {
+                const element = container.querySelector(altSelector);
+                if (element) {
+                  snippet2 = (element.textContent || "").trim();
+                  break;
+                }
+              }
+              if (!snippet2) {
+                const textNodes = Array.from(container.querySelectorAll("div")).filter((el) => !el.querySelector("h3") && (el.textContent || "").trim().length > 20);
+                if (textNodes.length > 0) {
+                  snippet2 = (textNodes[0]?.textContent || "").trim();
+                }
+              }
+            }
+            if (title && link) {
+              extracted.push({ title, link, snippet: snippet2 });
+              seenUrls.add(link);
+            }
+          }
+        }
+        if (extracted.length < limit) {
+          const anchorElements = Array.from(document.querySelectorAll("a[href^='http']"));
+          for (const el of anchorElements) {
+            if (extracted.length >= limit)
+              break;
+            if (!(el instanceof HTMLAnchorElement))
+              continue;
+            const link = el.href;
+            if (!link || seenUrls.has(link) || link.includes("google.com/") || link.includes("accounts.google") || link.includes("support.google")) {
+              continue;
+            }
+            const title = (el.textContent || "").trim();
+            if (!title)
+              continue;
+            let snippet2 = "";
+            let parent = el.parentElement;
+            for (let i2 = 0;i2 < 3 && parent; i2++) {
+              const text = (parent.textContent || "").trim();
+              if (text.length > 20 && text !== title) {
+                snippet2 = text;
+                break;
+              }
+              parent = parent.parentElement;
+            }
+            extracted.push({ title, link, snippet: snippet2 });
+            seenUrls.add(link);
+          }
+        }
+        return extracted.slice(0, limit);
+      }, options.limit);
+      await browser.close();
+      return results;
+    } catch (error45) {
+      await browser.close();
+      throw new Error(`Google search failed: ${error45 instanceof Error ? error45.message : String(error45)}`);
+    }
+  } catch (error45) {
+    if (error45 instanceof Error && error45.message.includes("Cannot find module")) {
+      throw new Error(`Google search requires Playwright to be installed. Please install it with: npm install playwright@latest
+Note: Playwright requires downloading browser binaries (~180MB).`);
+    }
+    throw error45;
+  }
+}
+
+// src/websearch/tools.ts
+var searchEngineOptionsSchema = tool.schema.object({
+  duckduckgo: tool.schema.object({
+    safe_search: tool.schema.boolean().optional(),
+    region: tool.schema.string().optional(),
+    time_range: tool.schema.enum(["d", "w", "m", "y"]).optional()
+  }).optional(),
+  google: tool.schema.object({
+    safe_search: tool.schema.boolean().optional(),
+    country: tool.schema.string().optional(),
+    headless: tool.schema.boolean().optional(),
+    use_saved_state: tool.schema.boolean().optional()
+  }).optional()
+}).refine((obj) => obj.duckduckgo !== undefined || obj.google !== undefined, {
+  message: "At least one search engine must be specified (duckduckgo or google)"
+});
+function createWebSearchTool() {
+  return tool({
+    description: "Search the web using Google and/or DuckDuckGo. If multiple engines are specified, queries run in parallel.",
+    args: {
+      query: tool.schema.string(),
+      engines: searchEngineOptionsSchema,
+      limit: tool.schema.number().int().positive().max(50).optional(),
+      timeout: tool.schema.number().int().positive().max(120000).optional(),
+      locale: tool.schema.string().optional()
+    },
+    async execute(args, _context) {
+      const { query, engines, limit = 10, timeout = 30000, locale = "en-US" } = args;
+      const results = [];
+      const sources = {};
+      const searchPromises = [];
+      if (engines.google) {
+        searchPromises.push(searchGoogle(query, { ...engines.google, limit, timeout, locale }).then((googleResults) => {
+          sources.google = { count: googleResults.length, success: true };
+          googleResults.forEach((result, index) => {
+            results.push({
+              ...result,
+              source: "google",
+              rank: index + 1
+            });
+          });
+        }).catch((error45) => {
+          sources.google = {
+            count: 0,
+            success: false,
+            error: error45 instanceof Error ? error45.message : String(error45)
+          };
+        }));
+      }
+      if (engines.duckduckgo) {
+        searchPromises.push(searchDuckDuckGo(query, { ...engines.duckduckgo, limit, timeout, locale }).then((ddResults) => {
+          sources.duckduckgo = { count: ddResults.length, success: true };
+          ddResults.forEach((result, index) => {
+            results.push({
+              ...result,
+              source: "duckduckgo",
+              rank: index + 1
+            });
+          });
+        }).catch((error45) => {
+          sources.duckduckgo = {
+            count: 0,
+            success: false,
+            error: error45 instanceof Error ? error45.message : String(error45)
+          };
+        }));
+      }
+      await Promise.allSettled(searchPromises);
+      results.sort((a, b) => {
+        if (a.source === b.source) {
+          return a.rank - b.rank;
+        }
+        return a.source === "google" ? -1 : 1;
+      });
+      if (results.length === 0) {
+        const errors3 = Object.entries(sources).filter(([_, info]) => !info?.success).map(([engine, info]) => `${engine}: ${info?.error}`).join("; ");
+        return `No results found. ${errors3 ? `Errors: ${errors3}` : "Try adjusting your search terms."}`;
+      }
+      const formatted = results.map((r, i2) => `${i2 + 1}. [${r.source.toUpperCase()}] ${r.title}
+   ${r.link}
+   ${r.snippet || "No description"}
+`).join(`
+`);
+      const summary = `Found ${results.length} results from: ${Object.entries(sources).filter(([_, info]) => info?.success).map(([engine, info]) => `${engine}(${info?.count})`).join(", ") || "none"}`;
+      return `${summary}
+
+${formatted}`;
+    }
+  });
+}
 // src/plugin.ts
 var SearchPlugin = async ({ directory }) => {
   return {
@@ -15304,7 +15610,8 @@ var SearchPlugin = async ({ directory }) => {
       ast_grep_find: createFindTool(directory),
       ast_grep_find_by_rule: createFindByRuleTool(directory),
       ast_grep_dump_syntax: createDumpSyntaxTool(),
-      ast_grep_test_rule: createTestRuleTool(directory)
+      ast_grep_test_rule: createTestRuleTool(directory),
+      web_search: createWebSearchTool()
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-plugin-search",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "An OpenCode plugin providing advanced code search capabilities including AST-based structural search using ast-grep.",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,8 @@
     "build": "bun build ./src/index.ts --outfile ./dist/index.js --target node",
     "watch": "bun build ./src/index.ts --outfile ./dist/index.js --target node --watch",
     "typecheck": "biome check && tsc --noEmit",
-    "auto": "biome check --fix && tsc --noEmit"
+    "auto": "biome check --fix && tsc --noEmit",
+    "test:pack": "bun pm pack --dry-run"
   },
   "repository": {
     "type": "git",
@@ -35,7 +36,13 @@
   "homepage": "https://github.com/elyzov/opencode-plugin-search#readme",
   "peerDependencies": {
     "@opencode-ai/plugin": "^1.1.19",
-    "@opencode-ai/sdk": "^1.1.19"
+    "@opencode-ai/sdk": "^1.1.19",
+    "playwright": "^1.49.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@tsconfig/bun": "^1.0.10",