@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/cli/cmd/models.ts

@@ -1,88 +0,0 @@
-import type { Argv } from "yargs"
-import { Instance } from "../../project/instance"
-import { Provider } from "../../provider"
-import { ProviderID } from "../../provider/schema"
-import { ModelsDev } from "../../provider"
-import { cmd } from "./cmd"
-import { UI } from "../ui"
-import { EOL } from "os"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Effect } from "effect"
-
-export const ModelsCommand = cmd({
-  command: "models [provider]",
-  describe: "list all available models",
-  builder: (yargs: Argv) => {
-    return yargs
-      .positional("provider", {
-        describe: "provider ID to filter models by",
-        type: "string",
-        array: false,
-      })
-      .option("verbose", {
-        describe: "use more verbose model output (includes metadata like costs)",
-        type: "boolean",
-      })
-      .option("refresh", {
-        describe: "refresh the models cache from models.dev",
-        type: "boolean",
-      })
-  },
-  handler: async (args) => {
-    if (args.refresh) {
-      await ModelsDev.refresh(true)
-      UI.println(UI.Style.TEXT_SUCCESS_BOLD + "Models cache refreshed" + UI.Style.TEXT_NORMAL)
-    }
-
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        await AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const svc = yield* Provider.Service
-            const providers = yield* svc.list()
-
-            const print = (providerID: ProviderID, verbose?: boolean) => {
-              const provider = providers[providerID]
-              const sorted = Object.entries(provider.models).sort(([a], [b]) => a.localeCompare(b))
-              for (const [modelID, model] of sorted) {
-                process.stdout.write(`${providerID}/${modelID}`)
-                process.stdout.write(EOL)
-                if (verbose) {
-                  process.stdout.write(JSON.stringify(model, null, 2))
-                  process.stdout.write(EOL)
-                }
-              }
-            }
-
-            if (args.provider) {
-              const providerID = ProviderID.make(args.provider)
-              const provider = providers[providerID]
-              if (!provider) {
-                yield* Effect.sync(() => UI.error(`Provider not found: ${args.provider}`))
-                return
-              }
-
-              yield* Effect.sync(() => print(providerID, args.verbose))
-              return
-            }
-
-            const ids = Object.keys(providers).sort((a, b) => {
-              const aIsOpencode = a.startsWith("opencode")
-              const bIsOpencode = b.startsWith("opencode")
-              if (aIsOpencode && !bIsOpencode) return -1
-              if (!aIsOpencode && bIsOpencode) return 1
-              return a.localeCompare(b)
-            })
-
-            yield* Effect.sync(() => {
-              for (const providerID of ids) {
-                print(ProviderID.make(providerID), args.verbose)
-              }
-            })
-          }),
-        )
-      },
-    })
-  },
-})

package/src/cli/cmd/plug.ts

