@vintasoftware/pr-review-canvas 0.2.0 → 0.3.0

package/src/commands.ts

@@ -63,7 +63,12 @@ export function printErrorEnvelope(io: CliIo, code: ErrorCode, message: string,
 }
 
 function isParseArgsError(err: unknown): err is Error {
-  return err instanceof Error && 'code' in err && typeof err.code === 'string' && err.code.startsWith('ERR_PARSE_ARGS')
+  return (
+    err instanceof Error &&
+    'code' in err &&
+    typeof err.code === 'string' &&
+    err.code.startsWith('ERR_PARSE_ARGS')
+  )
 }
 
 /** Prints the envelope for any failure and picks the exit code. */
@@ -156,7 +161,12 @@ export function parsePrepareTarget(values: { pr?: string; base?: string; head?:
 export async function runPrepare(ctx: AppContext, argv: string[], io: CliIo): Promise<number> {
   const { values } = parseArgs({
     args: argv,
-    options: { pr: { type: 'string' }, base: { type: 'string' }, head: { type: 'string' }, force: { type: 'boolean' } },
+    options: {
+      pr: { type: 'string' },
+      base: { type: 'string' },
+      head: { type: 'string' },
+      force: { type: 'boolean' },
+    },
     strict: true,
   })
   const target = parsePrepareTarget(values)
@@ -194,7 +204,9 @@ export async function runValidate(ctx: AppContext, argv: string[], io: CliIo): P
   })
   const file = positionals[0]
   if (file === undefined || positionals.length > 1) {
-    throw new UsageError('validate takes one file: pr-review validate <model.json|review.json> --canvas <dir>')
+    throw new UsageError(
+      'validate takes one file: pr-review validate <model.json|review.json> --canvas <dir>'
+    )
   }
   if (values.canvas === undefined) {
     throw new UsageError('validate needs --canvas <dir> (the directory prepare printed)')
@@ -202,7 +214,11 @@ export async function runValidate(ctx: AppContext, argv: string[], io: CliIo): P
   const context = await readContext(path.resolve(values.canvas))
   const text = await readText(path.resolve(file))
   if (text === null) {
-    throw new PublishError('NOT_FOUND', `${file} does not exist`, 'pass the model.json or review.json to check')
+    throw new PublishError(
+      'NOT_FOUND',
+      `${file} does not exist`,
+      'pass the model.json or review.json to check'
+    )
   }
   const fixed = values.fix === true ? await fixTitles(path.resolve(file), text, context) : { text, trims: [] }
   const report = await validateFile(ctx, parseModelText(fixed.text, path.basename(file)), context)
@@ -214,7 +230,9 @@ export async function runValidate(ctx: AppContext, argv: string[], io: CliIo): P
     if (trim.outcome === 'fixed') {
       io.stdout(`fixed ${trim.where}: "${trim.from}" -> "${trim.to}"`)
     } else {
-      io.stdout(`unfixable ${trim.where}: ${trim.length} visible chars, cap ${trim.cap}, ${trim.reason}; rewrite by hand`)
+      io.stdout(
+        `unfixable ${trim.where}: ${trim.length} visible chars, cap ${trim.cap}, ${trim.reason}; rewrite by hand`
+      )
     }
   }
   if (report.ok) {
@@ -277,7 +295,9 @@ export async function runPublish(ctx: AppContext, argv: string[], io: CliIo): Pr
   })
   const canvasDir = positionals[0]
   if (canvasDir === undefined || positionals.length > 1) {
-    throw new UsageError('publish takes one directory: pr-review publish <canvasDir> --agent <id> --harness <id>')
+    throw new UsageError(
+      'publish takes one directory: pr-review publish <canvasDir> --agent <id> --harness <id>'
+    )
   }
   if (values.agent === undefined || values.agent === '') {
     throw new UsageError('publish needs --agent <id>')
@@ -312,7 +332,11 @@ export interface InstallSkillEnv {
 export async function runInstallSkill(env: InstallSkillEnv, argv: string[], io: CliIo): Promise<number> {
   const { values } = parseArgs({
     args: argv,
-    options: { 'claude-dir': { type: 'string' }, 'codex-dir': { type: 'string' }, force: { type: 'boolean' } },
+    options: {
+      'claude-dir': { type: 'string' },
+      'codex-dir': { type: 'string' },
+      force: { type: 'boolean' },
+    },
     strict: true,
   })
   const resolve = (flag: string | undefined, fallback: string): string =>
@@ -357,7 +381,11 @@ export async function runExport(ctx: AppContext, argv: string[], io: CliIo): Pro
     strict: true,
   })
   const target = await resolveHead(ctx, values)
-  const result = await exportCanvas(ctx, { headSha: target.headSha, prNumber: target.prNumber, out: values.out })
+  const result = await exportCanvas(ctx, {
+    headSha: target.headSha,
+    prNumber: target.prNumber,
+    out: values.out,
+  })
   printJson(io, result)
   io.stderr(`drag ${result.path} into the pull request description or a comment`)
   return EXIT.ok
@@ -375,7 +403,11 @@ async function readZipFile(zipPath: string, shown: string): Promise<Uint8Array>
   } catch {
     throw new PublishError('NOT_FOUND', `${shown} does not exist`, 'pass the canvas zip to import')
   }
