rird 2.1.231 → 2.3.0

package/src/tool/webfetch.ts

@@ -0,0 +1,198 @@
+import z from "zod"
+import { Tool } from "./tool"
+import TurndownService from "turndown"
+import DESCRIPTION from "./webfetch.txt"
+import { Config } from "../config/config"
+import { Permission } from "../permission"
+import { checkDomain, logBlockedAttempt } from "../security"
+
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
+const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
+const MAX_TIMEOUT = 120 * 1000 // 2 minutes
+
+export const WebFetchTool = Tool.define("webfetch", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    url: z.string().describe("The URL to fetch content from"),
+    format: z
+      .enum(["text", "markdown", "html"])
+      .describe("The format to return the content in (text, markdown, or html)"),
+    timeout: z.number().describe("Optional timeout in seconds (max 120)").optional(),
+  }),
+  async execute(params, ctx) {
+    // Validate URL
+    if (!params.url.startsWith("http://") && !params.url.startsWith("https://")) {
+      throw new Error("URL must start with http:// or https://")
+    }
+
+    // Security guardrail: check for blocked domains (banking, crypto, government)
+    const domainCheck = checkDomain(params.url)
+    if (domainCheck.blocked) {
+      logBlockedAttempt(domainCheck, {
+        url: params.url,
+        timestamp: new Date(),
+      })
+      throw new Error(`URL blocked by security guardrails: ${domainCheck.reason}`)
+    }
+
+    const cfg = await Config.get()
+    if (cfg.permission?.webfetch === "ask")
+      await Permission.ask({
+        type: "webfetch",
+        sessionID: ctx.sessionID,
+        messageID: ctx.messageID,
+        callID: ctx.callID,
+        title: "Fetch content from: " + params.url,
+        metadata: {
+          url: params.url,
+          format: params.format,
+          timeout: params.timeout,
+        },
+      })
+
+    const timeout = Math.min((params.timeout ?? DEFAULT_TIMEOUT / 1000) * 1000, MAX_TIMEOUT)
+
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeout)
+
+    // Build Accept header based on requested format with q parameters for fallbacks
+    let acceptHeader = "*/*"
+    switch (params.format) {
+      case "markdown":
+        acceptHeader = "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1"
+        break
+      case "text":
+        acceptHeader = "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1"
+        break
+      case "html":
+        acceptHeader = "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1"
+        break
+      default:
+        acceptHeader =
+          "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8"
+    }
+
+    const response = await fetch(params.url, {
+      signal: AbortSignal.any([controller.signal, ctx.abort]),
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        Accept: acceptHeader,
+        "Accept-Language": "en-US,en;q=0.9",
+      },
+    })
+
+    clearTimeout(timeoutId)
+
+    if (!response.ok) {
+      throw new Error(`Request failed with status code: ${response.status}`)
+    }
+
+    // Check content length
+    const contentLength = response.headers.get("content-length")
+    if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
+      throw new Error("Response too large (exceeds 5MB limit)")
+    }
+
+    const arrayBuffer = await response.arrayBuffer()
+    if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
+      throw new Error("Response too large (exceeds 5MB limit)")
+    }
+
+    const content = new TextDecoder().decode(arrayBuffer)
+    const contentType = response.headers.get("content-type") || ""
+
+    const title = `RIRD Web Fetch: ${params.url} (${contentType})`
+
+    // Handle content based on requested format and actual content type
+    switch (params.format) {
+      case "markdown":
+        if (contentType.includes("text/html")) {
+          const markdown = convertHTMLToMarkdown(content)
+          return {
+            output: markdown,
+            title,
+            metadata: {},
+          }
+        }
+        return {
+          output: content,
+          title,
+          metadata: {},
+        }
+
+      case "text":
+        if (contentType.includes("text/html")) {
+          const text = await extractTextFromHTML(content)
+          return {
+            output: text,
+            title,
+            metadata: {},
+          }
+        }
+        return {
+          output: content,
+          title,
+          metadata: {},
+        }
+
+      case "html":
+        return {
+          output: content,
+          title,
+          metadata: {},
+        }
+
+      default:
+        return {
+          output: content,
+          title,
+          metadata: {},
+        }
+    }
+  },
+})
+
+async function extractTextFromHTML(html: string) {
+  let text = ""
+  let skipContent = false
+
+  const rewriter = new HTMLRewriter()
+    .on("script, style, noscript, iframe, object, embed", {
+      element() {
+        skipContent = true
+      },
+      text() {
+        // Skip text content inside these elements
+      },
+    })
+    .on("*", {
+      element(element) {
+        // Reset skip flag when entering other elements
+        if (!["script", "style", "noscript", "iframe", "object", "embed"].includes(element.tagName)) {
+          skipContent = false
+        }
+      },
+      text(input) {
+        if (!skipContent) {
+          text += input.text
+        }
+      },
+    })
+    .transform(new Response(html))
+
+  await rewriter.text()
+  return text.trim()
+}
+
+function convertHTMLToMarkdown(html: string): string {
+  const turndownService = new TurndownService({
+    headingStyle: "atx",
+    hr: "---",
+    bulletListMarker: "-",
+    codeBlockStyle: "fenced",
+    emDelimiter: "*",
+  })
+  turndownService.remove(["script", "style", "meta", "link"])
+  return turndownService.turndown(html)
+}

