@link-assistant/agent 0.0.8

package/src/cli/cmd/agent.ts

@@ -0,0 +1,165 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Global } from "../../global"
+import { Agent } from "../../agent/agent"
+import path from "path"
+import matter from "gray-matter"
+import { Instance } from "../../project/instance"
+import { EOL } from "os"
+
+const AgentCreateCommand = cmd({
+  command: "create",
+  describe: "create a new agent",
+  async handler() {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Create agent")
+        const project = Instance.project
+
+        let scope: "global" | "project" = "global"
+        if (project.vcs === "git") {
+          const scopeResult = await prompts.select({
+            message: "Location",
+            options: [
+              {
+                label: "Current project",
+                value: "project" as const,
+                hint: Instance.worktree,
+              },
+              {
+                label: "Global",
+                value: "global" as const,
+                hint: Global.Path.config,
+              },
+            ],
+          })
+          if (prompts.isCancel(scopeResult)) throw new UI.CancelledError()
+          scope = scopeResult
+        }
+
+        const query = await prompts.text({
+          message: "Description",
+          placeholder: "What should this agent do?",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        })
+        if (prompts.isCancel(query)) throw new UI.CancelledError()
+
+        const spinner = prompts.spinner()
+
+        spinner.start("Generating agent configuration...")
+        const generated = await Agent.generate({ description: query }).catch((error) => {
+          spinner.stop(`LLM failed to generate agent: ${error.message}`, 1)
+          throw new UI.CancelledError()
+        })
+        spinner.stop(`Agent ${generated.identifier} generated`)
+
+        const availableTools = [
+          "bash",
+          "read",
+          "write",
+          "edit",
+          "list",
+          "glob",
+          "grep",
+          "webfetch",
+          "task",
+          "todowrite",
+          "todoread",
+        ]
+
+        const selectedTools = await prompts.multiselect({
+          message: "Select tools to enable",
+          options: availableTools.map((tool) => ({
+            label: tool,
+            value: tool,
+          })),
+          initialValues: availableTools,
+        })
+        if (prompts.isCancel(selectedTools)) throw new UI.CancelledError()
+
+        const modeResult = await prompts.select({
+          message: "Agent mode",
+          options: [
+            {
+              label: "All",
+              value: "all" as const,
+              hint: "Can function in both primary and subagent roles",
+            },
+            {
+              label: "Primary",
+              value: "primary" as const,
+              hint: "Acts as a primary/main agent",
+            },
+            {
+              label: "Subagent",
+              value: "subagent" as const,
+              hint: "Can be used as a subagent by other agents",
+            },
+          ],
+          initialValue: "all",
+        })
+        if (prompts.isCancel(modeResult)) throw new UI.CancelledError()
+
+        const tools: Record<string, boolean> = {}
+        for (const tool of availableTools) {
+          if (!selectedTools.includes(tool)) {
+            tools[tool] = false
+          }
+        }
+
+        const frontmatter: any = {
+          description: generated.whenToUse,
+          mode: modeResult,
+        }
+        if (Object.keys(tools).length > 0) {
+          frontmatter.tools = tools
+        }
+
+        const content = matter.stringify(generated.systemPrompt, frontmatter)
+        const filePath = path.join(
+          scope === "global" ? Global.Path.config : path.join(Instance.worktree, ".opencode"),
+          `agent`,
+          `${generated.identifier}.md`,
+        )
+
+        await Bun.write(filePath, content)
+
+        prompts.log.success(`Agent created: ${filePath}`)
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+const AgentListCommand = cmd({
+  command: "list",
+  describe: "list all available agents",
+  async handler() {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        const agents = await Agent.list()
+        const sortedAgents = agents.sort((a, b) => {
+          if (a.builtIn !== b.builtIn) {
+            return a.builtIn ? -1 : 1
+          }
+          return a.name.localeCompare(b.name)
+        })
+
+        for (const agent of sortedAgents) {
+          process.stdout.write(`${agent.name} (${agent.mode})${EOL}`)
+        }
+      },
+    })
+  },
+})
+
+export const AgentCommand = cmd({
+  command: "agent",
+  describe: "manage agents",
+  builder: (yargs) => yargs.command(AgentCreateCommand).command(AgentListCommand).demandCommand(),
+  async handler() {},
+})