-  const tooLarge = new AppError('CANVAS_TOO_LARGE', `${shown} is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`, 413)
+  const tooLarge = new AppError(
+    'CANVAS_TOO_LARGE',
+    `${shown} is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`,
+    413
+  )
   try {
     // One byte past the cap is read, so a file of exactly the cap still fits and anything longer
     // is refused without the rest of it ever being in memory.

package/src/config.ts

@@ -47,7 +47,11 @@ export async function resolveRepoRoot(git: Git): Promise<string> {
     return await git.topLevel()
   } catch (err) {
     if (err instanceof GitError) {
-      throw new ConfigError('NOT_A_REPO', 'not inside a git repository', 'run from a clone or pass --repo <dir>')
+      throw new ConfigError(
+        'NOT_A_REPO',
+        'not inside a git repository',
+        'run from a clone or pass --repo <dir>'
+      )
     }
     throw err
   }
@@ -72,7 +76,11 @@ export function parseGithubRemote(url: string): Repo | null {
 export async function resolveGithubRepo(git: Git): Promise<Repo> {
   const url = await git.remoteUrl('origin')
   if (url === null) {
-    throw new ConfigError('NO_ORIGIN', 'the repository has no "origin" remote', 'add one that points at GitHub')
+    throw new ConfigError(
+      'NO_ORIGIN',
+      'the repository has no "origin" remote',
+      'add one that points at GitHub'
+    )
   }
   const repo = parseGithubRemote(url)
   if (repo === null) {
@@ -90,7 +98,11 @@ export function parseChatOverrides(flags: ServeFlags): SettingsOverrides {
   const overrides: SettingsOverrides = {}
   if (flags.agent !== undefined) {
     if (!isChatAgent(flags.agent)) {
-      throw new ConfigError('BAD_REQUEST', `unknown chat agent: ${flags.agent}`, 'use --agent claude or --agent codex')
+      throw new ConfigError(
+        'BAD_REQUEST',
+        `unknown chat agent: ${flags.agent}`,
+        'use --agent claude or --agent codex'
+      )
     }
     overrides.agent = flags.agent
   }

package/src/contract/comments.ts

@@ -79,7 +79,9 @@ export const PostCommentInputSchema = z.discriminatedUnion('kind', [
 export type PostCommentInput = z.infer<typeof PostCommentInputSchema>
 
 /** The posted comment: a review comment for inline and reply, an issue comment for PR-level. */
-export type PostCommentResult = { kind: 'review'; comment: ReviewComment } | { kind: 'issue'; comment: IssueComment }
+export type PostCommentResult =
+  | { kind: 'review'; comment: ReviewComment }
+  | { kind: 'issue'; comment: IssueComment }
 
 // The proposed-comment block a chat answer can carry. The parser lives in
 // static/js/proposed-comment.js so the browser loads the same code without a bundler.

package/src/contract/generation-context.ts

@@ -57,7 +57,9 @@ export const GenerationContextSchema = z.object({
   }),
   /** The globs that make a file a test here. Defaulted, so a context written before this
    * field existed still reads. */
-  tests: z.object({ patterns: z.array(z.string().min(1)) }).default(() => ({ patterns: [...DEFAULT_TEST_PATTERNS] })),
+  tests: z
+    .object({ patterns: z.array(z.string().min(1)) })
+    .default(() => ({ patterns: [...DEFAULT_TEST_PATTERNS] })),
   /** At most `generation.smallPrHunks` hunks: one layer unless concerns differ, fewer annotations. */
   smallPr: z.boolean(),
   /** More than 400 files or 50 000 changed lines: the prompt inlines nothing and tightens the caps. */

package/src/contract/review-artifact.ts

@@ -48,7 +48,9 @@ function mapCaps(fn: (key: keyof TextCaps) => number): TextCaps {
 }
 
 /** The project config may raise or lower a cap; the result is what the validator and the prompt use. */
-export function effectiveCaps(overrides: { [K in keyof TextCaps]?: number | undefined } | undefined): TextCaps {
+export function effectiveCaps(
+  overrides: { [K in keyof TextCaps]?: number | undefined } | undefined
+): TextCaps {
   return mapCaps(key => overrides?.[key] ?? TEXT_CAPS[key])
 }
 
@@ -162,13 +164,17 @@ function text(caps: Caps, key: keyof TextCaps): z.ZodString {
 
 function textOrEmpty(caps: Caps, key: keyof TextCaps): z.ZodString {
   const visibleCap = caps[key] / HARD_CAP_FACTOR
-  const diagrams = key === 'summary' || key === 'rationale'
-    ? ' Mermaid fences count toward the separate diagram cap, not this prose cap.'
-    : ''
-  return z.string().max(caps[key]).meta({
-    description: `At most ${visibleCap} visible characters. Link targets, backticks, and code-fence lines do not count. maxLength is only the raw Markdown ceiling.${diagrams}`,
-    'x-visibleMaxLength': visibleCap,
-  })
+  const diagrams =
+    key === 'summary' || key === 'rationale'
+      ? ' Mermaid fences count toward the separate diagram cap, not this prose cap.'
+      : ''
+  return z
+    .string()
+    .max(caps[key])
+    .meta({
+      description: `At most ${visibleCap} visible characters. Link targets, backticks, and code-fence lines do not count. maxLength is only the raw Markdown ceiling.${diagrams}`,
+      'x-visibleMaxLength': visibleCap,
+    })
 }
 
 export function testEntrySchema(caps: Caps) {

package/src/contract/state.ts

@@ -25,7 +25,9 @@ export const PrStateSchema = z.object({
    */
   reviewedHeadSha: z.string().optional(),
   hiddenThreads: z.record(z.string(), z.object({ at: z.string() })),
-  posted: z.array(z.object({ commentId: z.number().int(), pointFingerprint: z.string().optional(), at: z.string() })),
+  posted: z.array(
+    z.object({ commentId: z.number().int(), pointFingerprint: z.string().optional(), at: z.string() })
+  ),
   dismissed: z.record(z.string(), z.object({ at: z.string(), reason: z.string().optional() })),
   chat: z.object({ threads: z.array(ChatThreadSchema), activeThread: z.string().optional() }),
   updatedAt: z.string(),

package/src/git/diff-collector.ts

@@ -79,7 +79,8 @@ export function parseBlock(lines: string[]): Omit<CollectedFile, 'key'> | null {
     return null
   }
 
-  const isBinary = header.some(l => l.startsWith('Binary files ')) || header.some(l => l === 'GIT binary patch')
+  const isBinary =
+    header.some(l => l.startsWith('Binary files ')) || header.some(l => l === 'GIT binary patch')
   let status: FileStatus
   if (renameFrom !== null) {
     status = 'renamed'

package/src/git/git.ts

@@ -62,10 +62,15 @@ interface ExecResult {
 /** Runs git with an argument array; never a shell. */
 export function execGit(cwd: string, args: string[]): Promise<ExecResult> {
   return new Promise(resolve => {
-    execFile('git', args, { cwd, encoding: 'buffer', maxBuffer: 256 * 1024 * 1024 }, (error, stdout, stderr) => {
-      const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0
-      resolve({ stdout, stderr: stderr.toString('utf8'), code })
-    })
+    execFile(
+      'git',
+      args,
+      { cwd, encoding: 'buffer', maxBuffer: 256 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0
+        resolve({ stdout, stderr: stderr.toString('utf8'), code })
+      }
+    )
   })
 }
 

package/src/github/capabilities.ts

@@ -10,7 +10,11 @@ const RepoBodySchema = z.object({
 })
 
 /** What a page assumes before the probe answers: posting is tried and GitHub decides. */
-export const UNKNOWN_CAPABILITIES: Capabilities = { canComment: 'unknown', tokenKind: 'unprobed', login: null }
+export const UNKNOWN_CAPABILITIES: Capabilities = {
+  canComment: 'unknown',
+  tokenKind: 'unprobed',
+  login: null,
+}
 
 export const SCOPE_HINT = 'gh auth refresh -h github.com -s repo'
 

package/src/github/comments.ts

@@ -110,9 +110,12 @@ export async function fetchComments(
     fetchAllPages(gh, `${base}/issues/${number}/comments`),
   ])
   const reviews = (await fetchAllPages(gh, `${base}/pulls/${number}/reviews`)).flatMap(raw => {
-    const review = GhIssueCommentSchema.omit({ created_at: true }).extend({
-      submitted_at: z.string().nullable().optional(), state: z.string(),
-    }).parse(raw)
+    const review = GhIssueCommentSchema.omit({ created_at: true })
+      .extend({
+        submitted_at: z.string().nullable().optional(),
+        state: z.string(),
+      })
+      .parse(raw)
     if (!review.submitted_at || review.state === 'PENDING') return []
     return [{ ...mapIssueComment({ ...review, created_at: review.submitted_at }), state: review.state }]
   })

package/src/github/gh.ts

@@ -140,14 +140,24 @@ export function createGitHubClient(exec: GhExec = execGh): GitHubClient {
       }
       const r = await exec(args)
       if (r.code !== 0) {
-        throw new GitHubApiError(path, r.missingBinary ? 'gh: command not found' : r.stderr, r.code, r.missingBinary)
+        throw new GitHubApiError(
+          path,
+          r.missingBinary ? 'gh: command not found' : r.stderr,
+          r.code,
+          r.missingBinary
+        )
       }
       return JSON.parse(r.stdout) as unknown
     },
     apiWithHeaders: async path => {
       const r = await exec(['api', '-i', '--method', 'GET', path])
       if (r.code !== 0) {
-        throw new GitHubApiError(path, r.missingBinary ? 'gh: command not found' : r.stderr, r.code, r.missingBinary)
+        throw new GitHubApiError(
+          path,
+          r.missingBinary ? 'gh: command not found' : r.stderr,
+          r.code,
+          r.missingBinary
+        )
       }
       return parseIncludedResponse(r.stdout)
     },
@@ -155,7 +165,12 @@ export function createGitHubClient(exec: GhExec = execGh): GitHubClient {
       // The payload goes over stdin, so no comment text ever appears in an argument list.
       const r = await exec(['api', '--method', 'POST', path, '--input', '-'], { input: JSON.stringify(body) })
       if (r.code !== 0) {
-        throw new GitHubApiError(path, r.missingBinary ? 'gh: command not found' : r.stderr, r.code, r.missingBinary)
+        throw new GitHubApiError(
+          path,
+          r.missingBinary ? 'gh: command not found' : r.stderr,
+          r.code,
+          r.missingBinary
+        )
       }
       return JSON.parse(r.stdout) as unknown
     },

package/src/github/post-comment.ts

@@ -81,7 +81,10 @@ export function commentRequest(
       return { path: `${base}/pulls/${number}/comments`, body }
     }
     case 'reply':
-      return { path: `${base}/pulls/${number}/comments/${input.inReplyToId}/replies`, body: { body: input.body } }
+      return {
+        path: `${base}/pulls/${number}/comments/${input.inReplyToId}/replies`,
+        body: { body: input.body },
+      }
     case 'issue':
       return { path: `${base}/issues/${number}/comments`, body: { body: input.body } }
   }

package/src/github/pr.ts

@@ -100,7 +100,10 @@ export function prBaseRef(number: number): string {
  * it is local once the base was fetched). Today's base tip would contain the PR and give an
  * empty diff.
  */
-export async function fetchPrRefs(git: Git, meta: PrMeta): Promise<{ headSha: string; mergeBaseSha: string }> {
+export async function fetchPrRefs(
+  git: Git,
+  meta: PrMeta
+): Promise<{ headSha: string; mergeBaseSha: string }> {
   await git.fetch('origin', [
     `+pull/${meta.number}/head:${prHeadRef(meta.number)}`,
     `+refs/heads/${meta.baseRef}:${prBaseRef(meta.number)}`,

package/src/github/threads.ts

@@ -33,7 +33,11 @@ export const THREADS_QUERY = `query($owner: String!, $name: String!, $number: In
  * The ids of every review comment that sits in a resolved thread. REST has no resolved flag,
  * so this one GraphQL query is joined to the REST comments by id.
  */
-export async function fetchResolvedCommentIds(gh: GitHubClient, repo: Repo, number: number): Promise<Set<number>> {
+export async function fetchResolvedCommentIds(
+  gh: GitHubClient,
+  repo: Repo,
+  number: number
+): Promise<Set<number>> {
   const resolved = new Set<number>()
   let after: string | null = null
   for (;;) {

package/src/project-config.ts

@@ -36,14 +36,16 @@ const capsShape = {
   diagram: cap(),
 } satisfies Record<keyof TextCaps, z.ZodOptional<z.ZodNumber>>
 
-export const PromptOverridesSchema = z.object({
-  'generation-format.md': z.string().min(1).optional(),
-  'generation-strict.md': z.string().min(1).optional(),
-  'generation-surfacing.md': z.string().min(1).optional(),
-  'quality-standards.md': z.string().min(1).optional(),
-  'layering-guidance.md': z.string().min(1).optional(),
-  'chat-seed.md': z.string().min(1).optional(),
-}).strict()
+export const PromptOverridesSchema = z
+  .object({
+    'generation-format.md': z.string().min(1).optional(),
+    'generation-strict.md': z.string().min(1).optional(),
+    'generation-surfacing.md': z.string().min(1).optional(),
+    'quality-standards.md': z.string().min(1).optional(),
+    'layering-guidance.md': z.string().min(1).optional(),
+    'chat-seed.md': z.string().min(1).optional(),
+  })
+  .strict()
 export type PromptOverrides = z.infer<typeof PromptOverridesSchema>
 
 export const ProjectConfigSchema = z.object({
@@ -119,7 +121,8 @@ export function mergeProjectConfig(raw: unknown): { config: ProjectConfig; warni
   const generation: ProjectConfig['generation'] = {
     mode: user.generation?.mode ?? DEFAULT_PROJECT_CONFIG.generation.mode,
     maxRepairRounds: user.generation?.maxRepairRounds ?? DEFAULT_PROJECT_CONFIG.generation.maxRepairRounds,
-    inlineDiffMaxLines: user.generation?.inlineDiffMaxLines ?? DEFAULT_PROJECT_CONFIG.generation.inlineDiffMaxLines,
+    inlineDiffMaxLines:
+      user.generation?.inlineDiffMaxLines ?? DEFAULT_PROJECT_CONFIG.generation.inlineDiffMaxLines,
     smallPrHunks: user.generation?.smallPrHunks ?? DEFAULT_PROJECT_CONFIG.generation.smallPrHunks,
   }
   if (user.generation?.caps !== undefined) {

package/src/prompt-files.ts

@@ -15,9 +15,10 @@ export async function loadPromptFile(
   project?: ProjectPrompts
 ): Promise<string> {
   const override = project?.overrides?.[name]
-  const file = project !== undefined && override !== undefined
-    ? path.resolve(project.repoRoot, override)
-    : path.join(dir, name)
+  const file =
+    project !== undefined && override !== undefined
+      ? path.resolve(project.repoRoot, override)
+      : path.join(dir, name)
   try {
     return await readFile(file, 'utf8')
   } catch (cause) {

package/src/review/doctor.ts

@@ -88,7 +88,11 @@ export async function checkSkill(
     }
   }
   if (stale.length > 0) {
-    return { ok: false, detail: `outdated or modified skill: ${stale.join(', ')}`, hint: 'run `pr-review install-skill`' }
+    return {
+      ok: false,
+      detail: `outdated or modified skill: ${stale.join(', ')}`,
+      hint: 'run `pr-review install-skill`',
+    }
   }
   if (found.length === 0) {
     return {
@@ -113,7 +117,10 @@ async function checkAcpx(deps: DoctorDeps): Promise<DoctorCheck> {
 }
 
 /** Runs core checks and, with allChecks, checks acpx for AI Chat. */
-export async function runDoctorChecks(deps: DoctorDeps, options: { allChecks?: boolean } = {}): Promise<DoctorReport> {
+export async function runDoctorChecks(
+  deps: DoctorDeps,
+  options: { allChecks?: boolean } = {}
+): Promise<DoctorReport> {
   let repoRoot: string | null = null
   let git: DoctorCheck
   try {

package/src/review/normalize.ts

@@ -195,7 +195,9 @@ export function artifactToModelOutput(artifact: ReviewArtifact): ModelOutput {
     summary: artifact.summary,
     layers: artifact.layers.map(layer => {
       const { id: _id, risk, files, ...rest } = layer
-      const modelRisk = risk.filter(r => r.source === 'model').map(r => ({ label: r.label, reason: r.reason ?? '' }))
+      const modelRisk = risk
+        .filter(r => r.source === 'model')
+        .map(r => ({ label: r.label, reason: r.reason ?? '' }))
       const out: ModelLayer = { ...rest, files: files.map(({ isTest: _isTest, ...f }) => f) }
       if (modelRisk.length > 0) {
         out.risk = modelRisk

package/src/review/prepare.ts

@@ -37,7 +37,12 @@ async function resolvePr(ctx: AppContext, number: number, log: PrepareOptions['l
 }
 
 /** A change set before a PR exists: the refs must already be in the clone. */
-async function resolveRefs(ctx: AppContext, base: string, head: string, log: PrepareOptions['log']): Promise<Pr> {
+async function resolveRefs(
+  ctx: AppContext,
+  base: string,
+  head: string,
+  log: PrepareOptions['log']
+): Promise<Pr> {
   log('fetch-refs')
   const headSha = await ctx.git.revParse(head)
   const mergeBaseSha = await ctx.git.mergeBase(base, headSha)
@@ -93,7 +98,11 @@ async function clearCanvasDir(canvasDir: string): Promise<void> {
   }
 }
 
-export async function prepare(ctx: AppContext, target: PrepareTarget, opts: PrepareOptions): Promise<PrepareResult> {
+export async function prepare(
+  ctx: AppContext,
+  target: PrepareTarget,
+  opts: PrepareOptions
+): Promise<PrepareResult> {
   const pr =
     target.kind === 'pr'
       ? await resolvePr(ctx, target.number, opts.log)
@@ -116,7 +125,8 @@ export async function prepare(ctx: AppContext, target: PrepareTarget, opts: Prep
   const derived = await ctx.derived.ensure(pr.headSha, pr.mergeBaseSha)
   const additions = derived.files.reduce((n, f) => n + f.additions, 0)
   const deletions = derived.files.reduce((n, f) => n + f.deletions, 0)
-  const fullPr: Pr = target.kind === 'pr' ? pr : { ...pr, additions, deletions, changedFiles: derived.files.length }
+  const fullPr: Pr =
+    target.kind === 'pr' ? pr : { ...pr, additions, deletions, changedFiles: derived.files.length }
   const derivedDir = ctx.derived.derivedDir(pr.headSha)
   const config = ctx.projectConfig.config
 
@@ -152,14 +162,20 @@ export async function prepare(ctx: AppContext, target: PrepareTarget, opts: Prep
     largePr: isLargePr({ files: derived.files.length, additions, deletions }),
     preparedAt: ctx.now().toISOString(),
   }
-  const sources = opts.promptSources ?? (await loadPromptSources(undefined, {
-    repoRoot: ctx.config.repoRoot,
-    overrides: ctx.projectConfig.config.prompts,
-  }))
+  const sources =
+    opts.promptSources ??
+    (await loadPromptSources(undefined, {
+      repoRoot: ctx.config.repoRoot,
+      overrides: ctx.projectConfig.config.prompts,
+    }))
   await clearCanvasDir(canvasDir)
   await writeTextAtomic(promptPath, renderPrompt(context, derived.patches, sources))
   await writeJsonAtomic(contextPath, context)
   // The log keeps the whole history; publish counts attempts from this line on.
-  await appendFile(path.join(canvasDir, 'publish.log'), `${context.preparedAt} prepared ${pr.headSha}\n`, 'utf8')
+  await appendFile(
+    path.join(canvasDir, 'publish.log'),
+    `${context.preparedAt} prepared ${pr.headSha}\n`,
+    'utf8'
+  )
   return { ...result, status: 'prepared' }
 }

package/src/review/prompt.ts

@@ -71,7 +71,9 @@ function configuredLayersMarkdown(ctx: GenerationContext): string {
   return ctx.defaultLayers
     .map((l, i) => {
       const paths =
-        l.paths === undefined || l.paths.length === 0 ? '' : ` Path hints: ${l.paths.map(p => `\`${p}\``).join(', ')}.`
+        l.paths === undefined || l.paths.length === 0
+          ? ''
+          : ` Path hints: ${l.paths.map(p => `\`${p}\``).join(', ')}.`
       return `${i + 1}. \`${l.id}\` **${l.title}** — ${l.description}${paths}`
     })
     .join('\n')
@@ -196,7 +198,11 @@ export function schemaMarkdown(ctx: GenerationContext): string {
 }
 
 /** Selects one task and fills its data and format placeholders before the generator sees it. */
-export function renderPrompt(ctx: GenerationContext, patches: Record<string, string>, sources: PromptSources): string {
+export function renderPrompt(
+  ctx: GenerationContext,
+  patches: Record<string, string>,
+  sources: PromptSources
+): string {
   const tokens: Record<string, string> = {
     TARGET_WORD: ctx.target.kind === 'pr' ? 'pull request' : 'change set',
     META: metaMarkdown(ctx),

package/src/review/publish.ts

@@ -75,7 +75,11 @@ async function readModel(canvasDir: string): Promise<{ raw: unknown } | { error:
   const file = path.join(canvasDir, 'model.json')
   const text = await readText(file)
   if (text === null) {
-    throw new PublishError('NOT_FOUND', `${file} does not exist`, 'write the model output there and publish again')
+    throw new PublishError(
+      'NOT_FOUND',
+      `${file} does not exist`,
+      'write the model output there and publish again'
+    )
   }
   return parseModelText(text, 'model.json')
 }
@@ -141,7 +145,11 @@ export async function validationInput(
   }
 }
 
-export function buildManifest(context: GenerationContext, artifact: ReviewArtifact, version: string): CanvasManifest {
+export function buildManifest(
+  context: GenerationContext,
+  artifact: ReviewArtifact,
+  version: string
+): CanvasManifest {
   const manifest: CanvasManifest = {
     formatVersion: 1,
     tool: { name: 'pr-review', version },
@@ -159,7 +167,11 @@ export function buildManifest(context: GenerationContext, artifact: ReviewArtifa
   return manifest
 }
 
-export async function publish(ctx: AppContext, canvasDir: string, opts: PublishOptions): Promise<PublishResult> {
+export async function publish(
+  ctx: AppContext,
+  canvasDir: string,
+  opts: PublishOptions
+): Promise<PublishResult> {
   const context = await readContext(canvasDir)
   if (!opts.allowStale) {
     const head = await currentHead(ctx, context)

package/src/review/trim-caps.ts

@@ -77,7 +77,10 @@ interface TitledOutput {
  * Titles only: a rationale or a body is prose a reader will read, and cutting it is the author's
  * call, not the tool's.
  */
-export function applyTitleTrims(output: unknown, caps: { layerTitle: number; pointTitle: number }): TitleTrim[] {
+export function applyTitleTrims(
+  output: unknown,
+  caps: { layerTitle: number; pointTitle: number }
+): TitleTrim[] {
   const trims: TitleTrim[] = []
   const trim = (where: string, holder: { title?: string }, cap: number): void => {
     if (typeof holder.title !== 'string') {
@@ -89,11 +92,12 @@ export function applyTitleTrims(output: unknown, caps: { layerTitle: number; poi
       holder.title = trimmed
     } else if (visibleLength(holder.title) > cap) {
       const match = EXPLAINER.exec(holder.title.trim().replace(/\s+/g, ' '))
-      const reason = match === null
-        ? 'no explainer separator (:, —, – or -) to drop'
-        : match.index === 0
-          ? 'dropping the explainer would leave an empty title'
-          : 'the title before the explainer still exceeds the cap'
+      const reason =
+        match === null
+          ? 'no explainer separator (:, —, – or -) to drop'
+          : match.index === 0
+            ? 'dropping the explainer would leave an empty title'
+            : 'the title before the explainer still exceeds the cap'
       trims.push({ outcome: 'unfixable', where, length: visibleLength(holder.title), cap, reason })
     }
   }