package/src/tool/webfetch.txt

@@ -0,0 +1,13 @@
+- Fetches content from a specified URL
+- Takes a URL and a prompt as input
+- Fetches the URL content, converts HTML to markdown
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large

package/src/tool/websearch.ts

@@ -0,0 +1,268 @@
+import z from "zod"
+import { Tool } from "./tool"
+import DESCRIPTION from "./websearch.txt"
+import { Config } from "../config/config"
+import { Permission } from "../permission"
+
+const API_CONFIG = {
+  BASE_URL: process.env.RIRD_API?.trim() || "https://rird.ai",
+  ENDPOINTS: {
+    SEARCH: "/api/search",
+  },
+  DEFAULT_NUM_RESULTS: 10,
+} as const
+
+function getLicenseKey(): string | null {
+  return process.env.RIRD_API_KEY || null
+}
+
+interface SearchResult {
+  title: string
+  url: string
+  publishedDate?: string
+  author?: string
+  score?: number
+  id: string
+  text?: string
+  highlights?: string[]
+  highlightScores?: number[]
+  summary?: string
+}
+
+interface SearchResponse {
+  requestId: string
+  autopromptString?: string
+  results: SearchResult[]
+}
+
+type WebSearchMetadata = {
+  source: string
+  error?: string
+  resultCount?: number
+  requestId?: string
+}
+
+const WebSearchParameters = z.object({
+  query: z.string().describe("RIRD Web search query"),
+  numResults: z.number().optional().describe("Number of search results to return (default: 10)"),
+  type: z
+    .enum(["neural", "keyword", "auto"])
+    .optional()
+    .describe("Search type - 'neural': semantic search (default), 'keyword': traditional keyword matching, 'auto': automatic selection"),
+  category: z
+    .enum(["company", "research paper", "news", "github", "tweet", "movie", "song", "personal site", "pdf"])
+    .optional()
+    .describe("Filter results to specific content category"),
+  includeDomains: z
+    .array(z.string())
+    .optional()
+    .describe("Only include results from these domains (e.g., ['github.com', 'stackoverflow.com'])"),
+  excludeDomains: z
+    .array(z.string())
+    .optional()
+    .describe("Exclude results from these domains"),
+  startPublishedDate: z
+    .string()
+    .optional()
+    .describe("Only include results published after this date (ISO format: YYYY-MM-DD)"),
+  endPublishedDate: z
+    .string()
+    .optional()
+    .describe("Only include results published before this date (ISO format: YYYY-MM-DD)"),
+  useAutoprompt: z
+    .boolean()
+    .optional()
+    .describe("Let RIRD Web enhance your query for better results (default: true)"),
+  contents: z
+    .object({
+      text: z.boolean().optional().describe("Include full text content"),
+      highlights: z.boolean().optional().describe("Include relevant highlights"),
+      summary: z.boolean().optional().describe("Include AI-generated summary"),
+    })
+    .optional()
+    .describe("Content extraction options"),
+})
+
+export const WebSearchTool = Tool.define("web_search_rird", {
+  description: DESCRIPTION,
+  parameters: WebSearchParameters,
+  async execute(params, ctx) {
+    const licenseKey = getLicenseKey()
+
+    const cfg = await Config.get()
+    if (cfg.permission?.webfetch === "ask")
+      await Permission.ask({
+        type: "web_search_rird",
+        sessionID: ctx.sessionID,
+        messageID: ctx.messageID,
+        callID: ctx.callID,
+        title: "RIRD Web Search: " + params.query,
+        metadata: {
+          query: params.query,
+          numResults: params.numResults,
+          type: params.type,
+          category: params.category,
+        },
+      })
+
+    const requestBody: Record<string, unknown> = {
+      query: params.query,
+      numResults: params.numResults || API_CONFIG.DEFAULT_NUM_RESULTS,
+      type: params.type || "neural",
+      useAutoprompt: params.useAutoprompt !== false,
+    }
+
+    if (params.category) {
+      requestBody.category = params.category
+    }
+    if (params.includeDomains && params.includeDomains.length > 0) {
+      requestBody.includeDomains = params.includeDomains
+    }
+    if (params.excludeDomains && params.excludeDomains.length > 0) {
+      requestBody.excludeDomains = params.excludeDomains
+    }
+    if (params.startPublishedDate) {
+      requestBody.startPublishedDate = params.startPublishedDate
+    }
+    if (params.endPublishedDate) {
+      requestBody.endPublishedDate = params.endPublishedDate
+    }
+
+    // Content extraction options
+    if (params.contents) {
+      const contentsConfig: Record<string, unknown> = {}
+      if (params.contents.text) {
+        contentsConfig.text = { maxCharacters: 10000 }
+      }
+      if (params.contents.highlights) {
+        contentsConfig.highlights = { numSentences: 3, highlightsPerUrl: 3 }
+      }
+      if (params.contents.summary) {
+        contentsConfig.summary = { query: params.query }
+      }
+      if (Object.keys(contentsConfig).length > 0) {
+        requestBody.contents = contentsConfig
+      }
+    }
+
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), 30000)
+
+    try {
+      const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(licenseKey ? { Authorization: `Bearer ${licenseKey}` } : {}),
+        },
+        body: JSON.stringify(requestBody),
+        signal: AbortSignal.any([controller.signal, ctx.abort]),
+      })
+
+      clearTimeout(timeoutId)
+
+      if (!response.ok) {
+        const errorText = await response.text()
+
+        if (response.status === 401 || response.status === 403) {
+          return {
+            output: `RIRD Web Search: Unauthorized. Please run \`rird activate\` with a valid license key.
+
+Query was: "${params.query}"`,
+            title: `RIRD Web: ${params.query}`,
+            metadata: { source: "rird-web", error: "auth_failed" } as WebSearchMetadata,
+          }
+        }
+
+        if (response.status === 429) {
+          return {
+            output: `RIRD Web Search: Rate limit exceeded. Please wait a moment and try again.
+
+Query was: "${params.query}"`,
+            title: `RIRD Web: ${params.query}`,
+            metadata: { source: "rird-web", error: "rate_limited" } as WebSearchMetadata,
+          }
+        }
+
+        throw new Error(`RIRD Web error (${response.status}): ${errorText}`)
+      }
+
+      const data: SearchResponse = await response.json()
+
+      if (!data.results || data.results.length === 0) {
+        return {
+          output: `No results found for "${params.query}". Try a different search query or broaden your filters.`,
+          title: `RIRD Web: ${params.query}`,
+          metadata: { source: "rird-web", resultCount: 0 } as WebSearchMetadata,
+        }
+      }
+
+      // Format results
+      const formattedResults = data.results.map((result, index) => {
+        let output = `## ${index + 1}. ${result.title}\n`
+        output += `**URL:** ${result.url}\n`
+
+        if (result.publishedDate) {
+          output += `**Published:** ${result.publishedDate}\n`
+        }
+        if (result.author) {
+          output += `**Author:** ${result.author}\n`
+        }
+        if (result.score) {
+          output += `**Relevance:** ${(result.score * 100).toFixed(1)}%\n`
+        }
+
+        output += "\n"
+
+        if (result.summary) {
+          output += `**Summary:** ${result.summary}\n\n`
+        }
+
+        if (result.highlights && result.highlights.length > 0) {
+          output += "**Key excerpts:**\n"
+          result.highlights.forEach(highlight => {
+            output += `> ${highlight}\n`
+          })
+          output += "\n"
+        }
+
+        if (result.text) {
+          const truncatedText = result.text.length > 500
+            ? result.text.substring(0, 500) + "..."
+            : result.text
+          output += `**Content preview:**\n${truncatedText}\n`
+        }
+
+        return output
+      }).join("\n---\n\n")
+
+      const header = data.autopromptString
+        ? `*Enhanced query: "${data.autopromptString}"*\n\n`
+        : ""
+
+      return {
+        output: `${header}Found ${data.results.length} results for "${params.query}":\n\n${formattedResults}`,
+        title: `RIRD Web: ${params.query}`,
+        metadata: {
+          source: "rird-web",
+          resultCount: data.results.length,
+          requestId: data.requestId,
+        } as WebSearchMetadata,
+      }
+    } catch (error) {
+      clearTimeout(timeoutId)
+
+      if (error instanceof Error && error.name === "AbortError") {
+        return {
+          output: `RIRD Web Search timed out. The query may be too complex or the service is temporarily slow.
+
+Query was: "${params.query}"`,
+          title: `RIRD Web: ${params.query}`,
+          metadata: { source: "rird-web", error: "timeout" } as WebSearchMetadata,
+        }
+      }
+
+      throw error
+    }
+  },
+})

