jawere 1.5.1 → 1.6.0

package/dist/index.js

@@ -13101,6 +13101,14 @@ You have access to a set of tools that let you interact with the filesystem:
          Skips hidden dirs and node_modules, .git, dist, etc.
   grep   Search file contents with regex. Returns file paths with line numbers.
          Skips binary files and files over 500KB.
+  web_search  Search the web for general information using DuckDuckGo (free).
+         Returns abstracts, answers, definitions, related topics, web links.
+         Use for general knowledge, news, current events \u2014 NOT for code docs.
+  docs   Search library/framework/API documentation specifically. Uses site-scoped
+         DuckDuckGo queries targeting official doc sites (MDN, nodejs.org, docs.rs,
+         react.dev, python.org, etc.). Optional library param narrows the search.
+         Use this for API references, method signatures, config options, examples.
+         Prefer this over web_search for any programming documentation lookup.
 
 \u2500\u2500 Parallel Tool Execution \u2500\u2500
 
@@ -13116,6 +13124,9 @@ independent of each other. This is faster and saves tokens \u2014 use it wheneve
   GOOD \u2014 read a file AND list a directory at the same time:
     \u2022 Call read(config.ts) + ls(src/) together
 
+  GOOD \u2014 search docs/web while also reading files:
+    \u2022 Call docs(query, library) + web_search(query) + read(file) all at once
+
   BAD \u2014 these depend on each other, so must be sequential:
     \u2022 grep then read (grep finds a file, then you read it)
     \u2022 bash then read (you run a command, then read its output file)
@@ -13182,6 +13193,7 @@ import { exec } from "child_process";
 import { readFile, writeFile, mkdir, access, stat as fsStat } from "fs/promises";
 import { constants } from "fs";
 import { resolve, dirname } from "path";
+import { get as httpsGet } from "https";
 var TOOL_DEFS = [
   {
     type: "function",
@@ -13387,6 +13399,52 @@ var TOOL_DEFS = [
         required: ["pattern"]
       }
     }
+  },
+  {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search the web for information. Uses DuckDuckGo (free, no API key needed). Returns relevant results including abstracts, answers, related topics, and web links. Use this for general knowledge, news, current events, or broad information not found locally.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query string"
+          },
+          count: {
+            type: "number",
+            description: "Maximum number of results to return (default 5, max 10)"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "docs",
+      description: "Search library, framework, and API documentation. Uses DuckDuckGo site-targeted queries to search official documentation sources (MDN, Node.js docs, npm packages, Rust docs, Python docs, Go docs, etc.). Free \u2014 no API key needed. Use this for API signatures, method references, configuration options, package usage examples, or any programming documentation lookup.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'Documentation search query (e.g. "fs.readFile options", "React useEffect cleanup")'
+          },
+          library: {
+            type: "string",
+            description: 'Optional library/package name to narrow search (e.g. "react", "typescript", "express")'
+          },
+          count: {
+            type: "number",
+            description: "Maximum results (default 5, max 8)"
+          }
+        },
+        required: ["query"]
+      }
+    }
   }
 ];
 var MAX_OUTPUT_LINES = 2e3;
@@ -13789,6 +13847,285 @@ async function diffTool(path, staged, base, workDir) {
   else args.push("--", ".");
   return execBash(`git ${args.join(" ")}`, workDir, 30);
 }