@@ -1,233 +0,0 @@
-import { intro, log, outro, spinner } from "@clack/prompts"
-import type { Argv } from "yargs"
-
-import { ConfigPaths } from "../../config"
-import { Global } from "../../global"
-import { installPlugin, patchPluginConfig, readPluginManifest } from "../../plugin/install"
-import { resolvePluginTarget } from "../../plugin/shared"
-import { Instance } from "../../project/instance"
-import { errorMessage } from "../../util/error"
-import { Filesystem } from "../../util"
-import { Process } from "../../util"
-import { UI } from "../ui"
-import { cmd } from "./cmd"
-
-type Spin = {
-  start: (msg: string) => void
-  stop: (msg: string, code?: number) => void
-}
-
-export type PlugDeps = {
-  spinner: () => Spin
-  log: {
-    error: (msg: string) => void
-    info: (msg: string) => void
-    success: (msg: string) => void
-  }
-  resolve: (spec: string) => Promise<string>
-  readText: (file: string) => Promise<string>
-  write: (file: string, text: string) => Promise<void>
-  exists: (file: string) => Promise<boolean>
-  files: (dir: string, name: "sleepycode" | "tui") => string[]
-  global: string
-}
-
-export type PlugInput = {
-  mod: string
-  global?: boolean
-  force?: boolean
-}
-
-export type PlugCtx = {
-  vcs?: string
-  worktree: string
-  directory: string
-}
-
-const defaultPlugDeps: PlugDeps = {
-  spinner: () => spinner(),
-  log: {
-    error: (msg) => log.error(msg),
-    info: (msg) => log.info(msg),
-    success: (msg) => log.success(msg),
-  },
-  resolve: (spec) => resolvePluginTarget(spec),
-  readText: (file) => Filesystem.readText(file),
-  write: async (file, text) => {
-    await Filesystem.write(file, text)
-  },
-  exists: (file) => Filesystem.exists(file),
-  files: (dir, name) => ConfigPaths.fileInDirectory(dir, name),
-  global: Global.Path.config,
-}
-
-function cause(err: unknown) {
-  if (!err || typeof err !== "object") return
-  if (!("cause" in err)) return
-  return (err as { cause?: unknown }).cause
-}
-
-export function createPlugTask(input: PlugInput, dep: PlugDeps = defaultPlugDeps) {
-  const mod = input.mod
-  const force = Boolean(input.force)
-  const global = Boolean(input.global)
-
-  return async (ctx: PlugCtx) => {
-    const install = dep.spinner()
-    install.start("Installing plugin package...")
-    const target = await installPlugin(mod, dep)
-    if (!target.ok) {
-      install.stop("Install failed", 1)
-      dep.log.error(`Could not install "${mod}"`)
-      const hit = cause(target.error) ?? target.error
-      if (hit instanceof Process.RunFailedError) {
-        const lines = hit.stderr
-          .toString()
-          .split(/\r?\n/)
-          .map((line) => line.trim())
-          .filter(Boolean)
-        const errs = lines.filter((line) => line.startsWith("error:")).map((line) => line.replace(/^error:\s*/, ""))
-        const detail = errs[0] ?? lines.at(-1)
-        if (detail) dep.log.error(detail)
-        if (lines.some((line) => line.includes("No version matching"))) {
-          dep.log.info("This package depends on a version that is not available in your npm registry.")
-          dep.log.info("Check npm registry/auth settings and try again.")
-        }
-      }
-      if (!(hit instanceof Process.RunFailedError)) {
-        dep.log.error(errorMessage(hit))
-      }
-      return false
-    }
-    install.stop("Plugin package ready")
-
-    const inspect = dep.spinner()
-    inspect.start("Reading plugin manifest...")
-    const manifest = await readPluginManifest(target.target)
-    if (!manifest.ok) {
-      if (manifest.code === "manifest_read_failed") {
-        inspect.stop("Manifest read failed", 1)
-        dep.log.error(`Installed "${mod}" but failed to read ${manifest.file}`)
-        dep.log.error(errorMessage(cause(manifest.error) ?? manifest.error))
-        return false
-      }
-
-      if (manifest.code === "manifest_no_targets") {
-        inspect.stop("No plugin targets found", 1)
-        dep.log.error(`"${mod}" does not expose plugin entrypoints in package.json`)
-        dep.log.info(
-          'Expected one of: exports["./tui"], exports["./server"], package.json main for server, or package.json["oc-themes"] for tui themes.',
-        )
-        return false
-      }
-
-      inspect.stop("Manifest read failed", 1)
-      return false
-    }
-
-    inspect.stop(
-      `Detected ${manifest.targets.map((item) => item.kind).join(" + ")} target${manifest.targets.length === 1 ? "" : "s"}`,
-    )
-
-    const patch = dep.spinner()
-    patch.start("Updating plugin config...")
-    const out = await patchPluginConfig(
-      {
-        spec: mod,
-        targets: manifest.targets,
-        force,
-        global,
-        vcs: ctx.vcs,
-        worktree: ctx.worktree,
-        directory: ctx.directory,
-        config: dep.global,
-      },
-      dep,
-    )
-    if (!out.ok) {
-      if (out.code === "invalid_json") {
-        patch.stop(`Failed updating ${out.kind} config`, 1)
-        dep.log.error(`Invalid JSON in ${out.file} (${out.parse} at line ${out.line}, column ${out.col})`)
-        dep.log.info("Fix the config file and run the command again.")
-        return false
-      }
-
-      patch.stop("Failed updating plugin config", 1)
-      dep.log.error(errorMessage(out.error))
-      return false
-    }
-    patch.stop("Plugin config updated")
-    for (const item of out.items) {
-      if (item.mode === "noop") {
-        dep.log.info(`Already configured in ${item.file}`)
-        continue
-      }
-      if (item.mode === "replace") {
-        dep.log.info(`Replaced in ${item.file}`)
-        continue
-      }
-      dep.log.info(`Added to ${item.file}`)
-    }
-
-    dep.log.success(`Installed ${mod}`)
-    dep.log.info(global ? `Scope: global (${out.dir})` : `Scope: local (${out.dir})`)
-    return true
-  }
-}
-
-export const PluginCommand = cmd({
-  command: "plugin <module>",
-  aliases: ["plug"],
-  describe: "install plugin and update config",
-  builder: (yargs: Argv) => {
-    return yargs
-      .positional("module", {
-        type: "string",
-        describe: "npm module name",
-      })
-      .option("global", {
-        alias: ["g"],
-        type: "boolean",
-        default: false,
-        describe: "install in global config",
-      })
-      .option("force", {
-        alias: ["f"],
-        type: "boolean",
-        default: false,
-        describe: "replace existing plugin version",
-      })
-  },
-  handler: async (args) => {
-    const mod = String(args.module ?? "").trim()
-    if (!mod) {
-      UI.error("module is required")
-      process.exitCode = 1
-      return
-    }
-
-    UI.empty()
-    intro(`Install plugin ${mod}`)
-
-    const run = createPlugTask({
-      mod,
-      global: Boolean(args.global),
-      force: Boolean(args.force),
-    })
-    let ok = true
-
-    await Instance.provide({
-      directory: process.cwd(),
-      fn: async () => {
-        ok = await run({
-          vcs: Instance.project.vcs,
-          worktree: Instance.worktree,
-          directory: Instance.directory,
-        })
-      },
-    })
-
-    outro("Done")
-    if (!ok) process.exitCode = 1
-  },
-})

