cerebras-cli 1.0.1 → 1.0.4

package/src/cli/cmd/auth.ts

@@ -1,369 +0,0 @@
-import { Auth } from "../../auth"
-import { cmd } from "./cmd"
-import * as prompts from "@clack/prompts"
-import { UI } from "../ui"
-import { ModelsDev } from "../../provider/models"
-import { map, pipe, sortBy, values } from "remeda"
-import path from "path"
-import os from "os"
-import { Config } from "../../config/config"
-import { Global } from "../../global"
-import { Plugin } from "../../plugin"
-import { Instance } from "../../project/instance"
-
-export const AuthCommand = cmd({
-  command: "auth",
-  describe: "manage credentials",
-  builder: (yargs) =>
-    yargs.command(AuthLoginCommand).command(AuthLogoutCommand).command(AuthListCommand).demandCommand(),
-  async handler() {},
-})
-
-export const AuthListCommand = cmd({
-  command: "list",
-  aliases: ["ls"],
-  describe: "list providers",
-  async handler() {
-    UI.empty()
-    const authPath = path.join(Global.Path.data, "auth.json")
-    const homedir = os.homedir()
-    const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
-    prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
-    const results = Object.entries(await Auth.all())
-    const database = await ModelsDev.get()
-
-    for (const [providerID, result] of results) {
-      const name = database[providerID]?.name || providerID
-      prompts.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
-    }
-
-    prompts.outro(`${results.length} credentials`)
-
-    // Environment variables section
-    const activeEnvVars: Array<{ provider: string; envVar: string }> = []
-
-    for (const [providerID, provider] of Object.entries(database)) {
-      for (const envVar of provider.env) {
-        if (process.env[envVar]) {
-          activeEnvVars.push({
-            provider: provider.name || providerID,
-            envVar,
-          })
-        }
-      }
-    }
-
-    if (activeEnvVars.length > 0) {
-      UI.empty()
-      prompts.intro("Environment")
-
-      for (const { provider, envVar } of activeEnvVars) {
-        prompts.log.info(`${provider} ${UI.Style.TEXT_DIM}${envVar}`)
-      }
-
-      prompts.outro(`${activeEnvVars.length} environment variable` + (activeEnvVars.length === 1 ? "" : "s"))
-    }
-  },
-})
-
-export const AuthLoginCommand = cmd({
-  command: "login [url]",
-  describe: "log in to a provider",
-  builder: (yargs) =>
-    yargs.positional("url", {
-      describe: "opencode auth provider",
-      type: "string",
-    }),
-  async handler(args) {
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        UI.empty()
-        prompts.intro("Add credential")
-        if (args.url) {
-          const wellknown = await fetch(`${args.url}/.well-known/opencode`).then((x) => x.json() as any)
-          prompts.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
-          const proc = Bun.spawn({
-            cmd: wellknown.auth.command,
-            stdout: "pipe",
-          })
-          const exit = await proc.exited
-          if (exit !== 0) {
-            prompts.log.error("Failed")
-            prompts.outro("Done")
-            return
-          }
-          const token = await new Response(proc.stdout).text()
-          await Auth.set(args.url, {
-            type: "wellknown",
-            key: wellknown.auth.env,
-            token: token.trim(),
-          })
-          prompts.log.success("Logged into " + args.url)
-          prompts.outro("Done")
-          return
-        }
-        await ModelsDev.refresh().catch(() => {})
-
-        const config = await Config.get()
-
-        const disabled = new Set(config.disabled_providers ?? [])
-        const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
-
-        const providers = await ModelsDev.get().then((x) => {
-          const filtered: Record<string, (typeof x)[string]> = {}
-          for (const [key, value] of Object.entries(x)) {
-            if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
-              filtered[key] = value
-            }
-          }
-          return filtered
-        })
-
-        const priority: Record<string, number> = {
-          opencode: 0,
-          anthropic: 1,
-          "github-copilot": 2,
-          openai: 3,
-          google: 4,
-          openrouter: 5,
-          vercel: 6,
-        }
-        let provider = await prompts.autocomplete({
-          message: "Select provider",
-          maxItems: 8,
-          options: [
-            ...pipe(
-              providers,
-              values(),
-              sortBy(
-                (x) => priority[x.id] ?? 99,
-                (x) => x.name ?? x.id,
-              ),
-              map((x) => ({
-                label: x.name,
-                value: x.id,
-                hint: {
-                  opencode: "recommended",
-                  anthropic: "Claude Max or API key",
-                }[x.id],
-              })),
-            ),
-            {
-              value: "other",
-              label: "Other",
-            },
-          ],
-        })
-
-        if (prompts.isCancel(provider)) throw new UI.CancelledError()
-
-        const plugin = await Plugin.list().then((x) => x.find((x) => x.auth?.provider === provider))
-        if (plugin && plugin.auth) {
-          let index = 0
-          if (plugin.auth.methods.length > 1) {
-            const method = await prompts.select({
-              message: "Login method",
-              options: [
-                ...plugin.auth.methods.map((x, index) => ({
-                  label: x.label,
-                  value: index.toString(),
-                })),
-              ],
-            })
-            if (prompts.isCancel(method)) throw new UI.CancelledError()
-            index = parseInt(method)
-          }
-          const method = plugin.auth.methods[index]
-
-          // Handle prompts for all auth types
-          await new Promise((resolve) => setTimeout(resolve, 10))
-          const inputs: Record<string, string> = {}
-          if (method.prompts) {
-            for (const prompt of method.prompts) {
-              if (prompt.condition && !prompt.condition(inputs)) {
-                continue
-              }
-              if (prompt.type === "select") {
-                const value = await prompts.select({
-                  message: prompt.message,
-                  options: prompt.options,
-                })
-                if (prompts.isCancel(value)) throw new UI.CancelledError()
-                inputs[prompt.key] = value
-              } else {
-                const value = await prompts.text({
-                  message: prompt.message,
-                  placeholder: prompt.placeholder,
-                  validate: prompt.validate ? (v) => prompt.validate!(v ?? "") : undefined,
-                })
-                if (prompts.isCancel(value)) throw new UI.CancelledError()
-                inputs[prompt.key] = value
-              }
-            }
-          }
-
-          if (method.type === "oauth") {
-            const authorize = await method.authorize(inputs)
-
-            if (authorize.url) {
-              prompts.log.info("Go to: " + authorize.url)
-            }
-
-            if (authorize.method === "auto") {
-              if (authorize.instructions) {
-                prompts.log.info(authorize.instructions)
-              }
-              const spinner = prompts.spinner()
-              spinner.start("Waiting for authorization...")
-              const result = await authorize.callback()
-              if (result.type === "failed") {
-                spinner.stop("Failed to authorize", 1)
-              }
-              if (result.type === "success") {
-                const saveProvider = result.provider ?? provider
-                if ("refresh" in result) {
-                  const { type: _, provider: __, refresh, access, expires, ...extraFields } = result
-                  await Auth.set(saveProvider, {
-                    type: "oauth",
-                    refresh,
-                    access,
-                    expires,
-                    ...extraFields,
-                  })
-                }
-                if ("key" in result) {
-                  await Auth.set(saveProvider, {
-                    type: "api",
-                    key: result.key,
-                  })
-                }
-                spinner.stop("Login successful")
-              }
-            }
-
-            if (authorize.method === "code") {
-              const code = await prompts.text({
-                message: "Paste the authorization code here: ",
-                validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-              })
-              if (prompts.isCancel(code)) throw new UI.CancelledError()
-              const result = await authorize.callback(code)
-              if (result.type === "failed") {
-                prompts.log.error("Failed to authorize")
-              }
-              if (result.type === "success") {
-                const saveProvider = result.provider ?? provider
-                if ("refresh" in result) {
-                  const { type: _, provider: __, refresh, access, expires, ...extraFields } = result
-                  await Auth.set(saveProvider, {
-                    type: "oauth",
-                    refresh,
-                    access,
-                    expires,
-                    ...extraFields,
-                  })
-                }
-                if ("key" in result) {
-                  await Auth.set(saveProvider, {
-                    type: "api",
-                    key: result.key,
-                  })
-                }
-                prompts.log.success("Login successful")
-              }
-            }
-
-            prompts.outro("Done")
-            return
-          }
-
-          if (method.type === "api") {
-            if (method.authorize) {
-              const result = await method.authorize(inputs)
-              if (result.type === "failed") {
-                prompts.log.error("Failed to authorize")
-              }
-              if (result.type === "success") {
-                const saveProvider = result.provider ?? provider
-                await Auth.set(saveProvider, {
-                  type: "api",
-                  key: result.key,
-                })
-                prompts.log.success("Login successful")
-              }
-              prompts.outro("Done")
-              return
-            }
-          }
-        }
-
-        if (provider === "other") {
-          provider = await prompts.text({
-            message: "Enter provider id",
-            validate: (x) => (x && x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
-          })
-          if (prompts.isCancel(provider)) throw new UI.CancelledError()
-          provider = provider.replace(/^@ai-sdk\//, "")
-          if (prompts.isCancel(provider)) throw new UI.CancelledError()
-          prompts.log.warn(
-            `This only stores a credential for ${provider} - you will need configure it in opencode.json, check the docs for examples.`,
-          )
-        }
-
-        if (provider === "amazon-bedrock") {
-          prompts.log.info(
-            "Amazon bedrock can be configured with standard AWS environment variables like AWS_BEARER_TOKEN_BEDROCK, AWS_PROFILE or AWS_ACCESS_KEY_ID",
-          )
-          prompts.outro("Done")
-          return
-        }
-
-        if (provider === "opencode") {
-          prompts.log.info("Create an api key at https://opencode.ai/auth")
-        }
-
-        if (provider === "vercel") {
-          prompts.log.info("You can create an api key at https://vercel.link/ai-gateway-token")
-        }
-
-        const key = await prompts.password({
-          message: "Enter your API key",
-          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-        })
-        if (prompts.isCancel(key)) throw new UI.CancelledError()
-        await Auth.set(provider, {
-          type: "api",
-          key,
-        })
-
-        prompts.outro("Done")
-      },
-    })
-  },
-})
-
-export const AuthLogoutCommand = cmd({
-  command: "logout",
-  describe: "log out from a configured provider",
-  async handler() {
-    UI.empty()
-    const credentials = await Auth.all().then((x) => Object.entries(x))
-    prompts.intro("Remove credential")
-    if (credentials.length === 0) {
-      prompts.log.error("No credentials found")
-      return
-    }
-    const database = await ModelsDev.get()
-    const providerID = await prompts.select({
-      message: "Select provider",
-      options: credentials.map(([key, value]) => ({
-        label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")",
-        value: key,
-      })),
-    })
-    if (prompts.isCancel(providerID)) throw new UI.CancelledError()
-    await Auth.remove(providerID)
-    prompts.outro("Logout successful")
-  },
-})