+function httpsGetJSON(url, timeout = 8e3) {
+  return new Promise((resolve4, reject) => {
+    const req = httpsGet(url, { timeout }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        httpsGetJSON(res.headers.location, timeout).then(resolve4).catch(reject);
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+        if (data.length > 5e5) {
+          res.destroy();
+          reject(new Error("Response too large"));
+        }
+      });
+      res.on("end", () => {
+        try {
+          resolve4(JSON.parse(data));
+        } catch {
+          reject(new Error(`Failed to parse JSON (status ${res.statusCode})`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+async function webSearchTool(query, count) {
+  const maxResults = Math.min(Math.max(count ?? 5, 1), 10);
+  const encoded = encodeURIComponent(query);
+  const ddgUrl = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
+  let json;
+  try {
+    json = await httpsGetJSON(ddgUrl, 1e4);
+  } catch (err) {
+    return `Error: Web search failed \u2014 ${err.message || err}`;
+  }
+  const parts = [];
+  if (json.Heading && json.Heading !== query) {
+    parts.push(`Topic: ${json.Heading}`);
+  }
+  if (json.Answer) {
+    parts.push(`Answer: ${json.Answer}`);
+  }
+  if (json.AbstractText && json.AbstractText.trim()) {
+    let abstract = json.AbstractText.trim();
+    if (json.AbstractSource) {
+      abstract += ` [Source: ${json.AbstractSource}]`;
+    }
+    if (json.AbstractURL) {
+      abstract += ` \u2014 ${json.AbstractURL}`;
+    }
+    parts.push(`Summary: ${abstract}`);
+  } else if (json.Abstract && json.Abstract.trim()) {
+    parts.push(`Summary: ${json.Abstract.trim()}`);
+  }
+  if (json.Definition) {
+    let def = `Definition: ${json.Definition}`;
+    if (json.DefinitionSource) def += ` [Source: ${json.DefinitionSource}]`;
+    parts.push(def);
+  }
+  if (json.Infobox?.content) {
+    const fields = json.Infobox.content.filter((c2) => c2.label && c2.value).map((c2) => `  ${c2.label}: ${c2.value}`).slice(0, 8);
+    if (fields.length > 0) {
+      parts.push(`Details:
+${fields.join("\n")}`);
+    }
+  }
+  if (json.RelatedTopics && json.RelatedTopics.length > 0) {
+    const topics = [];
+    for (const t2 of json.RelatedTopics) {
+      if (topics.length >= maxResults) break;
+      if (t2.Text && t2.FirstURL) {
+        const cleanText = t2.Text.replace(/<[^>]+>/g, "").trim();
+        topics.push(`  - ${cleanText.slice(0, 200)}
+    ${t2.FirstURL}`);
+      } else if (t2.Text) {
+        topics.push(`  - ${t2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 200)}`);
+      }
+    }
+    if (topics.length > 0) {
+      parts.push(`Related:
+${topics.join("\n")}`);
+    }
+  }
+  if (json.Results && json.Results.length > 0) {
+    const results = [];
+    for (const r2 of json.Results) {
+      if (results.length >= maxResults) break;
+      if (r2.Text && r2.FirstURL) {
+        results.push(`  - ${r2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 200)}
+    ${r2.FirstURL}`);
+      }
+    }
+    if (results.length > 0) {
+      parts.push(`Web Results:
+${results.join("\n")}`);
+    }
+  }
+  if (parts.length === 0) {
+    return `No results found for "${query}". Try different keywords or be more specific.`;
+  }
+  return truncateOutput(parts.join("\n\n")).text;
+}
+var KNOWN_DOC_SITES = [
+  // JavaScript/TypeScript ecosystem
+  { patterns: ["node", "nodejs", "node.js"], sites: ["nodejs.org", "nodejs.dev"] },
+  { patterns: ["javascript", "js", "mozilla", "mdn"], sites: ["developer.mozilla.org"] },
+  { patterns: ["typescript", "ts"], sites: ["typescriptlang.org"] },
+  { patterns: ["react", "reactjs", "react.js"], sites: ["react.dev", "reactjs.org", "legacy.reactjs.org"] },
+  { patterns: ["express", "expressjs", "express.js"], sites: ["expressjs.com"] },
+  { patterns: ["next", "nextjs", "next.js"], sites: ["nextjs.org"] },
+  { patterns: ["vue", "vuejs", "vue.js"], sites: ["vuejs.org"] },
+  { patterns: ["svelte", "sveltekit"], sites: ["svelte.dev", "kit.svelte.dev"] },
+  { patterns: ["tailwind", "tailwindcss"], sites: ["tailwindcss.com"] },
+  { patterns: ["prisma"], sites: ["prisma.io"] },
+  { patterns: ["vite"], sites: ["vitejs.dev"] },
+  { patterns: ["esbuild"], sites: ["esbuild.github.io"] },
+  { patterns: ["webpack"], sites: ["webpack.js.org"] },
+  { patterns: ["babel"], sites: ["babeljs.io"] },
+  { patterns: ["eslint"], sites: ["eslint.org"] },
+  { patterns: ["prettier"], sites: ["prettier.io"] },
+  { patterns: ["jest"], sites: ["jestjs.io"] },
+  { patterns: ["vitest"], sites: ["vitest.dev"] },
+  { patterns: ["playwright"], sites: ["playwright.dev"] },
+  { patterns: ["cypress"], sites: ["cypress.io", "docs.cypress.io"] },
+  { patterns: ["graphql"], sites: ["graphql.org"] },
+  { patterns: ["apollo"], sites: ["apollographql.com"] },
+  { patterns: ["trpc"], sites: ["trpc.io"] },
+  { patterns: ["zod"], sites: ["github.com/colinhacks/zod", "zod.dev"] },
+  { patterns: ["axios"], sites: ["axios-http.com"] },
+  { patterns: ["npm"], sites: ["npmjs.com", "docs.npmjs.com"] },
+  { patterns: ["pnpm"], sites: ["pnpm.io"] },
+  { patterns: ["yarn"], sites: ["yarnpkg.com"] },
+  { patterns: ["deno"], sites: ["deno.com", "deno.land", "docs.deno.com"] },
+  { patterns: ["bun"], sites: ["bun.sh"] },
+  // Python
+  { patterns: ["python", "py"], sites: ["docs.python.org"] },
+  { patterns: ["django"], sites: ["djangoproject.com", "docs.djangoproject.com"] },
+  { patterns: ["flask"], sites: ["flask.palletsprojects.com"] },
+  { patterns: ["fastapi"], sites: ["fastapi.tiangolo.com"] },
+  { patterns: ["pydantic"], sites: ["docs.pydantic.dev"] },
+  { patterns: ["pytest"], sites: ["docs.pytest.org"] },
+  { patterns: ["poetry"], sites: ["python-poetry.org"] },
+  { patterns: ["numpy"], sites: ["numpy.org"] },
+  { patterns: ["pandas"], sites: ["pandas.pydata.org"] },
+  { patterns: ["sqlalchemy"], sites: ["docs.sqlalchemy.org"] },
+  { patterns: ["alembic"], sites: ["alembic.sqlalchemy.org"] },
+  // Rust
+  { patterns: ["rust", "cargo", "rustc"], sites: ["doc.rust-lang.org", "docs.rs"] },
+  { patterns: ["tokio"], sites: ["docs.rs/tokio", "tokio.rs"] },
+  { patterns: ["serde"], sites: ["docs.rs/serde", "serde.rs"] },
+  { patterns: ["actix"], sites: ["actix.rs", "docs.rs/actix-web"] },
+  { patterns: ["axum"], sites: ["docs.rs/axum"] },
+  { patterns: ["bevy"], sites: ["bevyengine.org", "docs.rs/bevy"] },
+  // Go
+  { patterns: ["go", "golang"], sites: ["pkg.go.dev", "go.dev"] },
+  { patterns: ["gin"], sites: ["gin-gonic.com", "pkg.go.dev/github.com/gin-gonic"] },
+  { patterns: ["echo"], sites: ["echo.labstack.com", "pkg.go.dev/github.com/labstack/echo"] },
+  { patterns: ["fiber"], sites: ["docs.gofiber.io", "pkg.go.dev/github.com/gofiber/fiber"] },
+  // Ruby
+  { patterns: ["ruby", "rubygems"], sites: ["ruby-doc.org", "rubygems.org"] },
+  { patterns: ["rails", "ruby on rails"], sites: ["guides.rubyonrails.org", "api.rubyonrails.org"] },
+  { patterns: ["rspec"], sites: ["rspec.info", "rubydoc.info"] },
+  // Other
+  { patterns: ["linux", "man"], sites: ["man7.org", "linux.die.net"] },
+  { patterns: ["git"], sites: ["git-scm.com"] },
+  { patterns: ["docker"], sites: ["docs.docker.com"] },
+  { patterns: ["kubernetes", "k8s"], sites: ["kubernetes.io"] },
+  { patterns: ["nginx"], sites: ["nginx.org", "nginx.com"] },
+  { patterns: ["postgresql", "postgres", "pg"], sites: ["postgresql.org"] },
+  { patterns: ["mysql"], sites: ["dev.mysql.com"] },
+  { patterns: ["redis"], sites: ["redis.io"] },
+  { patterns: ["mongodb", "mongo"], sites: ["mongodb.com", "docs.mongodb.com"] },
+  { patterns: ["sqlite"], sites: ["sqlite.org"] },
+  { patterns: ["aws"], sites: ["docs.aws.amazon.com"] }
+  // Add more as needed — this list guides the agent to official docs
+];
+function resolveDocSites(query, library) {
+  const searchTerms = (library ? `${library} ${query}` : query).toLowerCase();
+  const sites = [];
+  for (const entry of KNOWN_DOC_SITES) {
+    for (const pat of entry.patterns) {
+      if (searchTerms.includes(pat) && !sites.some((s2) => entry.sites.includes(s2))) {
+        sites.push(...entry.sites);
+        break;
+      }
+    }
+  }
+  return sites;
+}
+async function docsSearchTool(query, library, count, useSites = true) {
+  const maxResults = Math.min(Math.max(count ?? 5, 1), 8);
+  const sites = useSites ? resolveDocSites(query, library) : [];
+  let searchQuery;
+  if (library) {
+    searchQuery = `${library} ${query}`;
+  } else {
+    searchQuery = query;
+  }
+  if (sites.length > 0) {
+    const siteFilters = sites.map((s2) => `site:${s2}`).join(" OR ");
+    searchQuery = `${searchQuery} (${siteFilters})`;
+  } else {
+    searchQuery = `${searchQuery} documentation`;
+  }
+  const ddgUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(searchQuery)}&format=json&no_html=1&skip_disambig=1`;
+  let json;
+  try {
+    json = await httpsGetJSON(ddgUrl, 1e4);
+  } catch (err) {
+    return `Error: Docs search failed \u2014 ${err.message || err}`;
+  }
+  const parts = [];
+  const headerParts = [];
+  if (library) headerParts.push(`Library: ${library}`);
+  if (sites.length > 0) headerParts.push(`Sources: ${sites.join(", ")}`);
+  if (headerParts.length > 0) {
+    parts.push(headerParts.join(" | "));
+  }
+  if (json.Answer) {
+    parts.push(`Answer: ${json.Answer}`);
+  }
+  if (json.AbstractText && json.AbstractText.trim()) {
+    const abstract = json.AbstractText.trim();
+    const source = json.AbstractSource ? ` [${json.AbstractSource}]` : "";
+    const url = json.AbstractURL ? ` \u2014 ${json.AbstractURL}` : "";
+    parts.push(`Summary: ${abstract}${source}${url}`);
+  } else if (json.Abstract && json.Abstract.trim()) {
+    parts.push(`Summary: ${json.Abstract.trim()}`);
+  }
+  if (json.Definition) {
+    let def = `Definition: ${json.Definition}`;
+    if (json.DefinitionSource) def += ` [Source: ${json.DefinitionSource}]`;
+    parts.push(def);
+  }
+  if (json.RelatedTopics && json.RelatedTopics.length > 0) {
+    const topics = [];
+    for (const t2 of json.RelatedTopics) {
+      if (topics.length >= maxResults) break;
+      if (t2.Text && t2.FirstURL) {
+        const cleanText = t2.Text.replace(/<[^>]+>/g, "").trim();
+        topics.push(`  - ${cleanText.slice(0, 250)}
+    ${t2.FirstURL}`);
+      } else if (t2.Text) {
+        topics.push(`  - ${t2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 250)}`);
+      }
+    }
+    if (topics.length > 0) {
+      parts.push(`Documentation Results:
+${topics.join("\n")}`);
+    }
+  }
+  if (json.Results && json.Results.length > 0) {
+    const results = [];
+    for (const r2 of json.Results) {
+      if (results.length >= maxResults) break;
+      if (r2.Text && r2.FirstURL) {
+        results.push(`  - ${r2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 200)}
+    ${r2.FirstURL}`);
+      }
+    }
+    if (results.length > 0) {
+      parts.push(`More:
+${results.join("\n")}`);
+    }
+  }
+  const hasContent = parts.length > (headerParts.length > 0 ? 1 : 0);
+  if (!hasContent && sites.length > 0) {
+    return docsSearchTool(query, library, count, false);
+  }
+  if (!hasContent) {
+    return `No documentation results for "${query}". Try different terms or use web_search for broader results.`;
+  }
+  return truncateOutput(parts.join("\n\n")).text;
+}
 async function executeTool(call, workDir) {
   const { id, function: fn } = call;
   let args;
@@ -13850,6 +14187,19 @@ async function executeTool(call, workDir) {
       case "stat":
         result = await statTool(args.path, workDir);
         break;
+      case "web_search":
+        result = await webSearchTool(
+          args.query,
+          args.count
+        );
+        break;
+      case "docs":
+        result = await docsSearchTool(
+          args.query,
+          args.library,
+          args.count
+        );
+        break;
       default:
         result = `Error: Unknown tool: ${fn.name}`;
     }
@@ -14312,11 +14662,20 @@ var COL = () => process.stdout.columns || 80;
 var GRUVBOX_GREEN = "\x1B[38;2;184;187;3m";
 var GRUVBOX_GRAY = "\x1B[38;2;146;131;116m";
 var GRUVBOX_RED = "\x1B[38;2;251;73;52m";
+var GRUVBOX_AQUA = "\x1B[38;2;142;192;124m";
 var RESET2 = "\x1B[0m";
 var FILE_TOOLS = /* @__PURE__ */ new Set(["read", "write", "edit", "stat"]);
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["web_search", "docs"]);
 var SILENT_TOOLS = /* @__PURE__ */ new Set(["diff"]);
 function toolDetail(name, args) {
   switch (name) {
+    case "web_search":
+      return String(args.query || "?");
+    case "docs": {
+      let d2 = String(args.query || "?");
+      if (args.library) d2 = `${args.library}: ${d2}`;
+      return d2;
+    }
     case "read": {
       let d2 = String(args.path || "?");
       if (args.offset) d2 += ` [L${args.offset}${args.limit ? `-${Number(args.offset) + Number(args.limit) - 1}` : "+"}]`;
@@ -14345,7 +14704,7 @@ function displayToolLine(name, args, ok, spin) {
   }
   const statusIcon = ok ? "\u2713" : "\u2717";
   const statusColor = ok ? GRUVBOX_GREEN : GRUVBOX_RED;
-  const toolColor = FILE_TOOLS.has(name) ? GRUVBOX_GREEN : GRUVBOX_GRAY;
+  const toolColor = SEARCH_TOOLS.has(name) ? GRUVBOX_AQUA : FILE_TOOLS.has(name) ? GRUVBOX_GREEN : GRUVBOX_GRAY;
   const prefix = `${toolColor}${name}${RESET2}: `;
   const suffix = ` ${statusColor}${statusIcon}${RESET2}`;
   let detail = toolDetail(name, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jawere",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "type": "module",
   "bin": {
     "jawere": "bin/jawere.js"