package/src/cli/cmd/pr.ts

@@ -1,138 +0,0 @@
-import { UI } from "../ui"
-import { cmd } from "./cmd"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Git } from "@/git"
-import { Instance } from "@/project/instance"
-import { Process } from "@/util"
-
-export const PrCommand = cmd({
-  command: "pr <number>",
-  describe: "fetch and checkout a GitHub PR branch, then run sleepycode",
-  builder: (yargs) =>
-    yargs.positional("number", {
-      type: "number",
-      describe: "PR number to checkout",
-      demandOption: true,
-    }),
-  async handler(args) {
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        const project = Instance.project
-        if (project.vcs !== "git") {
-          UI.error("Could not find git repository. Please run this command from a git repository.")
-          process.exit(1)
-        }
-
-        const prNumber = args.number
-        const localBranchName = `pr/${prNumber}`
-        UI.println(`Fetching and checking out PR #${prNumber}...`)
-
-        // Use gh pr checkout with custom branch name
-        const result = await Process.run(
-          ["gh", "pr", "checkout", `${prNumber}`, "--branch", localBranchName, "--force"],
-          {
-            nothrow: true,
-          },
-        )
-
-        if (result.code !== 0) {
-          UI.error(`Failed to checkout PR #${prNumber}. Make sure you have gh CLI installed and authenticated.`)
-          process.exit(1)
-        }
-
-        // Fetch PR info for fork handling and session link detection
-        const prInfoResult = await Process.text(
-          [
-            "gh",
-            "pr",
-            "view",
-            `${prNumber}`,
-            "--json",
-            "headRepository,headRepositoryOwner,isCrossRepository,headRefName,body",
-          ],
-          { nothrow: true },
-        )
-
-        let sessionId: string | undefined
-
-        if (prInfoResult.code === 0) {
-          const prInfoText = prInfoResult.text
-          if (prInfoText.trim()) {
-            const prInfo = JSON.parse(prInfoText)
-
-            // Handle fork PRs
-            if (prInfo && prInfo.isCrossRepository && prInfo.headRepository && prInfo.headRepositoryOwner) {
-              const forkOwner = prInfo.headRepositoryOwner.login
-              const forkName = prInfo.headRepository.name
-              const remoteName = forkOwner
-
-              // Check if remote already exists
-              const remotes = await AppRuntime.runPromise(
-                Git.Service.use((git) => git.run(["remote"], { cwd: Instance.worktree })),
-              ).then((x) => x.text().trim())
-              if (!remotes.split("\n").includes(remoteName)) {
-                await AppRuntime.runPromise(
-                  Git.Service.use((git) =>
-                    git.run(["remote", "add", remoteName, `https://github.com/${forkOwner}/${forkName}.git`], {
-                      cwd: Instance.worktree,
-                    }),
-                  ),
-                )
-                UI.println(`Added fork remote: ${remoteName}`)
-              }
-
-              // Set upstream to the fork so pushes go there
-              const headRefName = prInfo.headRefName
-              await AppRuntime.runPromise(
-                Git.Service.use((git) =>
-                  git.run(["branch", `--set-upstream-to=${remoteName}/${headRefName}`, localBranchName], {
-                    cwd: Instance.worktree,
-                  }),
-                ),
-              )
-            }
-
-            // Check for sleepycode session link in PR body
-            if (prInfo && prInfo.body) {
-              const sessionMatch = prInfo.body.match(/https:\/\/opncd\.ai\/s\/([a-zA-Z0-9_-]+)/)
-              if (sessionMatch) {
-                const sessionUrl = sessionMatch[0]
-                UI.println(`Found sleepycode session: ${sessionUrl}`)
-                UI.println(`Importing session...`)
-
-                const importResult = await Process.text(["sleepy", "import", sessionUrl], {
-                  nothrow: true,
-                })
-                if (importResult.code === 0) {
-                  const importOutput = importResult.text.trim()
-                  // Extract session ID from the output (format: "Imported session: <session-id>")
-                  const sessionIdMatch = importOutput.match(/Imported session: ([a-zA-Z0-9_-]+)/)
-                  if (sessionIdMatch) {
-                    sessionId = sessionIdMatch[1]
-                    UI.println(`Session imported: ${sessionId}`)
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        UI.println(`Successfully checked out PR #${prNumber} as branch '${localBranchName}'`)
-        UI.println()
-        UI.println("Starting sleepycode...")
-        UI.println()
-
-        const sleepyArgs = sessionId ? ["-s", sessionId] : []
-        const sleepyProcess = Process.spawn(["sleepy", ...sleepyArgs], {
-          stdin: "inherit",
-          stdout: "inherit",
-          stderr: "inherit",
-          cwd: process.cwd(),
-        })
-        const code = await sleepyProcess.exited
-        if (code !== 0) throw new Error(`sleepy exited with code ${code}`)
-      },
-    })
-  },
-})