package/src/cli/cmd/cmd.ts

@@ -0,0 +1,5 @@
+import type { CommandModule } from "yargs"
+
+export function cmd<T, U>(input: CommandModule<T, U>) {
+  return input
+}

package/src/cli/cmd/export.ts

@@ -0,0 +1,88 @@
+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/mcp.ts

@@ -0,0 +1,80 @@
+import { cmd } from "./cmd"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+
+export const McpCommand = cmd({
+  command: "mcp",
+  builder: (yargs) => yargs.command(McpAddCommand).demandCommand(),
+  async handler() {},
+})
+
+export const McpAddCommand = cmd({
+  command: "add",
+  describe: "add an MCP server",
+  async handler() {
+    UI.empty()
+    prompts.intro("Add MCP server")
+
+    const name = await prompts.text({
+      message: "Enter MCP server name",
+      validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+    })
+    if (prompts.isCancel(name)) throw new UI.CancelledError()
+
+    const type = await prompts.select({
+      message: "Select MCP server type",
+      options: [
+        {
+          label: "Local",
+          value: "local",
+          hint: "Run a local command",
+        },
+        {
+          label: "Remote",
+          value: "remote",
+          hint: "Connect to a remote URL",
+        },
+      ],
+    })
+    if (prompts.isCancel(type)) throw new UI.CancelledError()
+
+    if (type === "local") {
+      const command = await prompts.text({
+        message: "Enter command to run",
+        placeholder: "e.g., opencode x @modelcontextprotocol/server-filesystem",
+        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(command)) throw new UI.CancelledError()
+
+      prompts.log.info(`Local MCP server "${name}" configured with command: ${command}`)
+      prompts.outro("MCP server added successfully")
+      return
+    }
+
+    if (type === "remote") {
+      const url = await prompts.text({
+        message: "Enter MCP server URL",
+        placeholder: "e.g., https://example.com/mcp",
+        validate: (x) => {
+          if (!x) return "Required"
+          if (x.length === 0) return "Required"
+          const isValid = URL.canParse(x)
+          return isValid ? undefined : "Invalid URL"
+        },
+      })
+      if (prompts.isCancel(url)) throw new UI.CancelledError()
+
+      const client = new Client({
+        name: "opencode",
+        version: "1.0.0",
+      })
+      const transport = new StreamableHTTPClientTransport(new URL(url))
+      await client.connect(transport)
+      prompts.log.info(`Remote MCP server "${name}" configured with URL: ${url}`)
+    }
+
+    prompts.outro("MCP server added successfully")
+  },
+})

package/src/cli/cmd/models.ts

@@ -0,0 +1,58 @@
+import type { Argv } from "yargs"
+import { Instance } from "../../project/instance"
+import { Provider } from "../../provider/provider"
+import { cmd } from "./cmd"
+import { UI } from "../ui"
+import { EOL } from "os"
+
+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",
+      })
+  },
+  handler: async (args) => {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        const providers = await Provider.list()
+
+        function printModels(providerID: string, verbose?: boolean) {
+          const provider = providers[providerID]
+          for (const [modelID, model] of Object.entries(provider.info.models)) {
+            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 provider = providers[args.provider]
+          if (!provider) {
+            UI.error(`Provider not found: ${args.provider}`)
+            return
+          }
+
+          printModels(args.provider, args.verbose)
+          return
+        }
+
+        for (const providerID of Object.keys(providers)) {
+          printModels(providerID, args.verbose)
+        }
+      },
+    })
+  },
+})