package/src/cli/cmd/cmd.ts

@@ -1,7 +0,0 @@
-import type { CommandModule } from "yargs"
-
-type WithDoubleDash<T> = T & { "--"?: string[] }
-
-export function cmd<T, U>(input: CommandModule<T, WithDoubleDash<U>>) {
-  return input
-}

package/src/cli/cmd/debug/config.ts

@@ -1,15 +0,0 @@
-import { EOL } from "os"
-import { Config } from "../../../config/config"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-
-export const ConfigCommand = cmd({
-  command: "config",
-  builder: (yargs) => yargs,
-  async handler() {
-    await bootstrap(process.cwd(), async () => {
-      const config = await Config.get()
-      process.stdout.write(JSON.stringify(config, null, 2) + EOL)
-    })
-  },
-})

package/src/cli/cmd/debug/file.ts

@@ -1,91 +0,0 @@
-import { EOL } from "os"
-import { File } from "../../../file"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-import { Ripgrep } from "@/file/ripgrep"
-
-const FileSearchCommand = cmd({
-  command: "search <query>",
-  builder: (yargs) =>
-    yargs.positional("query", {
-      type: "string",
-      demandOption: true,
-      description: "Search query",
-    }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      const results = await File.search({ query: args.query })
-      process.stdout.write(results.join(EOL) + EOL)
-    })
-  },
-})
-
-const FileReadCommand = cmd({
-  command: "read <path>",
-  builder: (yargs) =>
-    yargs.positional("path", {
-      type: "string",
-      demandOption: true,
-      description: "File path to read",
-    }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      const content = await File.read(args.path)
-      process.stdout.write(JSON.stringify(content, null, 2) + EOL)
-    })
-  },
-})
-
-const FileStatusCommand = cmd({
-  command: "status",
-  builder: (yargs) => yargs,
-  async handler() {
-    await bootstrap(process.cwd(), async () => {
-      const status = await File.status()
-      process.stdout.write(JSON.stringify(status, null, 2) + EOL)
-    })
-  },
-})
-
-const FileListCommand = cmd({
-  command: "list <path>",
-  builder: (yargs) =>
-    yargs.positional("path", {
-      type: "string",
-      demandOption: true,
-      description: "File path to list",
-    }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      const files = await File.list(args.path)
-      process.stdout.write(JSON.stringify(files, null, 2) + EOL)
-    })
-  },
-})
-
-const FileTreeCommand = cmd({
-  command: "tree [dir]",
-  builder: (yargs) =>
-    yargs.positional("dir", {
-      type: "string",
-      description: "Directory to tree",
-      default: process.cwd(),
-    }),
-  async handler(args) {
-    const files = await Ripgrep.tree({ cwd: args.dir, limit: 200 })
-    console.log(files)
-  },
-})
-
-export const FileCommand = cmd({
-  command: "file",
-  builder: (yargs) =>
-    yargs
-      .command(FileReadCommand)
-      .command(FileStatusCommand)
-      .command(FileListCommand)
-      .command(FileSearchCommand)
-      .command(FileTreeCommand)
-      .demandCommand(),
-  async handler() {},
-})

