webfox 0.0.0-test.0 → 4.0.1

package/dist/pi.js

@@ -0,0 +1,563 @@
+import {
+  renderTextDocument
+} from "./chunk-QRHDXM2L.js";
+import {
+  createWebfox
+} from "./chunk-MVCCEPDF.js";
+import "./chunk-WCTOYZVB.js";
+import "./chunk-GAWPRXAU.js";
+import "./chunk-ZVTVERW5.js";
+import {
+  CAPABILITIES
+} from "./chunk-G2YAQEET.js";
+import "./chunk-U4BLULLV.js";
+
+// src/pi.ts
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import {
+  truncateHead,
+  withFileMutationQueue
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+// src/pi-render.ts
+import { stripVTControlCharacters as stripVTControlCharacters3 } from "node:util";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import {
+  Text as Text2,
+  Container,
+  Markdown,
+  visibleWidth as visibleWidth2
+} from "@earendil-works/pi-tui";
+
+// src/pi-params.ts
+import { stripVTControlCharacters } from "node:util";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeOptions(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") return stripVTControlCharacters(value);
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value !== "object") return void 0;
+  if (ancestors.has(value)) return "[Circular]";
+  ancestors.add(value);
+  const safe = Array.isArray(value) ? value.map((child) => safeOptions(child, ancestors)) : Object.fromEntries(
+    Object.entries(value).map(([key, child]) => {
+      const normalized = stripVTControlCharacters(key).replace(
+        /[^a-z0-9]/gi,
+        ""
+      );
+      const sensitive = /authorization|apikey|credential|password|secret|headers?|cookie|privatekey|token$|^(auth|bearer)$/i.test(
+        normalized
+      );
+      return [
+        key,
+        sensitive ? "[redacted]" : safeOptions(child, ancestors)
+      ];
+    })
+  );
+  ancestors.delete(value);
+  return safe;
+}
+function keySegment(key) {
+  const safe = stripVTControlCharacters(key);
+  return /^[a-zA-Z_][\w-]*$/.test(safe) ? safe : JSON.stringify(safe);
+}
+function parameterValue(value) {
+  if (typeof value === "string" && /^[a-zA-Z_][\w./:@+-]*$/.test(value) && !/^(true|false|null)$/.test(value))
+    return value;
+  return JSON.stringify(value);
+}
+function callParameters(capability, args, formatKey = (key) => key) {
+  const pairs = [];
+  if (capability === "search" && typeof args.maxResults === "number" && Number.isFinite(args.maxResults))
+    pairs.push(`${formatKey("limit")}=${args.maxResults}`);
+  const append = (value, path) => {
+    if (isRecord(value) && Object.keys(value).length) {
+      for (const [key, child] of Object.entries(value))
+        append(child, path ? `${path}.${keySegment(key)}` : keySegment(key));
+    } else if (path) {
+      const formatted = parameterValue(value);
+      if (formatted !== void 0)
+        pairs.push(`${formatKey(path)}=${formatted}`);
+    }
+  };
+  if (isRecord(args.options)) {
+    const options = safeOptions(args.options);
+    for (const [key, value] of Object.entries(options)) {
+      append(value, key === "limit" ? "options.limit" : keySegment(key));
+    }
+  }
+  return pairs.join(" ");
+}
+
+// src/pi-keybindings.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir, keyText } from "@earendil-works/pi-coding-agent";
+import {
+  getKeybindings,
+  KeybindingsManager
+} from "@earendil-works/pi-tui";
+function expansionKey() {
+  const id = "app.tools.expand";
+  const key = keyText(id);
+  if (key) return key;
+  const manager = getKeybindings();
+  if (manager.getDefinition(id)) return formatKeys(manager.getKeys(id));
+  let configured;
+  try {
+    const settings = JSON.parse(
+      readFileSync(join(getAgentDir(), "keybindings.json"), "utf8")
+    );
+    configured = settings?.[id] ?? settings?.expandTools;
+  } catch {
+  }
+  const binding = typeof configured === "string" || Array.isArray(configured) && configured.every((key2) => typeof key2 === "string") ? configured : "ctrl+o";
+  const keys = new KeybindingsManager({ [id]: { defaultKeys: "ctrl+o" } }, {
+    [id]: binding
+  }).getKeys(id);
+  return formatKeys(keys);
+}
+function formatKeys(keys) {
+  return keys.map(
+    (key) => key.split("+").map(
+      (part) => process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part
+    ).join("+")
+  ).join("/");
+}
+
+// src/pi-text.ts
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+function truncateLine(text, width) {
+  return truncateToWidth(text, width).replaceAll(
+    "\x1B[0m",
+    "\x1B[22;23;24;25;27;28;29;39m"
+  );
+}
+function plainText(value) {
+  return stripVTControlCharacters2(value).replace(
+    /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g,
+    ""
+  );
+}
+
+// src/pi-search-render.ts
+import {
+  Text,
+  getCapabilities,
+  hyperlink,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function searchDocument(value) {
+  if (!isRecord2(value) || value.capability !== "search" || !Array.isArray(value.results))
+    return false;
+  return value.results.every((entry) => {
+    if (!isRecord2(entry) || typeof entry.input !== "string") return false;
+    if (entry.ok === false)
+      return isRecord2(entry.error) && typeof entry.error.message === "string";
+    return entry.ok === true && isRecord2(entry.value) && Array.isArray(entry.value.results) && entry.value.results.every(
+      (result) => isRecord2(result) && typeof result.title === "string" && typeof result.url === "string" && typeof result.snippet === "string"
+    );
+  });
+}
+function link(url, theme) {
+  const label = theme.fg("accent", theme.underline(plainText(url)));
+  if (!getCapabilities().hyperlinks || /[\x00-\x20\x7f-\x9f]/.test(url))
+    return label;
+  try {
+    const target = new URL(url);
+    if (target.protocol === "https:" || target.protocol === "http:")
+      return hyperlink(label, target.href);
+  } catch {
+  }
+  return label;
+}
+function renderSearchResult(details, fallback, theme) {
+  const document = isRecord2(details) && searchDocument(details.result) ? details.result : void 0;
+  return {
+    render(width) {
+      if (width <= 0) return [];
+      if (!document) {
+        const text = plainText(fallback).split("\n").map((line) => {
+          const urlLine = /^(\s*)(https?:\/\/\S+)(\s*)$/.exec(line);
+          return urlLine ? urlLine[1] + link(urlLine[2], theme) + urlLine[3] : theme.fg("toolOutput", line);
+        }).join("\n");
+        return new Text(text, 0, 0).render(width).map((line) => truncateLine(line, width));
+      }
+      const lines = [];
+      const append = (text, prefix = "") => {
+        const indent = visibleWidth(prefix);
+        const wrapped = new Text(text, 0, 0).render(
+          Math.max(1, width - indent)
+        );
+        lines.push(
+          ...wrapped.map(
+            (line, index) => truncateLine((index ? " ".repeat(indent) : prefix) + line, width)
+          )
+        );
+      };
+      document.results.forEach((entry, index) => {
+        if (index) lines.push("");
+        if (document.results.length > 1) {
+          append(
+            theme.fg(
+              "mdHeading",
+              theme.bold(`${index + 1}. ${plainText(entry.input)}`)
+            )
+          );
+          lines.push("");
+        }
+        if (!entry.ok) {
+          append(theme.fg("error", `Error: ${plainText(entry.error.message)}`));
+          return;
+        }
+        if (!entry.value.results.length)
+          append(theme.fg("toolOutput", "No results found."));
+        entry.value.results.forEach((result, resultIndex) => {
+          if (resultIndex) lines.push("");
+          const number = `${resultIndex + 1}. `;
+          const indent = " ".repeat(number.length);
+          append(
+            theme.fg("toolOutput", plainText(result.title)),
+            theme.fg("accent", number)
+          );
+          append(link(result.url, theme), indent);
+          if (result.snippet)
+            append(theme.fg("toolOutput", plainText(result.snippet)), indent);
+        });
+      });
+      return lines;
+    },
+    invalidate() {
+    }
+  };
+}
+
+// src/pi-render.ts
+var inputStates = {
+  queued: { glyph: "\u25CF", color: "dim" },
+  running: { glyph: "\u25B6\uFE0E", color: "muted" },
+  done: { glyph: "\u2714\uFE0E", color: "success" },
+  failed: { glyph: "\u2718\uFE0E", color: "error" },
+  cancelled: { glyph: "\u25A0", color: "dim" }
+};
+function statusRows(details) {
+  if (!details || typeof details !== "object") return;
+  let rows;
+  if ("webInputStatus" in details && details.webInputStatus === true && "inputs" in details && Array.isArray(details.inputs)) {
+    rows = details.inputs;
+  } else if ("webContentsStatus" in details && details.webContentsStatus === true && "urls" in details && Array.isArray(details.urls)) {
+    rows = details.urls.map((row) => ({ input: row?.url, state: row?.state }));
+  } else return;
+  const inputs = rows.filter(
+    (row) => !!row && typeof row === "object" && "input" in row && typeof row.input === "string" && "state" in row && typeof row.state === "string" && Object.hasOwn(inputStates, row.state)
+  );
+  return inputs;
+}
+function displayInput(value) {
+  return JSON.stringify(plainText(value)).slice(1, -1);
+}
+var WebCall = class {
+  constructor(capability) {
+    this.capability = capability;
+  }
+  capability;
+  args = {};
+  theme;
+  expanded = false;
+  update(args, theme, expanded) {
+    this.args = args && typeof args === "object" ? args : {};
+    this.theme = theme;
+    this.expanded = expanded;
+  }
+  render(width) {
+    if (width <= 0) return [];
+    const { args, theme, capability } = this;
+    const title = theme.fg("toolTitle", theme.bold(`web ${capability}`));
+    let text = title;
+    const parameters = callParameters(
+      capability,
+      args,
+      (key2) => theme.bold(key2)
+    );
+    if (parameters) text += theme.fg("dim", ` ${parameters}`);
+    if (this.expanded)
+      return visibleWidth2(text) <= width ? [text] : new Text2(text, 0, 0).render(width).map((line) => truncateLine(line, width));
+    const key = expansionKey();
+    const hint = key ? theme.fg("muted", " (") + theme.fg("dim", key) + theme.fg("muted", " to expand)") : "";
+    if (width >= visibleWidth2(title) + visibleWidth2(hint) + 3)
+      return [truncateLine(text, width - visibleWidth2(hint)) + hint];
+    return [truncateLine(text, width)];
+  }
+  // Rendering is stateless so width and theme changes never retain stale styling.
+  invalidate() {
+  }
+};
+function renderWebResult(result, options, theme, isError, capability) {
+  const text = result.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n");
+  const metadata = result.details;
+  const isSearch = (capability ?? metadata?.capability ?? metadata?.result?.capability) === "search";
+  const body = () => isSearch ? renderSearchResult(result.details, text, theme) : new Markdown(text, 0, 0, getMarkdownTheme());
+  const rows = statusRows(result.details);
+  if (rows?.length) {
+    const container = new Container();
+    container.addChild({
+      render: (width) => width > 0 ? rows.flatMap((row) => {
+        const { glyph, color } = inputStates[row.state];
+        const line = theme.fg(color, glyph) + " " + theme.fg("accent", displayInput(row.input));
+        return options.expanded ? new Text2(line, 0, 0).render(width).map((wrapped) => truncateLine(wrapped, width)) : [truncateLine(line, width)];
+      }) : [],
+      invalidate() {
+      }
+    });
+    if (options.expanded && !options.isPartial) container.addChild(body());
+    return container;
+  }
+  if (options.expanded) return body();
+  const partialFailure = result.details && typeof result.details === "object" && "status" in result.details && result.details.status === "partial";
+  if (!options.isPartial && !isError && !partialFailure) return new Container();
+  const summary = partialFailure ? "One or more inputs failed." : stripVTControlCharacters3(text).split(/\r?\n/).find((line) => line.trim()) ?? (options.isPartial ? "Working\u2026" : "Tool failed.");
+  const safe = JSON.stringify(summary).slice(1, -1);
+  const status = inputStates[isError || partialFailure ? "failed" : "running"];
+  return {
+    render: (width) => width > 0 ? [
+      truncateLine(
+        theme.fg(status.color, status.glyph) + " " + theme.fg(isError || partialFailure ? "error" : "muted", safe),
+        width
+      )
+    ] : [],
+    invalidate() {
+    }
+  };
+}
+
+// src/pi-validation.ts
+import { stripVTControlCharacters as stripVTControlCharacters4 } from "node:util";
+import { Check, Errors } from "typebox/value";
+function isSchema(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function alternatives(schema) {
+  return ["anyOf", "oneOf", "allOf"].flatMap(
+    (key) => Array.isArray(schema[key]) ? schema[key].filter(isSchema) : []
+  );
+}
+function acceptsPath(schema, path) {
+  if (schema === true) return true;
+  if (!isSchema(schema)) return false;
+  if (!path.length) return true;
+  if (alternatives(schema).some((branch) => acceptsPath(branch, path)))
+    return true;
+  const [key, ...rest] = path;
+  if (schema.type === "array") return acceptsPath(schema.items, rest);
+  if (schema.properties && Object.hasOwn(schema.properties, key))
+    return acceptsPath(schema.properties[key], rest);
+  if (isSchema(schema.patternProperties)) {
+    for (const [pattern, child] of Object.entries(schema.patternProperties))
+      if (new RegExp(pattern).test(key) && acceptsPath(child, rest))
+        return true;
+  }
+  if (schema.additionalProperties === false) return false;
+  if (schema.type && schema.type !== "object") return false;
+  if (alternatives(schema).length && !schema.properties && schema.additionalProperties === void 0)
+    return false;
+  return schema.additionalProperties === void 0 || acceptsPath(schema.additionalProperties, rest);
+}
+function displayPath(path) {
+  return path.map((part, index) => {
+    const safe = stripVTControlCharacters4(part);
+    if (/^[a-zA-Z_][\w-]*$/.test(safe)) return `${index ? "." : ""}${safe}`;
+    if (/^\d+$/.test(safe)) return `[${safe}]`;
+    return `[${JSON.stringify(safe)}]`;
+  }).join("");
+}
+function locations(schema, name, path = []) {
+  if (!isSchema(schema)) return [];
+  const found = alternatives(schema).flatMap(
+    (branch) => locations(branch, name, path)
+  );
+  if (isSchema(schema.properties)) {
+    for (const [key, child] of Object.entries(schema.properties)) {
+      const next = [...path, key];
+      if (key === name) found.push(next);
+      found.push(...locations(child, name, next));
+    }
+  }
+  return found;
+}
+function prepareToolArguments(schema, args) {
+  if (Check(schema, args)) return args;
+  const messages = /* @__PURE__ */ new Set();
+  for (const error of Errors(schema, args)) {
+    if (error.keyword !== "additionalProperties") continue;
+    const names = error.params.additionalProperties;
+    if (!Array.isArray(names)) continue;
+    const parent = error.instancePath.split("/").slice(1).map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
+    for (const name of names) {
+      if (typeof name !== "string") continue;
+      const path = [...parent, name];
+      if (acceptsPath(schema, path)) continue;
+      const targets = [...new Set(locations(schema, name).map(displayPath))];
+      const suggestion = targets.length === 1 ? ` Use ${targets[0]} instead.` : " Check the tool's parameter schema.";
+      messages.add(`Invalid parameter: ${displayPath(path)}.${suggestion}`);
+      if (messages.size === 3) break;
+    }
+    if (messages.size === 3) break;
+  }
+  if (messages.size) throw new Error([...messages].join("\n"));
+  return args;
+}
+
+// src/pi.ts
+function webExtension(pi) {
+  const clients = /* @__PURE__ */ new Map();
+  const clientFor = (cwd) => {
+    let client = clients.get(cwd);
+    if (!client) {
+      client = createWebfox({ cwd });
+      clients.set(cwd, client);
+    }
+    return client;
+  };
+  const initial = clientFor(process.cwd());
+  const selected = CAPABILITIES.filter(
+    (capability) => initial.inspectCapability(capability).provider
+  );
+  if (!selected.length)
+    pi.on("session_start", (_event, context) => {
+      if (context.hasUI)
+        context.ui.notify(
+          "Web registered no tools. Select a default provider in the shared configuration, then restart pi.",
+          "warning"
+        );
+    });
+  for (const capability of selected) {
+    const inspection = initial.inspectCapability(capability);
+    const provider = inspection.provider;
+    const fields = capability === "contents" ? { urls: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }) } : capability === "research" ? { input: Type.String({ minLength: 1 }) } : {
+      queries: Type.Array(Type.String({ minLength: 1 }), {
+        minItems: 1,
+        maxItems: 10
+      }),
+      ...capability === "search" ? { maxResults: Type.Optional(Type.Integer({ minimum: 1 })) } : {}
+    };
+    const parameters = Type.Object(
+      {
+        ...fields,
+        ...inspection.optionSchema ? {
+          options: Type.Optional(
+            inspection.optionSchema
+          )
+        } : {}
+      },
+      { additionalProperties: false }
+    );
+    pi.registerTool({
+      name: `web_${capability}`,
+      label: `Web ${capability[0].toUpperCase()}${capability.slice(1)}`,
+      description: `${descriptions[capability]} Output is truncated to 2000 lines or 50 KiB; full results are saved to a file when truncated.`,
+      parameters,
+      prepareArguments(args) {
+        return prepareToolArguments(parameters, args);
+      },
+      renderCall(args, theme, context) {
+        const call = context.lastComponent instanceof WebCall ? context.lastComponent : new WebCall(capability);
+        call.update(args, theme, context.expanded);
+        return call;
+      },
+      renderResult(result, options, theme, context) {
+        return renderWebResult(
+          result,
+          options,
+          theme,
+          context.isError,
+          capability
+        );
+      },
+      async execute(_id, values, signal, onUpdate, ctx) {
+        const params = values;
+        const client = clientFor(ctx.cwd);
+        const inputStatuses = [];
+        const request = {
+          provider,
+          signal: signal ?? ctx.signal,
+          options: params.options,
+          onProgress: (event) => {
+            if (event.inputIndex !== void 0 && event.input !== void 0 && event.state) {
+              inputStatuses[event.inputIndex] = {
+                input: event.input,
+                state: event.state
+              };
+            }
+            onUpdate?.({
+              content: [{ type: "text", text: event.message }],
+              details: {
+                webInputStatus: true,
+                capability,
+                inputs: inputStatuses.filter(Boolean).map((row) => ({ ...row }))
+              }
+            });
+          }
+        };
+        const result = capability === "search" ? await client.search({
+          ...request,
+          queries: params.queries,
+          maxResults: params.maxResults
+        }) : capability === "answer" ? await client.answer({ ...request, queries: params.queries }) : capability === "contents" ? await client.contents({ ...request, urls: params.urls }) : await client.research({ ...request, input: params.input });
+        const text = renderTextDocument(result);
+        const truncated = truncateHead(text);
+        let body = truncated.content;
+        let fullOutputPath;
+        if (truncated.truncated) {
+          fullOutputPath = join2(
+            await mkdtemp(join2(tmpdir(), "web-")),
+            "result.json"
+          );
+          await withFileMutationQueue(
+            fullOutputPath,
+            () => writeFile(fullOutputPath, JSON.stringify(result), { mode: 384 })
+          );
+          body += `
+
+Full results: ${fullOutputPath}`;
+        }
+        return {
+          content: [{ type: "text", text: body }],
+          details: {
+            webProviderResult: true,
+            status: result.status,
+            webInputStatus: true,
+            capability,
+            inputs: result.results.map((entry) => ({
+              input: entry.input,
+              state: entry.ok ? "done" : entry.error.code === "CANCELLED" ? "cancelled" : "failed"
+            })),
+            ...fullOutputPath ? { fullOutputPath } : { result }
+          }
+        };
+      }
+    });
+  }
+  pi.on("tool_result", (event) => {
+    if (event.details && typeof event.details === "object" && "webProviderResult" in event.details && event.details.webProviderResult === true && "status" in event.details && event.details.status === "partial")
+      return { isError: true };
+  });
+}
+var descriptions = {
+  search: "Search up to ten queries and return titles, URLs, and snippets in input order.",
+  contents: "Fetch and extract readable contents from web URLs.",
+  answer: "Answer up to ten questions using web-grounded evidence.",
+  research: "Run foreground multi-step web research and return the final report."
+};
+export {
+  webExtension as default
+};

