@bloxystudios/bloxycode 1.0.1 → 1.0.4

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

@@ -1,48 +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 { SkillCommand } from "./skill"
-import { SnapshotCommand } from "./snapshot"
-import { AgentCommand } from "./agent"
-
-export const DebugCommand = cmd({
-  command: "debug",
-  describe: "debugging and troubleshooting tools",
-  builder: (yargs) =>
-    yargs
-      .command(ConfigCommand)
-      .command(LSPCommand)
-      .command(RipgrepCommand)
-      .command(FileCommand)
-      .command(ScrapCommand)
-      .command(SkillCommand)
-      .command(SnapshotCommand)
-      .command(AgentCommand)
-      .command(PathsCommand)
-      .command({
-        command: "wait",
-        describe: "wait indefinitely (for debugging)",
-        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",
-  describe: "show global paths (data, config, cache, state)",
-  handler() {
-    for (const [key, value] of Object.entries(Global.Path)) {
-      console.log(key.padEnd(10), value)
-    }
-  },
-})

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

@@ -1,52 +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",
-  describe: "LSP debugging utilities",
-  builder: (yargs) =>
-    yargs.command(DiagnosticsCommand).command(SymbolsCommand).command(DocumentSymbolsCommand).demandCommand(),
-  async handler() {},
-})
-
-const DiagnosticsCommand = cmd({
-  command: "diagnostics <file>",
-  describe: "get diagnostics for a file",
-  builder: (yargs) => yargs.positional("file", { type: "string", demandOption: true }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      await LSP.touchFile(args.file, true)
-      await Bun.sleep(1000)
-      process.stdout.write(JSON.stringify(await LSP.diagnostics(), null, 2) + EOL)
-    })
-  },
-})
-
-export const SymbolsCommand = cmd({
-  command: "symbols <query>",
-  describe: "search workspace symbols",
-  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>",
-  describe: "get symbols from a document",
-  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,87 +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",
-  describe: "ripgrep debugging utilities",
-  builder: (yargs) => yargs.command(TreeCommand).command(FilesCommand).command(SearchCommand).demandCommand(),
-  async handler() {},
-})
-
-const TreeCommand = cmd({
-  command: "tree",
-  describe: "show file tree using ripgrep",
-  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",
-  describe: "list files using ripgrep",
-  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>",
-  describe: "search file contents using ripgrep",
-  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,16 +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",
-  describe: "list all known projects",
-  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()
-  },
-})

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

@@ -1,16 +0,0 @@
-import { EOL } from "os"
-import { Skill } from "../../../skill"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-
-export const SkillCommand = cmd({
-  command: "skill",
-  describe: "list all available skills",
-  builder: (yargs) => yargs,
-  async handler() {
-    await bootstrap(process.cwd(), async () => {
-      const skills = await Skill.all()
-      process.stdout.write(JSON.stringify(skills, null, 2) + EOL)
-    })
-  },
-})

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

@@ -1,52 +0,0 @@
-import { Snapshot } from "../../../snapshot"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-
-export const SnapshotCommand = cmd({
-  command: "snapshot",
-  describe: "snapshot debugging utilities",
-  builder: (yargs) => yargs.command(TrackCommand).command(PatchCommand).command(DiffCommand).demandCommand(),
-  async handler() {},
-})
-
-const TrackCommand = cmd({
-  command: "track",
-  describe: "track current snapshot state",
-  async handler() {
-    await bootstrap(process.cwd(), async () => {
-      console.log(await Snapshot.track())
-    })
-  },
-})
-
-const PatchCommand = cmd({
-  command: "patch <hash>",
-  describe: "show patch for a snapshot hash",
-  builder: (yargs) =>
-    yargs.positional("hash", {
-      type: "string",
-      description: "hash",
-      demandOption: true,
-    }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      console.log(await Snapshot.patch(args.hash))
-    })
-  },
-})
-
-const DiffCommand = cmd({
-  command: "diff <hash>",
-  describe: "show diff for a snapshot hash",
-  builder: (yargs) =>
-    yargs.positional("hash", {
-      type: "string",
-      description: "hash",
-      demandOption: true,
-    }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      console.log(await Snapshot.diff(args.hash))
-    })
-  },
-})