package/src/cli/cmd/debug/index.ts

@@ -1,41 +0,0 @@
-import { Global } from "../../../global"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-import { ConfigCommand } from "./config"
-import { FileCommand } from "./file"
-import { LSPCommand } from "./lsp"
-import { RipgrepCommand } from "./ripgrep"
-import { ScrapCommand } from "./scrap"
-import { SnapshotCommand } from "./snapshot"
-
-export const DebugCommand = cmd({
-  command: "debug",
-  builder: (yargs) =>
-    yargs
-      .command(ConfigCommand)
-      .command(LSPCommand)
-      .command(RipgrepCommand)
-      .command(FileCommand)
-      .command(ScrapCommand)
-      .command(SnapshotCommand)
-      .command(PathsCommand)
-      .command({
-        command: "wait",
-        async handler() {
-          await bootstrap(process.cwd(), async () => {
-            await new Promise((resolve) => setTimeout(resolve, 1_000 * 60 * 60 * 24))
-          })
-        },
-      })
-      .demandCommand(),
-  async handler() {},
-})
-
-const PathsCommand = cmd({
-  command: "paths",
-  handler() {
-    for (const [key, value] of Object.entries(Global.Path)) {
-      console.log(key.padEnd(10), value)
-    }
-  },
-})

package/src/cli/cmd/debug/lsp.ts