package/dist/providers/brave/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { Brave } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Brave, context: ProviderContext): Promise<SearchResponse>;
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: Brave, context: ProviderContext): Promise<ToolOutput>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: Brave, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/brave/definition.d.ts

@@ -0,0 +1 @@
+export declare const braveProvider: import("../definition.js").ProviderDefinitionFor<"brave">;

package/dist/providers/brave/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Brave extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/cli-json.d.ts

@@ -0,0 +1,9 @@
+import type { CustomCommandConfig } from "./custom/types.js";
+import type { ProviderContext } from "./contract.js";
+/** Subprocess mechanics only; lifecycle and outward redaction belong to runtime. */
+export declare function runCliJsonCommand<TOutput>({ command, payload, context, label, }: {
+    command: CustomCommandConfig;
+    payload: Record<string, unknown>;
+    context: ProviderContext;
+    label: string;
+}): Promise<TOutput>;

package/dist/providers/cloudflare/adapter.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderContext } from "../contract.js";
+import type { Cloudflare } from "./types.js";
+export declare const adapter: {
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Cloudflare, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+};

package/dist/providers/cloudflare/definition.d.ts

@@ -0,0 +1 @@
+export declare const cloudflareProvider: import("../definition.js").ProviderDefinitionFor<"cloudflare">;

package/dist/providers/cloudflare/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Cloudflare extends Provider {
+    accountId?: string;
+}