@openontology/opencode-palantir 0.1.3 → 0.1.4

package/dist/index.js

@@ -8068,36 +8068,254 @@ var plugin = async (input) => {
   function pushText(output, text) {
     output.parts.push({ type: "text", text });
   }
+  function toPathname(inputUrl) {
+    const trimmed = inputUrl.trim();
+    if (trimmed.length === 0)
+      return "";
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+      try {
+        return new URL(trimmed).pathname;
+      } catch {}
+    }
+    if (trimmed.startsWith("www.")) {
+      try {
+        return new URL(`https://${trimmed}`).pathname;
+      } catch {}
+    }
+    const noQueryOrHash = trimmed.split("#")[0].split("?")[0];
+    if (noQueryOrHash.startsWith("/"))
+      return noQueryOrHash;
+    return `/${noQueryOrHash}`;
+  }
+  function makeUrlCandidates(inputUrl) {
+    const raw = inputUrl.trim();
+    const pathOnly = toPathname(raw);
+    const candidates = new Set;
+    function addVariant(u) {
+      const v = u.trim();
+      if (v.length === 0)
+        return;
+      candidates.add(v);
+      if (v.endsWith("/") && v.length > 1)
+        candidates.add(v.slice(0, -1));
+      else
+        candidates.add(`${v}/`);
+    }
+    addVariant(raw);
+    addVariant(pathOnly);
+    if (pathOnly.startsWith("/docs/")) {
+      addVariant(pathOnly.replace(/^\/docs(?=\/)/, ""));
+    } else if (pathOnly.startsWith("/foundry/") || pathOnly.startsWith("/apollo/") || pathOnly.startsWith("/gotham/")) {
+      addVariant(`/docs${pathOnly}`);
+    }
+    return Array.from(candidates);
+  }
+  function parseScope(rawScope) {
+    if (rawScope === undefined)
+      return "foundry";
+    if (rawScope === "foundry" || rawScope === "apollo" || rawScope === "gotham" || rawScope === "all") {
+      return rawScope;
+    }
+    return null;
+  }
+  function isInScope(pageUrl, scope) {
+    if (scope === "all")
+      return true;
+    const path5 = toPathname(pageUrl);
+    return path5.startsWith(`/${scope}/`) || path5.startsWith(`/docs/${scope}/`);
+  }
+  function tokenizeQuery(query) {
+    const tokens = query.toLowerCase().trim().split(/[\s/._-]+/g).map((t) => t.trim()).filter((t) => t.length > 0);
+    return Array.from(new Set(tokens));
+  }
+  function scorePageMatch(page, query) {
+    const q = query.toLowerCase().trim();
+    if (q.length === 0)
+      return 0;
+    const path5 = toPathname(page.url).toLowerCase();
+    const title = page.title.toLowerCase();
+    if (path5 === q)
+      return 2000;
+    if (path5 === toPathname(q).toLowerCase())
+      return 2000;
+    if (path5.includes(q))
+      return 1200;
+    if (title.includes(q))
+      return 1000;
+    const tokens = tokenizeQuery(q);
+    if (tokens.length === 0)
+      return 0;
+    let score = 0;
+    for (const t of tokens) {
+      if (title.includes(t))
+        score += 40;
+      if (path5.includes(t))
+        score += 30;
+    }
+    if (path5.startsWith(q))
+      score += 100;
+    if (title.startsWith(q))
+      score += 100;
+    return score;
+  }
   return {
     tool: {
       get_doc_page: tool({
-        description: "Retrieve a Palantir Foundry documentation page by its URL path. Use this when you need the full content of a specific documentation page.",
+        description: "Retrieve a Palantir documentation page. Provide either a URL path (preferred) or a free-text query; the tool will handle common URL variants (full URLs, missing /docs prefix, trailing slashes).",
         args: {
-          url: tool.schema.string().describe("The URL path of the doc page, e.g. /docs/foundry/ontology/overview/")
+          url: tool.schema.string().optional().describe("Doc URL path or full URL, e.g. /foundry/compute-modules/overview/"),
+          query: tool.schema.string().optional().describe('Free-text query to find the most relevant page, e.g. "compute modules".'),
+          scope: tool.schema.enum(["foundry", "apollo", "gotham", "all"]).optional().describe("Scope to search within when using query or fuzzy matching (default: foundry).")
         },
         async execute(args) {
           if (!await dbExists())
             return NO_DB_MESSAGE;
+          const scope = parseScope(args.scope);
+          if (!scope) {
+            return [
+              "[ERROR] Invalid scope. Must be one of: foundry, apollo, gotham, all.",
+              'Example: get_doc_page with { "query": "compute modules", "scope": "foundry" }'
+            ].join(`
+`);
+          }
+          const rawUrl = args.url;
+          const rawQuery = args.query;
+          const urlInput = typeof rawUrl === "string" ? rawUrl.trim() : null;
+          const queryInput = typeof rawQuery === "string" ? rawQuery.trim() : null;
+          if ((!urlInput || urlInput.length === 0) && (!queryInput || queryInput.length === 0)) {
+            return [
+              '[ERROR] Missing input. Provide either "url" or "query".',
+              'Example: get_doc_page with { "url": "/foundry/compute-modules/overview/" }',
+              'Example: get_doc_page with { "query": "compute modules", "scope": "foundry" }'
+            ].join(`
+`);
+          }
           const db = await getDb();
-          const page = await getPage(db, args.url);
-          if (!page)
-            return `Page not found: ${args.url}`;
-          return page.content;
+          if (urlInput && urlInput.length > 0) {
+            const candidates = makeUrlCandidates(urlInput);
+            for (const c of candidates) {
+              const page = await getPage(db, c);
+              if (page)
+                return page.content;
+            }
+          }
+          const q = (queryInput && queryInput.length > 0 ? queryInput : urlInput) ?? "";
+          const pages = getAllPages(db);
+          const ranked = pages.filter((p) => isInScope(p.url, scope)).map((p) => ({ page: p, score: scorePageMatch(p, q) })).filter((r) => r.score > 0).sort((a, b) => {
+            if (b.score !== a.score)
+              return b.score - a.score;
+            return toPathname(a.page.url).localeCompare(toPathname(b.page.url));
+          }).slice(0, 5);
+          if (ranked.length === 0) {
+            return `Page not found: ${urlInput ?? q}`;
+          }
+          const best = ranked[0];
+          const bestPage = await getPage(db, best.page.url);
+          if (bestPage) {
+            const strong = best.score >= 200 || toPathname(best.page.url).toLowerCase() === toPathname(q).toLowerCase() || tokenizeQuery(q).every((t) => (best.page.title + " " + toPathname(best.page.url)).toLowerCase().includes(t));
+            if (strong) {
+              return `Matched: ${best.page.title} (${best.page.url})
+
+${bestPage.content}`;
+            }
+          }
+          const suggestions = ranked.map((r) => `- ${r.page.title} (${r.page.url})`).join(`
+`);
+          return [
+            `Page not found: ${urlInput ?? q}`,
+            "",
+            "Top matches:",
+            suggestions,
+            "",
+            "Tip: call get_doc_page with an exact URL from the list above."
+          ].join(`
+`);
         }
       }),
       list_all_docs: tool({
-        description: "List all available Palantir Foundry documentation pages with their URLs and titles. Use this to discover what documentation is available.",
-        args: {},
-        async execute() {
+        description: "List available Palantir documentation pages with their URLs and titles. Supports pagination and optional scope filtering (default: foundry). Use this to discover what documentation is available.",
+        args: {
+          limit: tool.schema.number().int().min(1).max(200).optional().describe("Max results to return (default: 50, max: 200)."),
+          offset: tool.schema.number().int().min(0).optional().describe("Zero-based offset into the filtered, deterministic listing (default: 0)."),
+          scope: tool.schema.enum(["foundry", "apollo", "gotham", "all"]).optional().describe("Doc scope filter by URL prefix /<scope>/ (default: foundry)."),
+          query: tool.schema.string().optional().describe("Optional query to filter/rank results by title/URL (case-insensitive).")
+        },
+        async execute(args) {
           if (!await dbExists())
             return NO_DB_MESSAGE;
+          const scope = parseScope(args.scope);
+          if (!scope) {
+            return [
+              "[ERROR] Invalid scope. Must be one of: foundry, apollo, gotham, all.",
+              'Example: list_all_docs with { "scope": "foundry", "offset": 0, "limit": 50 }'
+            ].join(`
+`);
+          }
+          const rawLimit = args.limit;
+          const limit = rawLimit === undefined ? 50 : rawLimit;
+          if (!Number.isFinite(limit) || !Number.isInteger(limit) || limit < 1 || limit > 200) {
+            return [
+              "[ERROR] Invalid limit. Must be an integer between 1 and 200.",
+              'Example: list_all_docs with { "scope": "foundry", "offset": 0, "limit": 50 }'
+            ].join(`
+`);
+          }
+          const rawOffset = args.offset;
+          const offset = rawOffset === undefined ? 0 : rawOffset;
+          if (!Number.isFinite(offset) || !Number.isInteger(offset) || offset < 0) {
+            return [
+              "[ERROR] Invalid offset. Must be an integer >= 0.",
+              'Example: list_all_docs with { "scope": "foundry", "offset": 0, "limit": 50 }'
+            ].join(`
+`);
+          }
+          const rawQuery = args.query;
+          const query = typeof rawQuery === "string" ? rawQuery.trim() : null;
+          if (query && query.length > 200) {
+            return "[ERROR] Query is too long. Please use 200 characters or fewer.";
+          }
           const db = await getDb();
-          const pages = getAllPages(db);
-          const lines = pages.map((p) => `- ${p.title} (${p.url})`);
-          return `Available Palantir Foundry Documentation (${pages.length} pages):
-
-${lines.join(`
+          const pages = getAllPages(db).slice();
+          const scoped = pages.filter((p) => isInScope(p.url, scope));
+          const filteredWithScores = query && query.length > 0 ? scoped.map((p) => ({ page: p, score: scorePageMatch(p, query) })).filter((r) => r.score > 0).sort((a, b) => {
+            if (b.score !== a.score)
+              return b.score - a.score;
+            return toPathname(a.page.url).localeCompare(toPathname(b.page.url));
+          }) : scoped.map((p) => ({ page: p, score: 0 })).sort((a, b) => toPathname(a.page.url).localeCompare(toPathname(b.page.url)));
+          const total = filteredWithScores.length;
+          if (offset >= total) {
+            const safeOffset = Math.max(0, total - limit);
+            return [
+              `Available Palantir Documentation Pages`,
+              `scope=${scope} query=${query ?? ""} total=${total} returned=0 offset=${offset} limit=${limit}`,
+              "",
+              `Offset ${offset} is beyond total ${total}.`,
+              `Try: list_all_docs with { "scope": "${scope}", "offset": ${safeOffset}, "limit": ${limit} }`
+            ].join(`
+`);
+          }
+          const page = filteredWithScores.slice(offset, offset + limit).map((r) => r.page);
+          const lines = page.map((p) => `- ${p.title} (${p.url})`);
+          const returned = page.length;
+          const nextOffset = offset + returned;
+          const hasMore = nextOffset < total;
+          const header = [
+            `Available Palantir Documentation Pages`,
+            `scope=${scope} query=${query ?? ""} total=${total} returned=${returned} offset=${offset} limit=${limit}`,
+            ""
+          ].join(`
+`);
+          if (!hasMore) {
+            return `${header}${lines.join(`
 `)}`;
+          }
+          return [
+            header + lines.join(`
+`),
+            "",
+            `Next: call list_all_docs with { "scope": "${scope}", "offset": ${nextOffset}, "limit": ${limit} }`
+          ].join(`
+`);
         }
       })
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openontology/opencode-palantir",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "collection of tools, agents, hooks to supercharge development in foundry",
   "license": "MIT",
   "author": {