cerebras-cli 1.0.1 → 1.0.4

package/src/tool/webfetch.txt

@@ -1,14 +0,0 @@
-- 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
-  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL

package/src/tool/websearch.ts

@@ -1,150 +0,0 @@
-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: "https://mcp.exa.ai",
-  ENDPOINTS: {
-    SEARCH: "/mcp",
-  },
-  DEFAULT_NUM_RESULTS: 8,
-} as const
-
-interface McpSearchRequest {
-  jsonrpc: string
-  id: number
-  method: string
-  params: {
-    name: string
-    arguments: {
-      query: string
-      numResults?: number
-      livecrawl?: "fallback" | "preferred"
-      type?: "auto" | "fast" | "deep"
-      contextMaxCharacters?: number
-    }
-  }
-}
-
-interface McpSearchResponse {
-  jsonrpc: string
-  result: {
-    content: Array<{
-      type: string
-      text: string
-    }>
-  }
-}
-
-export const WebSearchTool = Tool.define("websearch", {
-  description: DESCRIPTION,
-  parameters: z.object({
-    query: z.string().describe("Websearch query"),
-    numResults: z.number().optional().describe("Number of search results to return (default: 8)"),
-    livecrawl: z
-      .enum(["fallback", "preferred"])
-      .optional()
-      .describe(
-        "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
-      ),
-    type: z
-      .enum(["auto", "fast", "deep"])
-      .optional()
-      .describe("Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search"),
-    contextMaxCharacters: z
-      .number()
-      .optional()
-      .describe("Maximum characters for context string optimized for LLMs (default: 10000)"),
-  }),
-  async execute(params, ctx) {
-    const cfg = await Config.get()
-    if (cfg.permission?.webfetch === "ask")
-      await Permission.ask({
-        type: "websearch",
-        sessionID: ctx.sessionID,
-        messageID: ctx.messageID,
-        callID: ctx.callID,
-        title: "Search web for: " + params.query,
-        metadata: {
-          query: params.query,
-          numResults: params.numResults,
-          livecrawl: params.livecrawl,
-          type: params.type,
-          contextMaxCharacters: params.contextMaxCharacters,
-        },
-      })
-
-    const searchRequest: McpSearchRequest = {
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tools/call",
-      params: {
-        name: "web_search_exa",
-        arguments: {
-          query: params.query,
-          type: params.type || "auto",
-          numResults: params.numResults || API_CONFIG.DEFAULT_NUM_RESULTS,
-          livecrawl: params.livecrawl || "fallback",
-          contextMaxCharacters: params.contextMaxCharacters,
-        },
-      },
-    }
-
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), 25000)
-
-    try {
-      const headers: Record<string, string> = {
-        accept: "application/json, text/event-stream",
-        "content-type": "application/json",
-      }
-
-      const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(searchRequest),
-        signal: AbortSignal.any([controller.signal, ctx.abort]),
-      })
-
-      clearTimeout(timeoutId)
-
-      if (!response.ok) {
-        const errorText = await response.text()
-        throw new Error(`Search error (${response.status}): ${errorText}`)
-      }
-
-      const responseText = await response.text()
-
-      // Parse SSE response
-      const lines = responseText.split("\n")
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data: McpSearchResponse = JSON.parse(line.substring(6))
-          if (data.result && data.result.content && data.result.content.length > 0) {
-            return {
-              output: data.result.content[0].text,
-              title: `Web search: ${params.query}`,
-              metadata: {},
-            }
-          }
-        }
-      }
-
-      return {
-        output: "No search results found. Please try a different query.",
-        title: `Web search: ${params.query}`,
-        metadata: {},
-      }
-    } catch (error) {
-      clearTimeout(timeoutId)
-
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error("Search request timed out")
-      }
-
-      throw error
-    }
-  },
-})

package/src/tool/websearch.txt

@@ -1,11 +0,0 @@
-- Search the web using Exa AI - performs real-time web searches and can scrape content from specific URLs
-- Provides up-to-date information for current events and recent data
-- Supports configurable result counts and returns the content from the most relevant websites
-- Use this tool for accessing information beyond knowledge cutoff
-- Searches are performed automatically within a single API call
-
-Usage notes:
-  - Supports live crawling modes: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
-  - Search types: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
-  - Configurable context length for optimal LLM integration
-  - Domain filtering and advanced search options available

