easc-cli 1.1.37 → 1.1.40

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

@@ -1,166 +0,0 @@
-import { EOL } from "os"
-import { basename } from "path"
-import { Agent } from "../../../agent/agent"
-import { Provider } from "../../../provider/provider"
-import { Session } from "../../../session"
-import type { MessageV2 } from "../../../session/message-v2"
-import { Identifier } from "../../../id/id"
-import { ToolRegistry } from "../../../tool/registry"
-import { Instance } from "../../../project/instance"
-import { PermissionNext } from "../../../permission/next"
-import { iife } from "../../../util/iife"
-import { bootstrap } from "../../bootstrap"
-import { cmd } from "../cmd"
-
-export const AgentCommand = cmd({
-  command: "agent <name>",
-  describe: "show agent configuration details",
-  builder: (yargs) =>
-    yargs
-      .positional("name", {
-        type: "string",
-        demandOption: true,
-        description: "Agent name",
-      })
-      .option("tool", {
-        type: "string",
-        description: "Tool id to execute",
-      })
-      .option("params", {
-        type: "string",
-        description: "Tool params as JSON or a JS object literal",
-      }),
-  async handler(args) {
-    await bootstrap(process.cwd(), async () => {
-      const agentName = args.name as string
-      const agent = await Agent.get(agentName)
-      if (!agent) {
-        process.stderr.write(
-          `Agent ${agentName} not found, run '${basename(process.execPath)} agent list' to get an agent list` + EOL,
-        )
-        process.exit(1)
-      }
-      const availableTools = await getAvailableTools(agent)
-      const resolvedTools = await resolveTools(agent, availableTools)
-      const toolID = args.tool as string | undefined
-      if (toolID) {
-        const tool = availableTools.find((item) => item.id === toolID)
-        if (!tool) {
-          process.stderr.write(`Tool ${toolID} not found for agent ${agentName}` + EOL)
-          process.exit(1)
-        }
-        if (resolvedTools[toolID] === false) {
-          process.stderr.write(`Tool ${toolID} is disabled for agent ${agentName}` + EOL)
-          process.exit(1)
-        }
-        const params = parseToolParams(args.params as string | undefined)
-        const ctx = await createToolContext(agent)
-        const result = await tool.execute(params, ctx)
-        process.stdout.write(JSON.stringify({ tool: toolID, input: params, result }, null, 2) + EOL)
-        return
-      }
-
-      const output = {
-        ...agent,
-        tools: resolvedTools,
-      }
-      process.stdout.write(JSON.stringify(output, null, 2) + EOL)
-    })
-  },
-})
-
-async function getAvailableTools(agent: Agent.Info) {
-  const model = agent.model ?? (await Provider.defaultModel())
-  return ToolRegistry.tools(model, agent)
-}
-
-async function resolveTools(agent: Agent.Info, availableTools: Awaited<ReturnType<typeof getAvailableTools>>) {
-  const disabled = PermissionNext.disabled(
-    availableTools.map((tool) => tool.id),
-    agent.permission,
-  )
-  const resolved: Record<string, boolean> = {}
-  for (const tool of availableTools) {
-    resolved[tool.id] = !disabled.has(tool.id)
-  }
-  return resolved
-}
-
-function parseToolParams(input?: string) {
-  if (!input) return {}
-  const trimmed = input.trim()
-  if (trimmed.length === 0) return {}
-
-  const parsed = iife(() => {
-    try {
-      return JSON.parse(trimmed)
-    } catch (jsonError) {
-      try {
-        return new Function(`return (${trimmed})`)()
-      } catch (evalError) {
-        throw new Error(
-          `Failed to parse --params. Use JSON or a JS object literal. JSON error: ${jsonError}. Eval error: ${evalError}.`,
-        )
-      }
-    }
-  })
-
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Tool params must be an object.")
-  }
-  return parsed as Record<string, unknown>
-}
-
-async function createToolContext(agent: Agent.Info) {
-  const session = await Session.create({ title: `Debug tool run (${agent.name})` })
-  const messageID = Identifier.ascending("message")
-  const model = agent.model ?? (await Provider.defaultModel())
-  const now = Date.now()
-  const message: MessageV2.Assistant = {
-    id: messageID,
-    sessionID: session.id,
-    role: "assistant",
-    time: {
-      created: now,
-    },
-    parentID: messageID,
-    modelID: model.modelID,
-    providerID: model.providerID,
-    mode: "debug",
-    agent: agent.name,
-    path: {
-      cwd: Instance.directory,
-      root: Instance.worktree,
-    },
-    cost: 0,
-    tokens: {
-      input: 0,
-      output: 0,
-      reasoning: 0,
-      cache: {
-        read: 0,
-        write: 0,
-      },
-    },
-  }
-  await Session.updateMessage(message)
-
-  const ruleset = PermissionNext.merge(agent.permission, session.permission ?? [])
-
-  return {
-    sessionID: session.id,
-    messageID,
-    callID: Identifier.ascending("part"),
-    agent: agent.name,
-    abort: new AbortController().signal,
-    metadata: () => {},
-    async ask(req: Omit<PermissionNext.Request, "id" | "sessionID" | "tool">) {
-      for (const pattern of req.patterns) {
-        const rule = PermissionNext.evaluate(req.permission, pattern, ruleset)
-        if (rule.action === "deny") {
-          throw new PermissionNext.DeniedError(ruleset)
-        }
-      }
-    },
-  }
-}

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

@@ -1,16 +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",
-  describe: "show resolved configuration",
-  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,97 +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>",
-  describe: "search files by 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>",
-  describe: "read file contents as JSON",
-  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",
-  describe: "show file status information",
-  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>",
-  describe: "list files in a directory",
-  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]",
-  describe: "show directory tree",
-  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(JSON.stringify(files, null, 2))
-  },
-})
-
-export const FileCommand = cmd({
-  command: "file",
-  describe: "file system debugging utilities",
-  builder: (yargs) =>
-    yargs
-      .command(FileReadCommand)
-      .command(FileStatusCommand)
-      .command(FileListCommand)
-      .command(FileSearchCommand)
-      .command(FileTreeCommand)
-      .demandCommand(),
-  async handler() {},
-})

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 "@eliseart.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