opencode-agent[bot]
116 lines
4.0 KiB
TypeScript
116 lines
4.0 KiB
TypeScript
import { Effect } from "effect"
|
|
import { UI } from "../ui"
|
|
import { effectCmd, fail } from "../effect-cmd"
|
|
import { Git } from "@/git"
|
|
import { InstanceRef } from "@/effect/instance-ref"
|
|
import { Process } from "@/util/process"
|
|
|
|
export const PrCommand = effectCmd({
|
|
command: "pr <number>",
|
|
describe: "fetch and checkout a GitHub PR branch, then run opencode",
|
|
builder: (yargs) =>
|
|
yargs.positional("number", {
|
|
type: "number",
|
|
describe: "PR number to checkout",
|
|
demandOption: true,
|
|
}),
|
|
handler: Effect.fn("Cli.pr")(function* (args) {
|
|
const ctx = yield* InstanceRef
|
|
if (!ctx) return yield* fail("Could not load instance context")
|
|
if (ctx.project.vcs !== "git") {
|
|
return yield* fail("Could not find git repository. Please run this command from a git repository.")
|
|
}
|
|
|
|
const git = yield* Git.Service
|
|
const worktree = ctx.worktree
|
|
|
|
const prNumber = args.number
|
|
const localBranchName = `pr/${prNumber}`
|
|
UI.println(`Fetching and checking out PR #${prNumber}...`)
|
|
|
|
const checkout = yield* Effect.promise(() =>
|
|
Process.run(["gh", "pr", "checkout", `${prNumber}`, "--branch", localBranchName, "--force"], { nothrow: true }),
|
|
)
|
|
if (checkout.code !== 0) {
|
|
return yield* fail(`Failed to checkout PR #${prNumber}. Make sure you have gh CLI installed and authenticated.`)
|
|
}
|
|
|
|
const prInfoResult = yield* Effect.promise(() =>
|
|
Process.text(
|
|
[
|
|
"gh",
|
|
"pr",
|
|
"view",
|
|
`${prNumber}`,
|
|
"--json",
|
|
"headRepository,headRepositoryOwner,isCrossRepository,headRefName,body",
|
|
],
|
|
{ nothrow: true },
|
|
),
|
|
)
|
|
|
|
let sessionId: string | undefined
|
|
|
|
if (prInfoResult.code === 0 && prInfoResult.text.trim()) {
|
|
const prInfo = JSON.parse(prInfoResult.text)
|
|
|
|
if (prInfo?.isCrossRepository && prInfo.headRepository && prInfo.headRepositoryOwner) {
|
|
const forkOwner = prInfo.headRepositoryOwner.login
|
|
const forkName = prInfo.headRepository.name
|
|
const remoteName = forkOwner
|
|
|
|
const remotes = (yield* git.run(["remote"], { cwd: worktree })).text().trim()
|
|
if (!remotes.split("\n").includes(remoteName)) {
|
|
yield* git.run(["remote", "add", remoteName, `https://github.com/${forkOwner}/${forkName}.git`], {
|
|
cwd: worktree,
|
|
})
|
|
UI.println(`Added fork remote: ${remoteName}`)
|
|
}
|
|
|
|
yield* git.run(["branch", `--set-upstream-to=${remoteName}/${prInfo.headRefName}`, localBranchName], {
|
|
cwd: worktree,
|
|
})
|
|
}
|
|
|
|
if (prInfo?.body) {
|
|
const sessionMatch = prInfo.body.match(/https:\/\/opncd\.ai\/s\/([a-zA-Z0-9_-]+)/)
|
|
if (sessionMatch) {
|
|
const sessionUrl = sessionMatch[0]
|
|
UI.println(`Found opencode session: ${sessionUrl}`)
|
|
UI.println(`Importing session...`)
|
|
|
|
const importResult = yield* Effect.promise(() =>
|
|
Process.text(["opencode", "import", sessionUrl], { nothrow: true }),
|
|
)
|
|
if (importResult.code === 0) {
|
|
const sessionIdMatch = importResult.text.trim().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 opencode...")
|
|
UI.println()
|
|
|
|
const opencodeArgs = sessionId ? ["-s", sessionId] : []
|
|
const code = yield* Effect.promise(
|
|
() =>
|
|
Process.spawn(["opencode", ...opencodeArgs], {
|
|
stdin: "inherit",
|
|
stdout: "inherit",
|
|
stderr: "inherit",
|
|
cwd: process.cwd(),
|
|
}).exited,
|
|
)
|
|
// Match legacy throw semantics — propagate as a defect so the top-level
|
|
// index.ts catch handles it identically (exit 1, "Unexpected error" banner).
|
|
if (code !== 0) return yield* Effect.die(new Error(`opencode exited with code ${code}`))
|
|
}),
|
|
})
|