package/src/tool/write.ts

@@ -1,99 +0,0 @@
-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"
-
-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()
-    for (const [file, issues] of Object.entries(diagnostics)) {
-      if (issues.length === 0) continue
-      if (file === filepath) {
-        output += `\nThis file has errors, please fix\n<file_diagnostics>\n${issues.map(LSP.Diagnostic.pretty).join("\n")}\n</file_diagnostics>\n`
-        continue
-      }
-      output += `\n<project_diagnostics>\n${file}\n${issues.map(LSP.Diagnostic.pretty).join("\n")}\n</project_diagnostics>\n`
-    }
-
-    return {
-      title: path.relative(Instance.worktree, filepath),
-      metadata: {
-        diagnostics,
-        filepath,
-        exists: exists,
-      },
-      output,
-    }
-  },
-})

package/src/tool/write.txt

@@ -1,8 +0,0 @@
-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/types/shims.d.ts

@@ -1,3 +0,0 @@
-declare module "@ai-sdk/openai-compatible";
-declare module "ai";
-

package/src/util/color.ts

@@ -1,19 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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
-}

package/src/util/eventloop.ts

@@ -1,20 +0,0 @@
-import { Log } from "./log"
-
-export namespace EventLoop {
-  export async function wait() {
-    return new Promise<void>((resolve) => {
-      const check = () => {
-        const active = [...(process as any)._getActiveHandles(), ...(process as any)._getActiveRequests()]
-        Log.Default.info("eventloop", {
-          active,
-        })
-        if ((process as any)._getActiveHandles().length === 0 && (process as any)._getActiveRequests().length === 0) {
-          resolve()
-        } else {
-          setImmediate(check)
-        }
-      }
-      check()
-    })
-  }
-}

package/src/util/filesystem.ts

