cerebras-cli 1.0.0

package/src/cli/cmd/auth.ts

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+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()
+  },
+})