roforge-cli 0.3.0

package/src/tools/web.js

@@ -0,0 +1,155 @@
+// Web tools, running locally (no backend needed): web_search + url_fetch.
+// Search provider order: serper → brave → wikipedia (keyless fallback).
+import dns from "node:dns/promises";
+import net from "node:net";
+import { htmlToText, truncate } from "../util.js";
+
+const UA = "RoForge/0.2 (+local; roblox studio agent)";
+
+async function serper(q, max, key) {
+  const res = await fetch("https://google.serper.dev/search", {
+    method: "POST",
+    headers: { "X-API-KEY": key, "Content-Type": "application/json" },
+    body: JSON.stringify({ q, num: max }),
+    signal: AbortSignal.timeout(15000),
+  });
+  if (!res.ok) throw new Error(`Serper HTTP ${res.status}`);
+  const data = await res.json();
+  return (data.organic || []).slice(0, max).map((r) => ({ title: r.title, url: r.link, snippet: r.snippet }));
+}
+
+async function brave(q, max, key) {
+  const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(q)}&count=${max}`;
+  const res = await fetch(url, {
+    headers: { "X-Subscription-Token": key, Accept: "application/json" },
+    signal: AbortSignal.timeout(15000),
+  });
+  if (!res.ok) throw new Error(`Brave HTTP ${res.status}`);
+  const data = await res.json();
+  const results = (data && data.web && data.web.results) || [];
+  return results.slice(0, max).map((r) => ({ title: r.title, url: r.url, snippet: r.description }));
+}
+
+async function wikipedia(q, max) {
+  const url = `https://en.wikipedia.org/w/api.php?action=opensearch&format=json&limit=${max}&search=${encodeURIComponent(q)}`;
+  const res = await fetch(url, { headers: { "User-Agent": UA }, signal: AbortSignal.timeout(15000) });
+  if (!res.ok) throw new Error(`Wikipedia HTTP ${res.status}`);
+  const data = await res.json();
+  const titles = data[1] || [];
+  const urls = data[3] || [];
+  return titles.map((t, i) => ({ title: t, url: urls[i] || "", snippet: "Wikipedia (keyless fallback)" }));
+}
+
+function pickProvider(cfg) {
+  if (cfg.searchProvider && cfg.searchProvider !== "auto") return cfg.searchProvider;
+  if (cfg.serperKey) return "serper";
+  if (cfg.braveKey) return "brave";
+  return "wikipedia";
+}
+
+export async function webSearch(cfg, query, max = 6) {
+  const provider = pickProvider(cfg);
+  const impl = { serper, brave, wikipedia }[provider];
+  if (!impl) throw new Error(`unknown search provider '${provider}'`);
+  const results = await impl(String(query), max, cfg.serperKey || cfg.braveKey);
+  if (!results.length) return "No results found.";
+  let out = `Web search results for: ${query} (provider: ${provider}`;
+  if (provider === "wikipedia") out += ", keyless fallback";
+  out += ")\n";
+  results.forEach((r, i) => {
+    out += `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet || ""}\n`;
+  });
+  return out;
+}
+
+function ipIsPrivate(ip) {
+  if (net.isIPv4(ip)) {
+    const [a, b] = ip.split(".").map(Number);
+    return a === 10 || a === 127 || a === 0 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 169 && b === 254);
+  }
+  const lower = ip.toLowerCase();
+  if (lower === "::1" || lower === "::" || lower === "::ffff:0.0.0.0") return true;
+  if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
+  if (lower.startsWith("fe80:")) return true;
+  if (lower.startsWith("::ffff:")) return ipIsPrivate(lower.slice(7));
+  return false;
+}
+
+async function assertPublicHost(hostname) {
+  const host = hostname.replace(/^\[|\]$/g, "");
+  if (net.isIP(host)) {
+    if (ipIsPrivate(host)) throw new Error(`Blocked: ${host} is a private/loopback address`);
+    return;
+  }
+  const addresses = await dns.lookup(host, { all: true });
+  if (!addresses.length || addresses.some((a) => ipIsPrivate(a.address))) {
+    throw new Error(`Blocked: ${host} resolves to a private/loopback address`);
+  }
+}
+
+export async function fetchUrl(rawUrl, { maxBytes = 512 * 1024, maxChars = 60000, timeoutMs = 15000 } = {}) {
+  let current;
+  try {
+    current = new URL(String(rawUrl));
+  } catch {
+    throw new Error("Invalid URL");
+  }
+  for (let hop = 0; ; hop++) {
+    if (!/^https?:$/.test(current.protocol)) throw new Error("Only http/https URLs are allowed");
+    await assertPublicHost(current.hostname);
+    const res = await fetch(current.toString(), {
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { "User-Agent": UA, Accept: "text/html,application/json,text/plain,application/xml,*/*" },
+    }).catch((e) => {
+      throw new Error(`Fetch failed: ${e.cause?.code || e.message}`);
+    });
+    if (res.status >= 300 && res.status < 400 && res.headers.get("location")) {
+      if (hop + 1 > 5) throw new Error("Too many redirects");
+      current = new URL(res.headers.get("location"), current);
+      continue;
+    }
+    if (!res.ok) throw new Error(`Upstream HTTP ${res.status}`);
+    const ctype = String(res.headers.get("content-type") || "").toLowerCase();
+    if (ctype.includes("octet-stream") || ctype.includes("zip") || ctype.includes("pdf")) {
+      throw new Error(`Refusing binary content (${ctype || "unknown type"})`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.byteLength > maxBytes) throw new Error(`Content too large (${buf.byteLength} bytes)`);
+    let text = buf.toString("utf8");
+    if (ctype.includes("html")) text = htmlToText(text);
+    text = text.replace(/\r\n/g, "\n").trim();
+    if (!text) throw new Error("Fetched content was empty");
+    return truncate(text, maxChars);
+  }
+}
+
+export function webTools() {
+  return [
+    {
+      name: "web_search",
+      description: "Search the web and get top results with titles, URLs, and snippets. Use for documentation, APIs, and up-to-date facts about Roblox, Luau, or anything else.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "The search query" },
+          max_results: { type: "integer", description: "1-10. Default 6." },
+        },
+        required: ["query"],
+        additionalProperties: false,
+      },
+      execute: async (args, ctx) => webSearch(ctx.cfg, args.query, Math.min(Math.max(1, Number(args.max_results) || 6), 10)),
+    },
+    {
+      name: "url_fetch",
+      description: "Fetch a URL and return its content as text (HTML is converted to plain text). Use to read documentation pages or JSON APIs.",
+      inputSchema: {
+        type: "object",
+        properties: { url: { type: "string", description: "Absolute http(s) URL" } },
+        required: ["url"],
+        additionalProperties: false,
+      },
+      execute: async (args) => fetchUrl(args.url),
+    },
+  ];
+}