@@ -1,47 +0,0 @@
-import { LSP } from "../../../lsp"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-import { Log } from "../../../util/log"
-import { EOL } from "os"
-
-export const LSPCommand = cmd({
-  command: "lsp",
-  builder: (yargs) =>
-    yargs.command(DiagnosticsCommand).command(SymbolsCommand).command(DocumentSymbolsCommand).demandCommand(),
-  async handler() {},
-})
-
-const DiagnosticsCommand = cmd({
-  command: "diagnostics <file>",
-  builder: (yargs) => yargs.positional("file", { type: "string", demandOption: true }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      await LSP.touchFile(args.file, true)
-      process.stdout.write(JSON.stringify(await LSP.diagnostics(), null, 2) + EOL)
-    })
-  },
-})
-
-export const SymbolsCommand = cmd({
-  command: "symbols <query>",
-  builder: (yargs) => yargs.positional("query", { type: "string", demandOption: true }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      using _ = Log.Default.time("symbols")
-      const results = await LSP.workspaceSymbol(args.query)
-      process.stdout.write(JSON.stringify(results, null, 2) + EOL)
-    })
-  },
-})
-
-export const DocumentSymbolsCommand = cmd({
-  command: "document-symbols <uri>",
-  builder: (yargs) => yargs.positional("uri", { type: "string", demandOption: true }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      using _ = Log.Default.time("document-symbols")
-      const results = await LSP.documentSymbol(args.uri)
-      process.stdout.write(JSON.stringify(results, null, 2) + EOL)
-    })
-  },
-})