package/src/cli/cmd/export.ts

@@ -1,88 +0,0 @@
-import type { Argv } from "yargs"
-import { Session } from "../../session"
-import { cmd } from "./cmd"
-import { bootstrap } from "../bootstrap"
-import { UI } from "../ui"
-import * as prompts from "@clack/prompts"
-import { EOL } from "os"
-
-export const ExportCommand = cmd({
-  command: "export [sessionID]",
-  describe: "export session data as JSON",
-  builder: (yargs: Argv) => {
-    return yargs.positional("sessionID", {
-      describe: "session id to export",
-      type: "string",
-    })
-  },
-  handler: async (args) => {
-    await bootstrap(process.cwd(), async () => {
-      let sessionID = args.sessionID
-      process.stderr.write(`Exporting session: ${sessionID ?? "latest"}`)
-
-      if (!sessionID) {
-        UI.empty()
-        prompts.intro("Export session", {
-          output: process.stderr,
-        })
-
-        const sessions = []
-        for await (const session of Session.list()) {
-          sessions.push(session)
-        }
-
-        if (sessions.length === 0) {
-          prompts.log.error("No sessions found", {
-            output: process.stderr,
-          })
-          prompts.outro("Done", {
-            output: process.stderr,
-          })
-          return
-        }
-
-        sessions.sort((a, b) => b.time.updated - a.time.updated)
-
-        const selectedSession = await prompts.autocomplete({
-          message: "Select session to export",
-          maxItems: 10,
-          options: sessions.map((session) => ({
-            label: session.title,
-            value: session.id,
-            hint: `${new Date(session.time.updated).toLocaleString()} • ${session.id.slice(-8)}`,
-          })),
-          output: process.stderr,
-        })
-
-        if (prompts.isCancel(selectedSession)) {
-          throw new UI.CancelledError()
-        }
-
-        sessionID = selectedSession as string
-
-        prompts.outro("Exporting session...", {
-          output: process.stderr,
-        })
-      }
-
-      try {
-        const sessionInfo = await Session.get(sessionID!)
-        const messages = await Session.messages({ sessionID: sessionID! })
-
-        const exportData = {
-          info: sessionInfo,
-          messages: messages.map((msg) => ({
-            info: msg.info,
-            parts: msg.parts,
-          })),
-        }
-
-        process.stdout.write(JSON.stringify(exportData, null, 2))
-        process.stdout.write(EOL)
-      } catch (error) {
-        UI.error(`Session not found: ${sessionID!}`)
-        process.exit(1)
-      }
-    })
-  },
-})

package/src/cli/cmd/generate.ts

@@ -1,38 +0,0 @@
-import { Server } from "../../server/server"
-import type { CommandModule } from "yargs"
-
-export const GenerateCommand = {
-  command: "generate",
-  handler: async () => {
-    const specs = await Server.openapi()
-    for (const item of Object.values(specs.paths)) {
-      for (const method of ["get", "post", "put", "delete", "patch"] as const) {
-        const operation = item[method]
-        if (!operation?.operationId) continue
-        // @ts-expect-error
-        operation["x-codeSamples"] = [
-          {
-            lang: "js",
-            source: [
-              `import { createOpencodeClient } from "@opencode-ai/sdk`,
-              ``,
-              `const client = createOpencodeClient()`,
-              `await client.${operation.operationId}({`,
-              `  ...`,
-              `})`,
-            ].join("\n"),
-          },
-        ]
-      }
-    }
-    const json = JSON.stringify(specs, null, 2)
-
-    // Wait for stdout to finish writing before process.exit() is called
-    await new Promise<void>((resolve, reject) => {
-      process.stdout.write(json, (err) => {
-        if (err) reject(err)
-        else resolve()
-      })
-    })
-  },
-} satisfies CommandModule