@vintasoftware/pr-review-canvas 0.3.0 → 0.5.0

package/src/chat/chat-manager.ts

@@ -2,9 +2,11 @@
 // and keep the transcript. The lock is what makes `CHAT_BUSY` a real answer rather than two
 // agents writing into one thread.
 import type { AgentRunner } from '../acpx/acpx.js'
+import { latestModel } from '../acpx/models.js'
 import type { ChatContext, ChatEvent, ChatThreadsResponse, ChatTurn } from '../contract/chat.js'
 import type { FileEntry, Repo, ReviewArtifact } from '../contract/review-artifact.js'
 import type { Settings, SettingsOverrides } from '../contract/settings.js'
+import type { ReviewKey } from '../contract/review-key.js'
 import type { ChatThread } from '../contract/state.js'
 import type { SettingsStore } from '../store/settings-store.js'
 import type { StateStore } from '../store/state-store.js'
@@ -38,9 +40,9 @@ export interface ChatManagerDeps {
   now: () => Date
 }
 
-/** Everything about the pull request one turn needs, resolved by the route. */
+/** Everything about the review target one turn needs, resolved by the route. */
 export interface ChatTarget {
-  prNumber: number
+  key: ReviewKey
   headSha: string
   artifact: ReviewArtifact
   files: FileEntry[]
@@ -58,13 +60,13 @@ export interface ChatSendInput {
 
 export interface ChatManager {
   effectiveSettings(): Promise<Settings>
-  threads(prNumber: number): Promise<ChatThreadsResponse>
-  createThread(prNumber: number): Promise<ChatThread>
-  selectThread(prNumber: number, name: string): Promise<ChatThread | null>
+  threads(key: ReviewKey): Promise<ChatThreadsResponse>
+  createThread(key: ReviewKey): Promise<ChatThread>
+  selectThread(key: ReviewKey, name: string): Promise<ChatThread | null>
   send(target: ChatTarget, input: ChatSendInput): AsyncIterable<ChatEvent>
   /** True when a turn was running and has been asked to stop. */
-  cancel(prNumber: number): Promise<boolean>
-  busy(prNumber: number): boolean
+  cancel(key: ReviewKey): Promise<boolean>
+  busy(key: ReviewKey): boolean
 }
 
 /** The slot a turn holds while it runs. The handle is filled in once the agent has started. */
@@ -74,8 +76,31 @@ interface RunningTurn {
   stopped: boolean
 }
 
+/**
+ * The `--model` of one turn: the newest model of the saved family. With no saved model the agent's
+ * own default applies, unless the session is on a model that has since been replaced: a thread
+ * started months ago, or a default set to an old id.
+ */
+async function modelForTurn(
+  runner: AgentRunner,
+  settings: Settings,
+  session: string,
+  cwd: string
+): Promise<string | undefined> {
+  const upgrades = await runner.modelUpgrades(settings.agent)
+  if (settings.model !== null) {
+    return latestModel(settings.agent, settings.model, upgrades)
+  }
+  const current = await runner.sessionModel({ agent: settings.agent, session, cwd })
+  if (current === null) {
+    return undefined
+  }
+  const latest = latestModel(settings.agent, current, upgrades)
+  return latest === current ? undefined : latest
+}
+
 export function createChatManager(deps: ChatManagerDeps): ChatManager {
-  const running = new Map<number, RunningTurn>()
+  const running = new Map<ReviewKey, RunningTurn>()
 
   const effectiveSettings = async (): Promise<Settings> => {
     const saved = await deps.settings.read()
@@ -86,12 +111,12 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
     }
   }
 
-  const newThread = async (prNumber: number, agent: string): Promise<ChatThread> => {
+  const newThread = async (key: ReviewKey, agent: string): Promise<ChatThread> => {
     const at = deps.now().toISOString()
     let created: ChatThread | null = null
-    await deps.state.update(prNumber, state => {
+    await deps.state.update(key, state => {
       const thread: ChatThread = {
-        name: threadName(deps.repo, prNumber, agent, nextThreadIndex(state.chat.threads)),
+        name: threadName(deps.repo, key, agent, nextThreadIndex(state.chat.threads)),
         agent,
         rev: 0,
         title: NEW_THREAD_TITLE,
@@ -108,8 +133,8 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
   }
 
   /** The thread a message goes to: the one asked for, the active one, or a fresh one. */
-  const resolveThread = async (prNumber: number, agent: string, wanted?: string): Promise<ChatThread> => {
-    const state = await deps.state.read(prNumber)
+  const resolveThread = async (key: ReviewKey, agent: string, wanted?: string): Promise<ChatThread> => {
+    const state = await deps.state.read(key)
     const byName = wanted === undefined ? undefined : state.chat.threads.find(t => t.name === wanted)
     const active =
       byName ??
@@ -118,10 +143,10 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
         : state.chat.threads.find(t => t.name === state.chat.activeThread))
     // Changing the agent starts a new thread: the old session belongs to the old agent.
     if (active === undefined || active.agent !== agent) {
-      return newThread(prNumber, agent)
+      return newThread(key, agent)
     }
     if (state.chat.activeThread !== active.name) {
-      await deps.state.update(prNumber, current => ({
+      await deps.state.update(key, current => ({
         ...current,
         chat: { ...current.chat, activeThread: active.name },
       }))
@@ -134,18 +159,18 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
    * try creates the session again and sends the seed again.
    */
   const saveTurn = async (
-    prNumber: number,
+    key: ReviewKey,
     thread: ChatThread,
     userText: string,
     assistant: ChatTurn,
     seededHeadSha: string,
     reached: boolean
   ): Promise<void> => {
-    await deps.transcripts.append(prNumber, thread.name, assistant)
+    await deps.transcripts.append(key, thread.name, assistant)
     if (!reached) {
       return
     }
-    await deps.state.update(prNumber, state => ({
+    await deps.state.update(key, state => ({
       ...state,
       chat: {
         ...state.chat,
@@ -169,8 +194,8 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
    * it, so the next turn creates the session again and sends the seed with it. The revision keeps
    * counting the turns the thread has taken, which is what its title is keyed on.
    */
-  const forgetSession = async (prNumber: number, name: string): Promise<void> => {
-    await deps.state.update(prNumber, state => ({
+  const forgetSession = async (key: ReviewKey, name: string): Promise<void> => {
+    await deps.state.update(key, state => ({
       ...state,
       chat: {
         ...state.chat,
@@ -180,17 +205,17 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
   }
 
   async function* send(target: ChatTarget, input: ChatSendInput): AsyncIterable<ChatEvent> {
-    if (running.has(target.prNumber)) {
+    if (running.has(target.key)) {
       throw new ChatBusyError()
     }
     // The slot is taken before the first await, so a second request that arrives while this one
     // is still reading the settings sees a busy chat rather than starting a second agent.
     const slot: RunningTurn = { run: null, stopped: false }
-    running.set(target.prNumber, slot)
+    running.set(target.key, slot)
     try {
       yield* runTurn(target, input, slot)
     } finally {
-      running.delete(target.prNumber)
+      running.delete(target.key)
     }
   }
 
@@ -200,7 +225,7 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
     slot: RunningTurn
   ): AsyncIterable<ChatEvent> {
     const settings = await effectiveSettings()
-    const thread = await resolveThread(target.prNumber, settings.agent, input.thread)
+    const thread = await resolveThread(target.key, settings.agent, input.thread)
     const seeded = thread.seededHeadSha !== target.headSha
     const at = deps.now().toISOString()
     const contextBlock = await renderChatContext(input.context, {
@@ -224,18 +249,20 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
       })
     }
 
-    await deps.transcripts.append(target.prNumber, thread.name, {
+    await deps.transcripts.append(target.key, thread.name, {
       role: 'user',
       text: input.message,
       at,
       context: input.context,
     })
 
+    const model = await modelForTurn(deps.runner, settings, thread.name, deps.repoRoot)
+
     // A stop that arrived while the turn was setting up means no agent is started at all. The
     // transcript is written before the events, so a reader who leaves now still finds it there.
     if (slot.stopped) {
       await saveTurn(
-        target.prNumber,
+        target.key,
         thread,
         input.message,
         { role: 'assistant', text: '', at: deps.now().toISOString(), incomplete: 'cancelled' },
@@ -254,11 +281,11 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
       prompt,
       cwd: deps.repoRoot,
       timeoutSec: settings.chatTimeoutSec,
-      model: settings.model ?? undefined,
+      model,
       maxTurns: settings.maxTurns ?? undefined,
       // The runner scrubs the line before it gets here; this only writes it down.
       onRawLine: line => {
-        void deps.transcripts.appendEvent(target.prNumber, thread.name, line).catch(() => undefined)
+        void deps.transcripts.appendEvent(target.key, thread.name, line).catch(() => undefined)
       },
     })
     slot.run = run
@@ -316,7 +343,7 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
         await run.cancel().catch(() => undefined)
       }
       await saveTurn(
-        target.prNumber,
+        target.key,
         thread,
         input.message,
         {
@@ -330,15 +357,15 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
         answer !== '' || incomplete === undefined || incomplete === 'cancelled'
       )
       if (incomplete === 'AGENT_NO_SESSION') {
-        await forgetSession(target.prNumber, thread.name)
+        await forgetSession(target.key, thread.name)
       }
     }
   }
 
   return {
     effectiveSettings,
-    async threads(prNumber) {
-      const [state, settings] = await Promise.all([deps.state.read(prNumber), effectiveSettings()])
+    async threads(key) {
+      const [state, settings] = await Promise.all([deps.state.read(key), effectiveSettings()])
       return {
         threads: state.chat.threads.map(t => ({
           name: t.name,
@@ -350,25 +377,25 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
         agent: settings.agent,
       }
     },
-    async createThread(prNumber) {
+    async createThread(key) {
       const settings = await effectiveSettings()
-      return newThread(prNumber, settings.agent)
+      return newThread(key, settings.agent)
     },
-    async selectThread(prNumber, name) {
-      const state = await deps.state.read(prNumber)
+    async selectThread(key, name) {
+      const state = await deps.state.read(key)
       const thread = state.chat.threads.find(t => t.name === name)
       if (thread === undefined) {
         return null
       }
-      await deps.state.update(prNumber, current => ({
+      await deps.state.update(key, current => ({
         ...current,
         chat: { ...current.chat, activeThread: name },
       }))
       return thread
     },
     send,
-    async cancel(prNumber) {
-      const slot = running.get(prNumber)
+    async cancel(key) {
+      const slot = running.get(key)
       if (slot === undefined) {
         return false
       }
@@ -378,7 +405,7 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
       await slot.run?.cancel()
       return true
     },
-    busy: prNumber => running.has(prNumber),
+    busy: key => running.has(key),
   }
 }
 

package/src/chat/threads.ts

@@ -1,9 +1,10 @@
 // A chat thread is one acpx session plus the transcript of what was said in it. Both are named
-// after the pull request, so two repositories never share a session and a name can never point
+// after the review target, so two repositories never share a session and a name can never point
 // outside the chat directory.
 import { appendFile, mkdir, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { type ChatTurn, ChatTurnSchema } from '../contract/chat.js'
+import { keyToString, type ReviewKey } from '../contract/review-key.js'
 import type { Repo } from '../contract/review-artifact.js'
 import type { ChatThread } from '../contract/state.js'
 import { isNotFound } from '../store/atomic-json.js'
@@ -17,19 +18,19 @@ export function slug(value: string): string {
     .slice(0, 40)
 }
 
-export function threadName(repo: Repo, prNumber: number, agent: string, index: number): string {
-  return `pr-review-${slug(repo.owner)}-${slug(repo.name)}-${prNumber}-${slug(agent)}-t${index}`
+export function threadName(repo: Repo, key: ReviewKey, agent: string, index: number): string {
+  return `pr-review-${slug(repo.owner)}-${slug(repo.name)}-${keyToString(key)}-${slug(agent)}-t${index}`
 }
 
-const NAME_RE = /^pr-review-[a-z0-9-]+-(\d+)-[a-z0-9-]+-t(\d+)$/
+const NAME_RE = /^pr-review-[a-z0-9-]+-(\d+|branch|uncommitted)-[a-z0-9-]+-t(\d+)$/
 
-/** True when the name is one this tool could have made for this pull request. */
-export function isThreadNameFor(name: string, prNumber: number): boolean {
+/** True when the name is one this tool could have made for this target. */
+export function isThreadNameFor(name: string, key: ReviewKey): boolean {
   const m = NAME_RE.exec(name)
-  return m !== null && m[1] === String(prNumber)
+  return m !== null && m[1] === keyToString(key)
 }
 
-/** The next `t<k>`: one past the highest index already used on this pull request. */
+/** The next `t<k>`: one past the highest index already used on this target. */
 export function nextThreadIndex(threads: readonly ChatThread[]): number {
   let highest = 0
   for (const thread of threads) {
@@ -55,22 +56,22 @@ export function threadTitle(firstMessage: string): string {
 }
 
 export interface TranscriptStore {
-  dir(prNumber: number): string
-  file(prNumber: number, name: string): string
-  eventsFile(prNumber: number, name: string): string
-  read(prNumber: number, name: string): Promise<ChatTurn[]>
-  append(prNumber: number, name: string, turn: ChatTurn): Promise<void>
+  dir(key: ReviewKey): string
+  file(key: ReviewKey, name: string): string
+  eventsFile(key: ReviewKey, name: string): string
+  read(key: ReviewKey, name: string): Promise<ChatTurn[]>
+  append(key: ReviewKey, name: string, turn: ChatTurn): Promise<void>
   /** Appends one already-scrubbed acpx line to the raw event log. */
-  appendEvent(prNumber: number, name: string, line: string): Promise<void>
+  appendEvent(key: ReviewKey, name: string, line: string): Promise<void>
 }
 
-export function createTranscriptStore(prDir: (prNumber: number) => string): TranscriptStore {
-  const dir = (prNumber: number): string => path.join(prDir(prNumber), 'chat')
-  const named = (prNumber: number, name: string, suffix: string): string => {
-    if (!isThreadNameFor(name, prNumber)) {
-      throw new Error(`not a chat thread of pull request ${prNumber}: ${name}`)
+export function createTranscriptStore(prDir: (key: ReviewKey) => string): TranscriptStore {
+  const dir = (key: ReviewKey): string => path.join(prDir(key), 'chat')
+  const named = (key: ReviewKey, name: string, suffix: string): string => {
+    if (!isThreadNameFor(name, key)) {
+      throw new Error(`not a chat thread of ${keyToString(key)}: ${name}`)
     }
-    return path.join(dir(prNumber), `${name}${suffix}`)
+    return path.join(dir(key), `${name}${suffix}`)
   }
   const appendLine = async (file: string, line: string): Promise<void> => {
     await mkdir(path.dirname(file), { recursive: true })
@@ -78,12 +79,12 @@ export function createTranscriptStore(prDir: (prNumber: number) => string): Tran
   }
   return {
     dir,
-    file: (prNumber, name) => named(prNumber, name, '.jsonl'),
-    eventsFile: (prNumber, name) => named(prNumber, name, '.events.ndjson'),
-    async read(prNumber, name) {
+    file: (key, name) => named(key, name, '.jsonl'),
+    eventsFile: (key, name) => named(key, name, '.events.ndjson'),
+    async read(key, name) {
       let text: string
       try {
-        text = await readFile(named(prNumber, name, '.jsonl'), 'utf8')
+        text = await readFile(named(key, name, '.jsonl'), 'utf8')
       } catch (err) {
         if (isNotFound(err)) {
           return []
@@ -108,7 +109,7 @@ export function createTranscriptStore(prDir: (prNumber: number) => string): Tran
       }
       return turns
     },
-    append: (prNumber, name, turn) => appendLine(named(prNumber, name, '.jsonl'), JSON.stringify(turn)),
-    appendEvent: (prNumber, name, line) => appendLine(named(prNumber, name, '.events.ndjson'), line),
+    append: (key, name, turn) => appendLine(named(key, name, '.jsonl'), JSON.stringify(turn)),
+    appendEvent: (key, name, line) => appendLine(named(key, name, '.events.ndjson'), line),
   }
 }

package/src/cli.ts

@@ -1,6 +1,9 @@
+import { execFile } from 'node:child_process'
+import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { createInterface } from 'node:readline/promises'
 import { parseArgs } from 'node:util'
-import { createAgentRunner } from './acpx/acpx.js'
+import { ACPX_BIN, createAgentRunner, findOnPath } from './acpx/acpx.js'
 import {
   type CliIo,
   EXIT,
@@ -18,13 +21,15 @@ import {
 import { ConfigError, loadRuntimeConfig, parsePort, readEnv, resolveRepoRoot } from './config.js'
 import { type ReviewArtifact, ReviewArtifactSchema } from './contract/review-artifact.js'
 import { createGit } from './git/git.js'
-import { createGitHubClient } from './github/gh.js'
+import { createHostClient } from './host/client.js'
 import { loadProjectConfig } from './project-config.js'
 import { checkSkill } from './review/doctor.js'
 import { type AppContext, createAppContext, readPackageVersion } from './server/context.js'
 import { startServer } from './server/node-server.js'
+import { PACKAGE_ROOT } from './paths.js'
 import { readJson } from './store/atomic-json.js'
 import { ensureDataDir } from './store/data-dir.js'
+import { type CommandResult, runUpgrade } from './upgrade.js'
 
 const SUBCOMMANDS = [
   'serve',
@@ -35,13 +40,19 @@ const SUBCOMMANDS = [
   'import',
   'install-skill',
   'doctor',
+  'upgrade',
 ] as const
 
 const USAGE = `usage: pr-review <command> [flags]
 
   serve [--port 3010] [--repo <dir>] [--data-dir <dir>] [--fixture-canvas <review.json>]
         [--agent claude|codex] [--model <id>]   (chat only; wins over .pr-review/settings.yml)
-  prepare (--pr <n> | --base <ref> --head <ref>) [--force] [--repo <dir>] [--data-dir <dir>]
+  prepare (--pr <n> | --branch | --uncommitted | --base <ref> --head <ref>) [--force]
+          [--base <ref>] [--repo <dir>] [--data-dir <dir>]
+                   (--branch reviews the current branch against the default branch, and
+                    --uncommitted reviews it with the working tree's edits and new files on top.
+                    Both are for work with no PR yet, take --base <ref> to compare against
+                    another branch, and show at /review/branch and /review/uncommitted.)
   validate <model.json|review.json> --canvas <dir> [--human] [--fix] [--repo <dir>] [--data-dir <dir>]
                    (--fix trims over-cap titles in place and reports each one)
   publish <canvasDir> --agent <id> [--model <id>] --harness claude-code|codex|other [--allow-stale]
@@ -50,9 +61,12 @@ const USAGE = `usage: pr-review <command> [flags]
                    (both flags: the named commit is exported and the number stamps the zip)
   import <zip> [--pr <n>] [--force] [--repo <dir>] [--data-dir <dir>]
   doctor [--all-checks] [--repo <dir>] [--data-dir <dir>]
+  upgrade [--yes] [--only package,acpx,skill] [--repo <dir>]
+                   (updates pr-review and acpx with npm, and refreshes the project's skill copies;
+                    lists the changes and asks first unless --yes)
 
 Every command prints one JSON line on success and { "error": { code, message, hint } } on failure.
-Exit codes: 0 ok, 1 error, 2 usage, 4 gh missing or not logged in, 5 invalid model output.
+Exit codes: 0 ok, 1 error, 2 usage, 4 gh/glab missing or not logged in, 5 invalid model output.
 `
 
 const io: CliIo = {
@@ -125,15 +139,15 @@ async function serve(argv: string[]): Promise<number> {
   return EXIT.ok
 }
 
-/** doctor builds no AppContext: it has to answer even when the repo or `gh` is the problem. */
+/** doctor builds no AppContext: it has to answer even when the repo or host CLI is the problem. */
 async function doctorCommand(argv: string[]): Promise<number> {
   const { repo, dataDir, rest } = splitCommonFlags(argv)
   const cwd = process.cwd()
-  const git = createGit(repo === undefined ? cwd : path.resolve(cwd, repo))
   return runDoctor(
     {
-      git,
-      gh: createGitHubClient(),
+      git: createGit(repo === undefined ? cwd : path.resolve(cwd, repo)),
+      env: process.env,
+      client: host => createHostClient(host.cli),
       version: readPackageVersion(),
       acpxVersion: () => createAgentRunner().acpxVersion(),
       dataDirOverride: dataDir ?? readEnv(process.env, 'PR_REVIEW_DATA_DIR'),
@@ -150,6 +164,52 @@ async function installSkillCommand(argv: string[]): Promise<number> {
   return runInstallSkill({ repoRoot, cwd }, rest, io)
 }
 
+function runCommand(file: string, args: string[]): Promise<CommandResult> {
+  return new Promise(resolve => {
+    execFile(file, args, { encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) =>
+      resolve({ ok: err === null, stdout, stderr })
+    )
+  })
+}
+
+async function confirmOnTerminal(question: string): Promise<boolean | null> {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) return null
+  const rl = createInterface({ input: process.stdin, output: process.stderr })
+  try {
+    return /^y(es)?$/i.test((await rl.question(question)).trim())
+  } finally {
+    rl.close()
+  }
+}
+
+async function upgradeCommand(argv: string[]): Promise<number> {
+  const { repo, rest } = splitCommonFlags(argv)
+  const cwd = process.cwd()
+  let repoRoot: string | null
+  try {
+    repoRoot = await resolveRepoRoot(createGit(repo === undefined ? cwd : path.resolve(cwd, repo)))
+  } catch {
+    repoRoot = null
+  }
+  const pkg = JSON.parse(await readFile(path.join(PACKAGE_ROOT, 'package.json'), 'utf8')) as { name: string }
+  return runUpgrade(
+    {
+      packageName: pkg.name,
+      version: readPackageVersion(),
+      packageRoot: PACKAGE_ROOT,
+      repoRoot,
+      acpxVersion: () => createAgentRunner().acpxVersion(),
+      acpxPath: findOnPath(ACPX_BIN, process.env),
+      run: runCommand,
+      runInstalled: args =>
+        runCommand(process.execPath, [path.join(PACKAGE_ROOT, 'bin', 'pr-review.mjs'), ...args]),
+      confirm: confirmOnTerminal,
+    },
+    rest,
+    io
+  )
+}
+
 export async function main(argv: string[]): Promise<number> {
   // `pnpm review -- --port 3011` forwards the `--` itself; drop it so parseArgs sees the flags.
   const [command, ...rest] = argv.filter(a => a !== '--')
@@ -169,6 +229,8 @@ export async function main(argv: string[]): Promise<number> {
         return await installSkillCommand(rest)
       case 'doctor':
         return await doctorCommand(rest)
+      case 'upgrade':
+        return await upgradeCommand(rest)
       default: {
         const { repo, dataDir, rest: own } = splitCommonFlags(rest)
         const ctx = await buildContext(repo, dataDir)