@wrongstack/plugins 0.1.0

package/dist/web-search.js

@@ -0,0 +1,210 @@
+// src/web-search/index.ts
+var API_VERSION = "^0.1.10";
+async function duckduckgoSearch(query, numResults) {
+  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}&kl=us-en`;
+  const resp = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)"
+    }
+  });
+  if (!resp.ok) throw new Error(`DuckDuckGo search failed: ${resp.status}`);
+  const html = await resp.text();
+  const results = [];
+  const resultRe = /<a class="result__a" href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+  let m;
+  while ((m = resultRe.exec(html)) !== null && results.length < numResults) {
+    const url2 = m[1];
+    if (!url2) continue;
+    const title = (m[2] ?? "").replace(/<[^>]+>/g, "").trim();
+    const snippet = (m[3] ?? "").replace(/<[^>]+>/g, "").trim();
+    results.push({
+      url: url2,
+      title,
+      snippet,
+      score: 1,
+      source: "duckduckgo",
+      cached: false
+    });
+  }
+  return results;
+}
+async function fetchUrl(url, format) {
+  const resp = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)",
+      "Accept": format === "text" ? "text/plain" : "text/html"
+    }
+  });
+  if (!resp.ok) throw new Error(`Failed to fetch ${url}: ${resp.status} ${resp.statusText}`);
+  if (format === "text") {
+    return resp.text();
+  }
+  let html = await resp.text();
+  html = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  html = html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  html = html.replace(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi, (_, t) => `
+## ${t.trim()}
+`);
+  html = html.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, t) => `${t.trim()}
+
+`);
+  html = html.replace(/<br\s*\/?>/gi, "\n");
+  html = html.replace(/<[^>]+>/g, "");
+  html = html.replace(/&amp;/g, "&");
+  html = html.replace(/&lt;/g, "<");
+  html = html.replace(/&gt;/g, ">");
+  html = html.replace(/&quot;/g, '"');
+  html = html.replace(/&#39;/g, "'");
+  html = html.replace(/\n{3,}/g, "\n\n");
+  return html.trim().slice(0, 5e4);
+}
+function scoreResults(results, query) {
+  const terms = query.toLowerCase().split(/\s+/);
+  return results.map((r) => {
+    const titleLower = r.title.toLowerCase();
+    const snippetLower = r.snippet.toLowerCase();
+    let score = r.score;
+    for (const term of terms) {
+      if (titleLower.includes(term)) score += 2;
+      if (snippetLower.includes(term)) score += 1;
+    }
+    return { ...r, score };
+  }).sort((a, b) => b.score - a.score);
+}
+var plugin = {
+  name: "web-search",
+  version: "0.1.0",
+  description: "Cached web search with deduplication and relevance ranking",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, pipelines: ["request"] },
+  defaultConfig: {
+    cacheTtlMs: 3e5,
+    maxResults: 10,
+    userAgent: "WrongStack/1.0"
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      cacheTtlMs: { type: "number", default: 3e5 },
+      maxResults: { type: "number", default: 10 },
+      userAgent: { type: "string", default: "WrongStack/1.0" }
+    }
+  },
+  setup(api) {
+    const cache = /* @__PURE__ */ new Map();
+    const cacheTtlMs = api.config.extensions?.["web-search"]?.["cacheTtlMs"] ?? 3e5;
+    const maxResults = api.config.extensions?.["web-search"]?.["maxResults"] ?? 10;
+    api.tools.register({
+      name: "web_search",
+      description: "Search the web using DuckDuckGo with automatic caching and deduplication. Results are cached for faster subsequent queries.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          numResults: { type: "number", default: 10, description: "Maximum number of results" },
+          source: { type: "string", enum: ["duckduckgo"], default: "duckduckgo", description: "Search engine" },
+          skipCache: { type: "boolean", default: false, description: "Skip cache and force fresh search" }
+        },
+        required: ["query"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const query = input["query"];
+        if (!query || typeof query !== "string" || query.trim() === "") {
+          return { ok: false, error: "query is required and must be a non-empty string", results: [] };
+        }
+        const numResults = input["numResults"] ?? maxResults;
+        const skipCache = input["skipCache"] ?? false;
+        if (!skipCache) {
+          const cached = cache.get(query);
+          if (cached && Date.now() - cached.timestamp < cacheTtlMs) {
+            const results = cached.results.map((r) => ({ ...r, cached: true }));
+            api.metrics.counter("cache_hit", 1, { query: query.slice(0, 20) });
+            return {
+              ok: true,
+              query,
+              cached: true,
+              results: results.slice(0, numResults),
+              count: results.length
+            };
+          }
+        }
+        api.metrics.counter("cache_miss", 1, { query: query.slice(0, 20) });
+        const seenUrls = /* @__PURE__ */ new Set();
+        let rawResults;
+        try {
+          rawResults = await duckduckgoSearch(query, numResults * 2);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { ok: false, error: `Search failed: ${msg}`, results: [] };
+        }
+        const deduplicated = [];
+        for (const r of rawResults) {
+          const normalized = (r.url.split("?")[0] ?? r.url).split("#")[0] ?? r.url;
+          if (!seenUrls.has(normalized) && r.url.startsWith("http")) {
+            seenUrls.add(normalized);
+            deduplicated.push(r);
+          }
+        }
+        const ranked = scoreResults(deduplicated, query);
+        cache.set(query, { results: ranked, timestamp: Date.now() });
+        const now = Date.now();
+        for (const [key, entry] of cache.entries()) {
+          if (now - entry.timestamp > cacheTtlMs * 2) cache.delete(key);
+        }
+        return {
+          ok: true,
+          query,
+          cached: false,
+          results: ranked.slice(0, numResults),
+          count: ranked.length
+        };
+      }
+    });
+    api.tools.register({
+      name: "web_fetch",
+      description: "Fetch a URL and return its content as markdown or plain text.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          url: { type: "string", format: "uri", description: "URL to fetch" },
+          format: { type: "string", enum: ["markdown", "text"], default: "markdown" }
+        },
+        required: ["url"]
+      },
+      permission: "confirm",
+      mutating: false,
+      async execute(input) {
+        const rawUrl = input["url"];
+        if (!rawUrl || typeof rawUrl !== "string") {
+          return { ok: false, error: "url is required and must be a string" };
+        }
+        const url = rawUrl;
+        const format = input["format"] ?? "markdown";
+        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+          return { ok: false, error: "URL must start with http:// or https://" };
+        }
+        let content;
+        try {
+          content = await fetchUrl(url, format);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { ok: false, error: msg };
+        }
+        return {
+          ok: true,
+          url,
+          format,
+          contentLength: content.length,
+          content: content.slice(0, 2e4),
+          truncated: content.length > 2e4
+        };
+      }
+    });
+    api.log.info("web-search plugin loaded", { version: "0.1.0", cacheTtlMs });
+  }
+};
+var web_search_default = plugin;
+
+export { web_search_default as default };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@wrongstack/plugins",
+  "version": "0.1.0",
+  "description": "Official WrongStack plugin collection — auto-doc, git-autocommit, shell-check, cost-tracker, file-watcher, web-search, json-path, cron, template-engine, semver-bump",
+  "license": "MIT",
+  "author": "ECOSTACK TECHNOLOGY OÜ",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./auto-doc": {
+      "types": "./dist/auto-doc/index.d.ts",
+      "import": "./dist/auto-doc/index.js"
+    },
+    "./git-autocommit": {
+      "types": "./dist/git-autocommit/index.d.ts",
+      "import": "./dist/git-autocommit/index.js"
+    },
+    "./shell-check": {
+      "types": "./dist/shell-check/index.d.ts",
+      "import": "./dist/shell-check/index.js"
+    },
+    "./cost-tracker": {
+      "types": "./dist/cost-tracker/index.d.ts",
+      "import": "./dist/cost-tracker/index.js"
+    },
+    "./file-watcher": {
+      "types": "./dist/file-watcher/index.d.ts",
+      "import": "./dist/file-watcher/index.js"
+    },
+    "./web-search": {
+      "types": "./dist/web-search/index.d.ts",
+      "import": "./dist/web-search/index.js"
+    },
+    "./json-path": {
+      "types": "./dist/json-path/index.d.ts",
+      "import": "./dist/json-path/index.js"
+    },
+    "./cron": {
+      "types": "./dist/cron/index.d.ts",
+      "import": "./dist/cron/index.js"
+    },
+    "./template-engine": {
+      "types": "./dist/template-engine/index.d.ts",
+      "import": "./dist/template-engine/index.js"
+    },
+    "./semver-bump": {
+      "types": "./dist/semver-bump/index.d.ts",
+      "import": "./dist/semver-bump/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.19.19",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "@wrongstack/core": "0.6.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}