package/src/cli/cmd/debug/ripgrep.ts

@@ -1,83 +0,0 @@
-import { EOL } from "os"
-import { Ripgrep } from "../../../file/ripgrep"
-import { Instance } from "../../../project/instance"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-
-export const RipgrepCommand = cmd({
-  command: "rg",
-  builder: (yargs) => yargs.command(TreeCommand).command(FilesCommand).command(SearchCommand).demandCommand(),
-  async handler() {},
-})
-
-const TreeCommand = cmd({
-  command: "tree",
-  builder: (yargs) =>
-    yargs.option("limit", {
-      type: "number",
-    }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      process.stdout.write((await Ripgrep.tree({ cwd: Instance.directory, limit: args.limit })) + EOL)
-    })
-  },
-})
-
-const FilesCommand = cmd({
-  command: "files",
-  builder: (yargs) =>
-    yargs
-      .option("query", {
-        type: "string",
-        description: "Filter files by query",
-      })
-      .option("glob", {
-        type: "string",
-        description: "Glob pattern to match files",
-      })
-      .option("limit", {
-        type: "number",
-        description: "Limit number of results",
-      }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      const files: string[] = []
-      for await (const file of Ripgrep.files({
-        cwd: Instance.directory,
-        glob: args.glob ? [args.glob] : undefined,
-      })) {
-        files.push(file)
-        if (args.limit && files.length >= args.limit) break
-      }
-      process.stdout.write(files.join(EOL) + EOL)
-    })
-  },
-})
-
-const SearchCommand = cmd({
-  command: "search <pattern>",
-  builder: (yargs) =>
-    yargs
-      .positional("pattern", {
-        type: "string",
-        demandOption: true,
-        description: "Search pattern",
-      })
-      .option("glob", {
-        type: "array",
-        description: "File glob patterns",
-      })
-      .option("limit", {
-        type: "number",
-        description: "Limit number of results",
-      }),
-  async handler(args) {
-    const results = await Ripgrep.search({
-      cwd: process.cwd(),
-      pattern: args.pattern,
-      glob: args.glob as string[] | undefined,
-      limit: args.limit,
-    })
-    process.stdout.write(JSON.stringify(results, null, 2) + EOL)
-  },
-})

package/src/cli/cmd/debug/scrap.ts

@@ -1,15 +0,0 @@
-import { EOL } from "os"
-import { Project } from "../../../project/project"
-import { Log } from "../../../util/log"
-import { cmd } from "../cmd"
-
-export const ScrapCommand = cmd({
-  command: "scrap",
-  builder: (yargs) => yargs,
-  async handler() {
-    const timer = Log.Default.time("scrap")
-    const list = await Project.list()
-    process.stdout.write(JSON.stringify(list, null, 2) + EOL)
-    timer.stop()
-  },
-})