package/src/tui/ansi.js

@@ -0,0 +1,41 @@
+// Minimal ANSI helpers.
+// Color can be disabled with --no-color, ROFORGE_NO_COLOR=1, or the standard
+// NO_COLOR env var (checked at call time so flags work even after import).
+function colorEnabled() {
+  if (process.env.NO_COLOR || process.env.ROFORGE_NO_COLOR) return false;
+  if (process.argv.includes("--no-color")) return false;
+  return true;
+}
+const c = (n) => (s) => (colorEnabled() ? `\x1b[${n}m${s}\x1b[0m` : String(s));
+export const bold = c(1);
+export const dim = c(2);
+export const red = c(31);
+export const green = c(32);
+export const yellow = c(33);
+export const blue = c(34);
+export const magenta = c(35);
+export const cyan = c(36);
+export const gray = c(90);
+
+export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "", "⠼", "⠴", "", "", "⠇", "⠏"];
+
+export const CLEAR_LINE = "\x1b[2K";
+export const MOVE_UP = (n) => `\x1b[${n}A`;
+export const COLUMNS = () => (typeof process.stdout.columns === "number" ? process.stdout.columns : 80);
+
+// Wrap plain text to terminal width (word-aware).
+export function wrap(text, width) {
+  width = Math.max(20, width - 2);
+  const out = [];
+  for (const rawLine of String(text).split("\n")) {
+    let line = rawLine;
+    while (line.length > width) {
+      let cut = line.lastIndexOf(" ", width);
+      if (cut < 20) cut = width;
+      out.push(line.slice(0, cut));
+      line = line.slice(cut).replace(/^\s+/, "");
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}

package/src/tui/markdown.js

@@ -0,0 +1,67 @@
+// Lightweight streaming Markdown renderer for assistant output.
+// Renders line-by-line as lines complete (safe for token streaming), keeps
+// code-fence state across deltas, and resets cleanly per assistant segment.
+// Deliberately small: headings, bullets, numbered lists, bold, inline code,
+// fences, blockquotes, rules. Everything else passes through untouched.
+import { bold, dim, cyan, gray } from "./ansi.js";
+
+export class MarkdownStream {
+  constructor() {
+    this.buf = "";
+    this.inFence = false;
+  }
+
+  // Consume a chunk; returns the renderable output for completed lines.
+  push(delta) {
+    this.buf += String(delta ?? "");
+    let out = "";
+    let idx;
+    while ((idx = this.buf.indexOf("\n")) !== -1) {
+      const line = this.buf.slice(0, idx);
+      this.buf = this.buf.slice(idx + 1);
+      out += this._renderLine(line) + "\n";
+    }
+    return out;
+  }
+
+  // Flush the incomplete trailing line (at end of an assistant segment).
+  finish() {
+    if (!this.buf.length) return "";
+    const line = this.buf;
+    this.buf = "";
+    return this._renderLine(line) + "\n";
+  }
+
+  _renderLine(line) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      this.inFence = !this.inFence;
+      return dim("  " + line.trim());
+    }
+    if (this.inFence) {
+      return dim("  " + line);
+    }
+    return this._renderPlain(line);
+  }
+
+  _renderPlain(line) {
+    const h = line.match(/^(#{1,4})\s+(.*)$/);
+    if (h) return bold(h[1] + " " + this._inline(h[2]));
+    if (/^\s*([-*+])\s+/.test(line)) {
+      return cyan("•  ") + this._inline(line.replace(/^\s*[-*+]\s+/, ""));
+    }
+    const num = line.match(/^\s*(\d+)[.)]\s+(.*)$/);
+    if (num) return gray(num[1] + ".") + " " + this._inline(num[2]);
+    if (/^\s*>\s?/.test(line)) {
+      return dim("│ ") + dim(this._inline(line.replace(/^\s*>\s?/, "")));
+    }
+    if (/^\s*([-*_])\1{2,}\s*$/.test(line)) return dim("────────────────────────────────");
+    if (!line.trim()) return "";
+    return this._inline(line);
+  }
+
+  _inline(s) {
+    s = s.replace(/`([^`]+)`/g, (_, c) => cyan(c));
+    s = s.replace(/\*\*([^*]+)\*\*/g, (_, b) => bold(b));
+    return s;
+  }
+}