package/src/tool/websearch.txt

@@ -0,0 +1,13 @@
+- RIRD Web Search - AI-powered semantic web search with real-time content retrieval
+- Uses neural search technology for understanding meaning, not just keywords
+- Provides up-to-date information for current events and recent data
+- Supports content extraction: full text, key highlights, and AI summaries
+- Use this tool for accessing information beyond knowledge cutoff
+
+Usage notes:
+  - Search types: 'neural' (semantic understanding - default), 'keyword' (traditional matching), 'auto' (automatic selection)
+  - Category filtering: company, research paper, news, github, tweet, movie, song, personal site, pdf
+  - Domain filtering: includeDomains/excludeDomains to focus or exclude specific sites
+  - Date filtering: startPublishedDate/endPublishedDate for time-bounded searches
+  - Content extraction: Enable text, highlights, or summary for richer results
+  - Autoprompt: Automatically enhances queries for better results (enabled by default)

package/src/tool/write.ts

@@ -0,0 +1,110 @@
+import z from "zod"
+import * as path from "path"
+import { Tool } from "./tool"
+import { LSP } from "../lsp"
+import { Permission } from "../permission"
+import DESCRIPTION from "./write.txt"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { FileTime } from "../file/time"
+import { Filesystem } from "../util/filesystem"
+import { Instance } from "../project/instance"
+import { Agent } from "../agent/agent"
+
+const MAX_DIAGNOSTICS_PER_FILE = 20
+const MAX_PROJECT_DIAGNOSTICS_FILES = 5
+
+export const WriteTool = Tool.define("write", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    content: z.string().describe("The content to write to the file"),
+    filePath: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+  }),
+  async execute(params, ctx) {
+    const agent = await Agent.get(ctx.agent)
+
+    const filepath = path.isAbsolute(params.filePath) ? params.filePath : path.join(Instance.directory, params.filePath)
+    if (!Filesystem.contains(Instance.directory, filepath)) {
+      const parentDir = path.dirname(filepath)
+      if (agent.permission.external_directory === "ask") {
+        await Permission.ask({
+          type: "external_directory",
+          pattern: [parentDir, path.join(parentDir, "*")],
+          sessionID: ctx.sessionID,
+          messageID: ctx.messageID,
+          callID: ctx.callID,
+          title: `Write file outside working directory: ${filepath}`,
+          metadata: {
+            filepath,
+            parentDir,
+          },
+        })
+      } else if (agent.permission.external_directory === "deny") {
+        throw new Permission.RejectedError(
+          ctx.sessionID,
+          "external_directory",
+          ctx.callID,
+          {
+            filepath: filepath,
+            parentDir,
+          },
+          `File ${filepath} is not in the current working directory`,
+        )
+      }
+    }
+
+    const file = Bun.file(filepath)
+    const exists = await file.exists()
+    if (exists) await FileTime.assert(ctx.sessionID, filepath)
+
+    if (agent.permission.edit === "ask")
+      await Permission.ask({
+        type: "write",
+        sessionID: ctx.sessionID,
+        messageID: ctx.messageID,
+        callID: ctx.callID,
+        title: exists ? "Overwrite this file: " + filepath : "Create new file: " + filepath,
+        metadata: {
+          filePath: filepath,
+          content: params.content,
+          exists,
+        },
+      })
+
+    await Bun.write(filepath, params.content)
+    await Bus.publish(File.Event.Edited, {
+      file: filepath,
+    })
+    FileTime.read(ctx.sessionID, filepath)
+
+    let output = ""
+    await LSP.touchFile(filepath, true)
+    const diagnostics = await LSP.diagnostics()
+    const normalizedFilepath = Filesystem.normalizePath(filepath)
+    let projectDiagnosticsCount = 0
+    for (const [file, issues] of Object.entries(diagnostics)) {
+      if (issues.length === 0) continue
+      const sorted = issues.toSorted((a, b) => (a.severity ?? 4) - (b.severity ?? 4))
+      const limited = sorted.slice(0, MAX_DIAGNOSTICS_PER_FILE)
+      const suffix =
+        issues.length > MAX_DIAGNOSTICS_PER_FILE ? `\n... and ${issues.length - MAX_DIAGNOSTICS_PER_FILE} more` : ""
+      if (file === normalizedFilepath) {
+        output += `\nThis file has errors, please fix\n<file_diagnostics>\n${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}\n</file_diagnostics>\n`
+        continue
+      }
+      if (projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue
+      projectDiagnosticsCount++
+      output += `\n<project_diagnostics>\n${file}\n${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}\n</project_diagnostics>\n`
+    }
+
+    return {
+      title: path.relative(Instance.worktree, filepath),
+      metadata: {
+        diagnostics,
+        filepath,
+        exists: exists,
+      },
+      output,
+    }
+  },
+})