@@ -1,69 +0,0 @@
-import { exists } from "fs/promises"
-import { dirname, join, relative } from "path"
-
-export namespace Filesystem {
-  export function overlaps(a: string, b: string) {
-    const relA = relative(a, b)
-    const relB = relative(b, a)
-    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
-  }
-
-  export function contains(parent: string, child: string) {
-    return !relative(parent, child).startsWith("..")
-  }
-
-  export async function findUp(target: string, start: string, stop?: string) {
-    let current = start
-    const result = []
-    while (true) {
-      const search = join(current, target)
-      if (await exists(search)) result.push(search)
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-    return result
-  }
-
-  export async function* up(options: { targets: string[]; start: string; stop?: string }) {
-    const { targets, start, stop } = options
-    let current = start
-    while (true) {
-      for (const target of targets) {
-        const search = join(current, target)
-        if (await exists(search)) yield search
-      }
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-  }
-
-  export async function globUp(pattern: string, start: string, stop?: string) {
-    let current = start
-    const result = []
-    while (true) {
-      try {
-        const glob = new Bun.Glob(pattern)
-        for await (const match of glob.scan({
-          cwd: current,
-          absolute: true,
-          onlyFiles: true,
-          followSymlinks: true,
-          dot: true,
-        })) {
-          result.push(match)
-        }
-      } catch {
-        // Skip invalid glob patterns
-      }
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-    return result
-  }
-}

package/src/util/fn.ts

@@ -1,11 +0,0 @@
-import { z } from "zod"
-
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
-  const result = (input: z.infer<T>) => {
-    const parsed = schema.parse(input)
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
-}

package/src/util/iife.ts

@@ -1,3 +0,0 @@
-export function iife<T>(fn: () => T) {
-  return fn()
-}

package/src/util/keybind.ts

@@ -1,79 +0,0 @@
-import { isDeepEqual } from "remeda"
-
-export namespace Keybind {
-  export type Info = {
-    ctrl: boolean
-    meta: boolean
-    shift: boolean
-    leader: boolean
-    name: string
-  }
-
-  export function match(a: Info, b: Info): boolean {
-    return isDeepEqual(a, b)
-  }
-
-  export function toString(info: Info): string {
-    const parts: string[] = []
-
-    if (info.ctrl) parts.push("ctrl")
-    if (info.meta) parts.push("alt")
-    if (info.shift) parts.push("shift")
-    if (info.name) {
-      if (info.name === "delete") parts.push("del")
-      else parts.push(info.name)
-    }
-
-    let result = parts.join("+")
-
-    if (info.leader) {
-      result = result ? `<leader> ${result}` : `<leader>`
-    }
-
-    return result
-  }
-
-  export function parse(key: string): Info[] {
-    if (key === "none") return []
-
-    return key.split(",").map((combo) => {
-      // Handle <leader> syntax by replacing with leader+
-      const normalized = combo.replace(/<leader>/g, "leader+")
-      const parts = normalized.toLowerCase().split("+")
-      const info: Info = {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "",
-      }
-
-      for (const part of parts) {
-        switch (part) {
-          case "ctrl":
-            info.ctrl = true
-            break
-          case "alt":
-          case "meta":
-          case "option":
-            info.meta = true
-            break
-          case "shift":
-            info.shift = true
-            break
-          case "leader":
-            info.leader = true
-            break
-          case "esc":
-            info.name = "escape"
-            break
-          default:
-            info.name = part
-            break
-        }
-      }
-
-      return info
-    })
-  }
-}

package/src/util/lazy.ts

@@ -1,11 +0,0 @@
-export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
-
-  return (): T => {
-    if (loaded) return value as T
-    loaded = true
-    value = fn()
-    return value as T
-  }
-}

package/src/util/locale.ts

@@ -1,81 +0,0 @@
-export namespace Locale {
-  export function titlecase(str: string) {
-    return str.replace(/\b\w/g, (c) => c.toUpperCase())
-  }
-
-  export function time(input: number): string {
-    const date = new Date(input)
-    return date.toLocaleTimeString(undefined, { timeStyle: "short" })
-  }
-
-  export function datetime(input: number): string {
-    const date = new Date(input)
-    const localTime = time(input)
-    const localDate = date.toLocaleDateString()
-    return `${localTime} · ${localDate}`
-  }
-
-  export function todayTimeOrDateTime(input: number): string {
-    const date = new Date(input)
-    const now = new Date()
-    const isToday =
-      date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
-
-    if (isToday) {
-      return time(input)
-    } else {
-      return datetime(input)
-    }
-  }
-
-  export function number(num: number): string {
-    if (num >= 1000000) {
-      return (num / 1000000).toFixed(1) + "M"
-    } else if (num >= 1000) {
-      return (num / 1000).toFixed(1) + "K"
-    }
-    return num.toString()
-  }
-
-  export function duration(input: number) {
-    if (input < 1000) {
-      return `${input}ms`
-    }
-    if (input < 60000) {
-      return `${(input / 1000).toFixed(1)}s`
-    }
-    if (input < 3600000) {
-      const minutes = Math.floor(input / 60000)
-      const seconds = Math.floor((input % 60000) / 1000)
-      return `${minutes}m ${seconds}s`
-    }
-    if (input < 86400000) {
-      const hours = Math.floor(input / 3600000)
-      const minutes = Math.floor((input % 3600000) / 60000)
-      return `${hours}h ${minutes}m`
-    }
-    const hours = Math.floor(input / 3600000)
-    const days = Math.floor((input % 3600000) / 86400000)
-    return `${days}d ${hours}h`
-  }
-
-  export function truncate(str: string, len: number): string {
-    if (str.length <= len) return str
-    return str.slice(0, len - 1) + "…"
-  }
-
-  export function truncateMiddle(str: string, maxLength: number = 35): string {
-    if (str.length <= maxLength) return str
-
-    const ellipsis = "…"
-    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
-    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
-
-    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
-  }
-
-  export function pluralize(count: number, singular: string, plural: string): string {
-    const template = count === 1 ? singular : plural
-    return template.replace("{}", count.toString())
-  }
-}