package/src/tool/write.txt

@@ -0,0 +1,8 @@
+Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/util/archive.ts

@@ -0,0 +1,16 @@
+import { $ } from "bun"
+import path from "path"
+
+export namespace Archive {
+  export async function extractZip(zipPath: string, destDir: string) {
+    if (process.platform === "win32") {
+      const winZipPath = path.resolve(zipPath)
+      const winDestDir = path.resolve(destDir)
+      // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
+      const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
+      await $`powershell -NoProfile -NonInteractive -Command ${cmd}`.quiet()
+    } else {
+      await $`unzip -o -q ${zipPath} -d ${destDir}`.quiet()
+    }
+  }
+}

package/src/util/color.ts

@@ -0,0 +1,19 @@
+export namespace Color {
+  export function isValidHex(hex?: string): hex is string {
+    if (!hex) return false
+    return /^#[0-9a-fA-F]{6}$/.test(hex)
+  }
+
+  export function hexToRgb(hex: string): { r: number; g: number; b: number } {
+    const r = parseInt(hex.slice(1, 3), 16)
+    const g = parseInt(hex.slice(3, 5), 16)
+    const b = parseInt(hex.slice(5, 7), 16)
+    return { r, g, b }
+  }
+
+  export function hexToAnsiBold(hex?: string): string | undefined {
+    if (!isValidHex(hex)) return undefined
+    const { r, g, b } = hexToRgb(hex)
+    return `\x1b[38;2;${r};${g};${b}m\x1b[1m`
+  }
+}

package/src/util/context.ts

@@ -0,0 +1,25 @@
+import { AsyncLocalStorage } from "async_hooks"
+
+export namespace Context {
+  export class NotFound extends Error {
+    constructor(public override readonly name: string) {
+      super(`No context found for ${name}`)
+    }
+  }
+
+  export function create<T>(name: string) {
+    const storage = new AsyncLocalStorage<T>()
+    return {
+      use() {
+        const result = storage.getStore()
+        if (!result) {
+          throw new NotFound(name)
+        }
+        return result
+      },
+      provide<R>(value: T, fn: () => R) {
+        return storage.run(value, fn)
+      },
+    }
+  }
+}

package/src/util/defer.ts

@@ -0,0 +1,12 @@
+export function defer<T extends () => void | Promise<void>>(
+  fn: T,
+): T extends () => Promise<void> ? { [Symbol.asyncDispose]: () => Promise<void> } : { [Symbol.dispose]: () => void } {
+  return {
+    [Symbol.dispose]() {
+      fn()
+    },
+    [Symbol.asyncDispose]() {
+      return Promise.resolve(fn())
+    },
+  } as any
+}