mutation-tap

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { Mutant, MutationRun } from '../types'
5import { apply, changedLines, guessCommand, isMutable, mutantsOf, scoreLine, spread, tallyOf } from './mutate'
6
7const PANE = 'mutation-tap'
8const TITLE = 'ミューテーション'
9// The store is one file for every session of the user: each copy is kept with when its run last
10// moved, so a session starting removes only copies whose run went quiet, never one running.
11const COPIES_KEY = 'copies'
12// The key an earlier version kept its single copy under.
13const LEGACY_KEY = 'copy'
14const DIR_NAME = 'claude-mutation-tap'
15// Copying a large tree (dependencies included) may take a while.
16const COPY_TIMEOUT_MS = 600_000
17// A live run moves at least this often: the copy and each test run are held to 10 minutes.
18const QUIET_MS = 30 * 60_000
19// An earlier version's copy carries only when it was made, never when its run last moved.
20const LEGACY_MS = 3 * 60 * 60_000
21// What is read of files not yet added: a scratch script or a bundle never ignored is no reason to wait.
22const MAX_NEW_FILES = 20
23const MAX_NEW_BYTES = 200_000
24// A line as kept for the pane: a minified one would otherwise ride whole, twice per mutant, in state.
25const SHOWN = 300
26const shown = (one: Mutant): Mutant => ({ ...one, original: one.original.slice(0, SHOWN), mutated: one.mutated.slice(0, SHOWN) })
27// Written at the copy's root once it is whole; a copy being removed loses it first (the folder is
28// moved aside in one step before it is deleted), so its absence says the copy is no longer whole.
29const SENTINEL = '.claude-mutation-tap'
30
31type Copies = Record<string, { at: number }>
32
33const copiesOf = async ($: EngineInterface): Promise<Copies> => {
34  const value = await $.store.get(COPIES_KEY)
35  return typeof value === 'object' && value !== null && !Array.isArray(value) ? (value as Copies) : {}
36}
37
38/** Marks a copy as in use now (or forgets it): read and written afresh, so other sessions' copies stay. */
39async function mark($: EngineInterface, dir: string, isGone = false): Promise<void> {
40  const { [dir]: _, ...others } = await copiesOf($)
41  await $.store.set(COPIES_KEY, isGone ? others : { ...others, [dir]: { at: await $.clock.now() } })
42}
43
44const run = atom({ plugin: 'mutation-tap', key: 'run' } as const, null as MutationRun | null)
45const isStopping = atom({ plugin: 'mutation-tap', key: 'isStopping' } as const, false)
46
47type Options = { max: number; timeoutMs: number; command: string }
48
49/** Changes the run in hand, if there is one. */
50const patch = ($: EngineInterface, fn: (old: MutationRun) => MutationRun) => update($, run, old => (old === null ? null : fn(old)))
51
52async function sh($: EngineInterface, root: string, argv: string[], timeoutMs = 30_000) {
53  return $.process.run(argv, { cwd: root, timeoutMs }).catch(() => undefined)
54}
55
56/**
57 * A copy of the repository to mutate, so the working tree is never touched: a copy-on-write clone
58 * where the file system has one (APFS `cp -c`, `cp --reflink`), a plain copy otherwise.
59 * Dependencies and build output come along, so the tests run as they do in the tree.
60 */
61async function makeCopy($: EngineInterface, root: string): Promise<string | undefined> {
62  const base = ((await $.env.get('TMPDIR')) || `${(await $.env.get('HOME')) ?? ''}/.cache`).replace(/\/+$/, '')
63  if (base === '' || base === '/.cache') return undefined
64  const dir = `${base}/${DIR_NAME}/${await $.clock.now()}`
65  // Kept first, so a reload or a crash mid-copy still removes it at a later start.
66  await mark($, dir)
67  const made = await $.process
68    .run(
69      [
70        '/bin/sh',
71        '-c',
72        // Compiled Python is dropped: a mutant of the same length written within one second would
73        // otherwise run the bytecode of the line before it.
74        'umask 077 && mkdir -p -- "$1" && [ -d "$1" ] && [ ! -L "$1" ] && [ -O "$1" ] && { cp -cR -- "$2"/. "$1"/ 2>/dev/null || cp -a --reflink=auto -- "$2"/. "$1"/; } && { find "$1" -name __pycache__ -type d -prune -exec rm -rf {} + 2>/dev/null; true; }',
75        'sh',
76        dir,
77        root,
78      ],
79      { timeoutMs: COPY_TIMEOUT_MS },
80    )
81    .catch(() => undefined)
82  if (made?.exitCode === 0 && (await $.fs.write(`${dir}/${SENTINEL}`, String(await $.clock.now())).then(() => true).catch(() => false))) {
83    await mark($, dir)
84    return dir
85  }
86  await removeCopy($, dir)
87  return undefined
88}
89
90/** Removes a copy this module made: only a folder under its own name, found again from the store. */
91async function removeCopy($: EngineInterface, dir: string): Promise<void> {
92  if (dir.includes(`/${DIR_NAME}/`) && !dir.includes('..')) await removeTree($, dir)
93  await mark($, dir, true)
94}
95
96/** Moves the folder aside in one step, then deletes it: a run in it sees it whole or not at all. */
97async function removeTree($: EngineInterface, dir: string): Promise<void> {
98  await $.process
99    .run(['/bin/sh', '-c', 'd="$1.removing.$$"; mv -- "$1" "$d" 2>/dev/null && rm -rf -- "$d"', 'sh', dir], { timeoutMs: 120_000 })
100    .catch(() => undefined)
101}
102
103/** Whether the copy is still whole: its root marker is there. */
104const isWhole = ($: EngineInterface, copy: string): Promise<boolean> => $.fs.exists(`${copy}/${SENTINEL}`).catch(() => false)
105
106async function testCommand($: EngineInterface, root: string, given: string): Promise<string | undefined> {
107  if (given.trim() !== '') return given.trim()
108  const names = new Set((await $.fs.list(root).catch(() => [])).map(entry => entry.name))
109  const text = (name: string) => (names.has(name) ? $.fs.read(`${root}/${name}`).then(String).catch(() => undefined) : Promise.resolve(undefined))
110  return guessCommand(names, await text('package.json'), await text('Makefile'))
111}
112
113/** One run of the tests: killed when they fail, timeout when they run past the limit. */
114async function runTests($: EngineInterface, root: string, command: string, timeoutMs: number): Promise<'pass' | 'fail' | 'timeout'> {
115  const ran = await $.process.run(['/bin/sh', '-c', `export PYTHONDONTWRITEBYTECODE=1; ${command}`], { cwd: root, timeoutMs }).catch(() => undefined)
116  if (ran === undefined) return 'timeout'
117  return ran.exitCode === 0 ? 'pass' : 'fail'
118}
119
120async function mutateAll($: EngineInterface, options: Options, given: string): Promise<void> {
121  const at = await $.clock.now()
122  const root = (await $.session.repo())?.root ?? (await $.session.cwd())
123  const fail = (note: string, command = '') =>
124    update($, run, () => ({ status: 'failed', command, root, startedAt: at, finishedAt: at, mutants: [], ran: 0, note }) as MutationRun)
125
126  // Against HEAD; in a repository with no commit yet, the working tree against the index.
127  // Paths as written, whatever the person's diff settings (mnemonicPrefix, noprefix, quotePath).
128  const gitDiff = (...rest: string[]) =>
129    sh($, root, ['git', '-c', 'core.quotePath=false', 'diff', '-U0', '--no-color', '--no-ext-diff', '--src-prefix=a/', '--dst-prefix=b/', ...rest])
130  const head = await gitDiff('HEAD')
131  const diff = head?.exitCode === 0 ? head : await gitDiff()
132  if (diff === undefined || diff.exitCode !== 0) return void (await fail('git diff を取れませんでした（git リポジトリの外？）'))
133  // A new file not yet added is changed whole: an empty list stands for every line.
134  const untracked = await sh($, root, ['git', 'ls-files', '--others', '--exclude-standard', '-z'])
135  const added: [string, number[]][] = (untracked?.exitCode === 0 ? untracked.stdout.split('\0') : [])
136    .filter(path => path !== '' && isMutable(path))
137    .slice(0, MAX_NEW_FILES)
138    .map(path => [path, []])
139  const changed = [...changedLines(diff.stdout), ...added].filter(([path]) => isMutable(path))
140  if (changed.length === 0) return void (await fail('HEAD からの変更行に、改変できるソースの行がありません（テストファイル・コメント・import は対象外）'))
141
142  const command = await testCommand($, root, given || options.command)
143  if (command === undefined) return void (await fail('テストコマンドが分かりません。/mutate <コマンド> で指定するか、testCommand を設定してください'))
144
145  await update($, isStopping, () => false)
146  await update($, run, (): MutationRun => ({ status: 'running', command, root, startedAt: at, mutants: [], ran: 0, note: 'リポジトリの複製を作成中' }))
147  $.ui.status('🧬 複製を作成中')
148  const copy = await makeCopy($, root)
149  if (copy === undefined) {
150    $.ui.status(undefined)
151    return void (await fail('リポジトリの複製を作れませんでした（TMPDIR の空き容量を確認してください）', command))
152  }
153
154  try {
155    // The mutants come from the copy, so they match the files they are written into.
156    const byLine: Mutant[][] = []
157    for (const [path, lines] of changed) {
158      const text = await $.fs.read(`${copy}/${path}`).then(String).catch(() => undefined)
159      if (text === undefined || (lines.length === 0 && text.length > MAX_NEW_BYTES)) continue
160      const all = text.split('\n')
161      for (const n of lines.length > 0 ? lines : all.map((_, i) => i + 1)) byLine.push(mutantsOf(path, n, all[n - 1] ?? ''))
162    }
163    const mutants = spread(byLine.filter(list => list.length > 0), options.max)
164    if (mutants.length === 0) return void (await fail('HEAD からの変更行に、改変できるソースの行がありません（テストファイル・コメント・import は対象外）', command))
165
166    await patch($, old => ({ ...old, mutants: mutants.map(shown), note: '変更前のテストを実行中' }))
167    $.ui.status('🧬 ベースライン実行中')
168    const baseline = await runTests($, copy, command, options.timeoutMs)
169    if (baseline !== 'pass') {
170      return void (await fail(baseline === 'timeout' ? 'テストが時間内に終わりませんでした（timeoutSec を延ばしてください）' : '改変前のテストが既に失敗しています。通る状態にしてから実行してください', command))
171    }
172
173    for (const [index, mutant] of mutants.entries()) {
174      if (await read($, isStopping)) {
175        const now = await $.clock.now()
176        await patch($, old => ({ ...old, status: 'stopped', finishedAt: now, note: '停止しました' }))
177        return
178      }
179      const file = `${copy}/${mutant.path}`
180      await mark($, copy)
181      // Tests fail in a copy taken away from under them: that is no mutant caught.
182      const gone = () => fail('実行中にリポジトリの複製が消えました（別の処理が削除した可能性）。結果は数えていません', command)
183      if (!(await isWhole($, copy))) return void (await gone())
184      const original = await $.fs.read(file).then(String).catch(() => undefined)
185      if (original === undefined) return void (await gone())
186      const mutated = apply(original, mutant)
187      let outcome: Mutant['outcome'] = 'skipped'
188      if (mutated !== undefined) {
189        await $.fs.write(file, mutated)
190        let isThere = true
191        try {
192          const result = await runTests($, copy, command, options.timeoutMs)
193          isThere = await isWhole($, copy)
194          outcome = result === 'pass' ? 'survived' : result === 'fail' ? 'killed' : 'timeout'
195        } finally {
196          if (isThere) await $.fs.write(file, original)
197        }
198        if (!isThere) return void (await gone())
199      }
200      const done = await patch($, old => ({ ...old, ran: index + 1, mutants: old.mutants.map((one, i) => (i === index ? { ...one, outcome } : one)), note: undefined }))
201      const t = tallyOf(done?.mutants ?? [])
202      $.ui.status(`🧬 ${index + 1}/${mutants.length} · 生存 ${t.survived}`)
203    }
204
205    const end = await $.clock.now()
206    const all = tallyOf((await read($, run))?.mutants ?? [])
207    // Every mutant passing is more often the tests reading another tree than tests that check nothing.
208    const note = all.survived >= 2 && all.killed === 0 && all.timeout === 0
209      ? 'すべての改変が生存しました。テストが複製ではなく元のツリーを読んでいる可能性があります（editable install・絶対パスの参照・ビルド済みの dist）'
210      : undefined
211    const finished = await patch($, old => ({ ...old, status: 'done', finishedAt: end, note }))
212    const t = tallyOf(finished?.mutants ?? [])
213    $.ui.toast(t.survived > 0 ? `🧬 テストが見逃した改変 ${t.survived}件 — /mutate show` : `🧬 すべての改変をテストが検出（${scoreLine(t)}）`)
214  } finally {
215    $.ui.status(undefined)
216    await removeCopy($, copy)
217  }
218}
219
220export const register: Register = (on, options) => {
221  const settings: Options = {
222    max: Math.max(1, Math.min(200, Number(options.maxMutants ?? 20) || 20)),
223    timeoutMs: Math.max(5, Math.min(600, Number(options.timeoutSec ?? 300) || 300)) * 1000,
224    command: typeof options.testCommand === 'string' ? options.testCommand : '',
225  }
226
227  on('session.start', async ($, e, next) => {
228    await $.command.register({
229      name: 'mutate',
230      description: 'HEAD からの変更行に限ったミューテーションテスト（/mutate [テストコマンド] · show · stop）',
231      argumentHint: '[テストコマンド | show | stop]',
232    })
233    const started = await next(e)
234    // A copy left behind by a run cut short (a reload, a crash) is removed once its run went
235    // quiet; one another session is running in is left alone.
236    const now = await $.clock.now()
237    for (const [dir, { at }] of Object.entries(await copiesOf($))) if (now - at > QUIET_MS) await removeCopy($, dir)
238    // An earlier version's copy, named by when it was made: removed once that is long past, else
239    // kept track of like this version's, so a run of that version still going is not cut short.
240    const legacy = await $.store.get(LEGACY_KEY)
241    if (typeof legacy === 'string') {
242      const made = Number(legacy.match(/\/(\d+)$/)?.[1] ?? 0)
243      if (legacy.includes(`/${DIR_NAME}/`) && !legacy.includes('..')) {
244        if (now - made > LEGACY_MS) await removeTree($, legacy)
245        else await $.store.set(COPIES_KEY, { ...(await copiesOf($)), [legacy]: { at: made + LEGACY_MS - QUIET_MS } })
246      }
247      await $.store.delete(LEGACY_KEY)
248    }
249    const last = await read($, run)
250    if (last?.status === 'running') await patch($, old => ({ ...old, status: 'stopped', note: '再読み込みで中断されました' }))
251    return started
252  })
253
254  on('command.run', { command: 'mutate' }, async ($, e) => {
255    const args = e.args.trim()
256    const current = await read($, run)
257    if (args === 'stop') {
258      if (current?.status !== 'running') return { text: '🧬 実行中のミューテーションはありません。' }
259      await update($, isStopping, () => true)
260      return { text: '🧬 今の改変が終わったら停止します。' }
261    }
262    if (args === 'show') {
263      await $.ui.open({ id: PANE, title: TITLE })
264      return { text: current === null ? '🧬 まだ実行していません。' : `🧬 ${scoreLine(tallyOf(current.mutants))}` }
265    }
266    if (current?.status === 'running') return { text: '🧬 実行中です。/mutate stop で止められます。' }
267
268    await update($, run, () => null)
269    $.clock.after(0, () => {
270      void mutateAll($, settings, args).catch(async err => {
271        $.ui.status(undefined)
272        await patch($, old => ({ ...old, status: 'failed', note: String(err) }))
273      })
274    })
275    await $.ui.open({ id: PANE, title: TITLE })
276    return { text: '🧬 ミューテーションテストを開始しました。リポジトリの複製で実行するので、作業ツリーは書き換えません。' }
277  })
278
279  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
280    const { Box, Text } = $.ui.resolve(e)
281    const shown = await read($, run)
282    if (shown === null) return <Text dimColor>準備中…</Text>
283
284    const t = tallyOf(shown.mutants)
285    const survivors = shown.mutants.filter(one => one.outcome === 'survived')
286    const room = Math.max(1, Math.floor(((e.props.scroll.bodyRows ?? 24) - 5) / 3))
287    const head =
288      shown.status === 'running'
289        ? `🧬 実行中 ${shown.ran}/${shown.mutants.length} · ${scoreLine(t)}`
290        : shown.status === 'done'
291          ? `🧬 完了 ${shown.mutants.length}件 · ${scoreLine(t)}`
292          : shown.status === 'stopped'
293            ? `🧬 停止 ${shown.ran}/${shown.mutants.length} · ${scoreLine(t)}`
294            : '🧬 実行できませんでした'
295    return (
296      <Box flexDirection="column">
297        <Text bold>{head}</Text>
298        {shown.command !== '' && <Text dimColor wrap="truncate-end">{`$ ${shown.command}`}</Text>}
299        {shown.note !== undefined && <Text color={shown.status === 'failed' ? 'red' : undefined}>{shown.note}</Text>}
300        {survivors.length > 0 && <Text color="yellow">テストが見逃した改変:</Text>}
301        {survivors.slice(0, room).map((one, index) => (
302          <Box key={`s-${index}`} flexDirection="column">
303            <Text wrap="truncate-end">{`✗ ${one.path}:${one.line}  ${one.operator}`}</Text>
304            <Text dimColor wrap="truncate-end">{`  - ${one.original}`}</Text>
305            <Text color="yellow" wrap="truncate-end">{`  + ${one.mutated}`}</Text>
306          </Box>
307        ))}
308        {survivors.length > room && <Text dimColor>{`…ほか ${survivors.length - room} 件`}</Text>}
309        {shown.status === 'done' && survivors.length === 0 && <Text color="green">見逃された改変はありません。</Text>}
310      </Box>
311    )
312  })
313}
314

1// Mutation, pure: which lines changed, the small changes worth making to them, and the
2// command that runs the project's tests.
3
4import type { Mutant } from '../types'
5
6const TEST_PATH = /(?:^|\/)(?:tests?|__tests__|spec|specs|testdata|fixtures?)\/|\.(?:test|spec)\.[cm]?[jt]sx?$|_test\.(?:go|py|rb|exs?)$|(?:^|\/)test_[^/]+\.py$|_spec\.rb$|Tests?\.(?:swift|kt|java|cs)$/
7const SOURCE = /\.(?:[cm]?[jt]sx?|py|rb|go|rs|swift|kt|java|cs|php|scala|c|cc|cpp|h|hpp)$/
8
9export const isMutable = (path: string): boolean => SOURCE.test(path) && !TEST_PATH.test(path) && !/\.d\.ts$/.test(path)
10
11/** The new-side line numbers each file's hunks touch, from `git diff -U0`. */
12export function changedLines(diff: string): Map<string, number[]> {
13  const out = new Map<string, number[]>()
14  let file: string | undefined
15  for (const line of diff.split('\n')) {
16    if (line.startsWith('+++ ')) {
17      const name = line.slice(4).trim()
18      file = name === '/dev/null' ? undefined : name.replace(/^b\//, '')
19      continue
20    }
21    const hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/)
22    if (hunk === null || file === undefined) continue
23    const start = Number(hunk[1])
24    const count = hunk[2] === undefined ? 1 : Number(hunk[2])
25    const list = out.get(file) ?? []
26    for (let n = start; n < start + count; n += 1) list.push(n)
27    out.set(file, list)
28  }
29  return out
30}
31
32/** Which characters of a line are code: not inside a string literal or a trailing comment. */
33export function codeMask(line: string, hashComments: boolean): boolean[] {
34  const mask: boolean[] = new Array(line.length).fill(true)
35  let quote: string | undefined
36  for (let i = 0; i < line.length; i += 1) {
37    const ch = line[i] as string
38    if (quote !== undefined) {
39      mask[i] = false
40      if (ch === '\\') {
41        if (i + 1 < line.length) mask[i + 1] = false
42        i += 1
43      } else if (ch === quote) quote = undefined
44      continue
45    }
46    if (ch === '"' || ch === "'" || ch === '`') {
47      quote = ch
48      mask[i] = false
49      continue
50    }
51    if ((ch === '/' && line[i + 1] === '/') || (hashComments && ch === '#')) {
52      for (let j = i; j < line.length; j += 1) mask[j] = false
53      break
54    }
55  }
56  return mask
57}
58
59type Operator = { name: string; find: RegExp; to: string | ((found: string) => string) }
60
61// Comparisons and arithmetic only with spaces around them, so generics (`Array<T>`), arrows
62// (`=>`, `->`), JSX and unary signs are left alone.
63const OPERATORS: Operator[] = [
64  { name: '===→!==', find: / === /g, to: ' !== ' },
65  { name: '!==→===', find: / !== /g, to: ' === ' },
66  { name: '==→!=', find: / == /g, to: ' != ' },
67  { name: '!=→==', find: / != /g, to: ' == ' },
68  { name: '<=→<', find: / <= /g, to: ' < ' },
69  { name: '>=→>', find: / >= /g, to: ' > ' },
70  { name: '<→<=', find: / < /g, to: ' <= ' },
71  { name: '>→>=', find: / > /g, to: ' >= ' },
72  { name: '&&→||', find: / && /g, to: ' || ' },
73  { name: '||→&&', find: / \|\| /g, to: ' && ' },
74  { name: 'and→or', find: / and /g, to: ' or ' },
75  { name: 'or→and', find: / or /g, to: ' and ' },
76  { name: '+→-', find: / \+ /g, to: ' - ' },
77  { name: '-→+', find: / - /g, to: ' + ' },
78  { name: '*→/', find: / \* /g, to: ' / ' },
79  { name: 'true→false', find: /\btrue\b/g, to: 'false' },
80  { name: 'false→true', find: /\bfalse\b/g, to: 'true' },
81  { name: 'True→False', find: /\bTrue\b/g, to: 'False' },
82  { name: 'False→True', find: /\bFalse\b/g, to: 'True' },
83  { name: '!x→x', find: /!(?=[A-Za-z_($])/g, to: '' },
84  { name: 'n→n+1', find: /(?<![\w.$])\d+(?![\w.])/g, to: found => String(Number(found) + 1) },
85]
86
87const SKIP_LINE = /^(?:import\b|export\s+(?:\*|\{[^}]*\})\s+from\b|from\s+\S+\s+import\b|use\s|#include|package\s|require\(|\/\/|\/\*|\*|#(?!\[)|--|@)/
88
89/**
90 * Every mutant of one line: each operator at each place it applies in the code part of the
91 * line. Imports, comments and decorators make none.
92 */
93export function mutantsOf(path: string, line: number, text: string): Mutant[] {
94  const trimmed = text.trim()
95  if (trimmed === '' || SKIP_LINE.test(trimmed)) return []
96  const mask = codeMask(text, /\.(?:py|rb)$/.test(path))
97  const out: Mutant[] = []
98  for (const op of OPERATORS) {
99    for (const m of text.matchAll(op.find)) {
100      const at = m.index ?? 0
101      if (!mask.slice(at, at + m[0].length).every(Boolean)) continue
102      const to = typeof op.to === 'string' ? op.to : op.to(m[0])
103      const mutated = `${text.slice(0, at)}${to}${text.slice(at + m[0].length)}`
104      if (mutated !== text) out.push({ path, line, operator: op.name, original: trimmed, mutated: mutated.trim() })
105    }
106  }
107  return out
108}
109
110/** At most `max` mutants, taken round-robin across lines so every changed line gets one first. */
111export function spread(byLine: readonly Mutant[][], max: number): Mutant[] {
112  const picked: Mutant[] = []
113  const queues = byLine.map(list => [...list])
114  while (picked.length < max && queues.some(q => q.length > 0)) {
115    for (const q of queues) {
116      const one = q.shift()
117      if (one !== undefined && picked.length < max) picked.push(one)
118    }
119  }
120  return picked
121}
122
123/** Puts a mutant into a file's text, or undefined when the line no longer reads as it did. */
124export function apply(fileText: string, mutant: Mutant): string | undefined {
125  const lines = fileText.split('\n')
126  const at = mutant.line - 1
127  const current = lines[at]
128  if (current === undefined || current.trim() !== mutant.original) return undefined
129  const indent = current.slice(0, current.length - current.trimStart().length)
130  lines[at] = `${indent}${mutant.mutated}`
131  return lines.join('\n')
132}
133
134/** The project's test command, guessed from the files at its root. */
135export function guessCommand(files: ReadonlySet<string>, packageJson: string | undefined, makefile: string | undefined): string | undefined {
136  if (makefile !== undefined && /^test\s*:/m.test(makefile)) return 'make test'
137  if (packageJson !== undefined) {
138    try {
139      const scripts = (JSON.parse(packageJson) as { scripts?: Record<string, string> }).scripts ?? {}
140      if (typeof scripts.test === 'string' && !/no test specified/.test(scripts.test)) {
141        const runner = files.has('pnpm-lock.yaml') ? 'pnpm' : files.has('yarn.lock') ? 'yarn' : files.has('bun.lockb') || files.has('bun.lock') ? 'bun run' : 'npm'
142        return `${runner} test`
143      }
144    } catch {
145      // A package.json that does not parse says nothing of the tests.
146    }
147  }
148  if (files.has('Cargo.toml')) return 'cargo test --quiet'
149  if (files.has('go.mod')) return 'go test ./...'
150  if (files.has('pyproject.toml') || files.has('pytest.ini') || files.has('setup.cfg') || files.has('tox.ini')) return 'python3 -m pytest -q -x'
151  if (files.has('Package.swift')) return 'swift test'
152  return undefined
153}
154
155export type Tally = { killed: number; survived: number; timeout: number; skipped: number; score: number | undefined }
156
157export function tallyOf(mutants: readonly Mutant[]): Tally {
158  const count = (outcome: Mutant['outcome']) => mutants.filter(one => one.outcome === outcome).length
159  const killed = count('killed')
160  const survived = count('survived')
161  const timeout = count('timeout')
162  const judged = killed + survived + timeout
163  return { killed, survived, timeout, skipped: count('skipped'), score: judged === 0 ? undefined : Math.round(((killed + timeout) / judged) * 100) }
164}
165
166export const scoreLine = (t: Tally): string =>
167  `検出 ${t.killed + t.timeout} · 生存 ${t.survived}${t.skipped > 0 ? ` · 対象外 ${t.skipped}` : ''}${t.score !== undefined ? ` · スコア ${t.score}%` : ''}`
168

1/** One small change made to a changed line, and what the tests said of it. */
2export type Mutant = {
3  /** Repository-relative path and 1-based line. */
4  path: string
5  line: number
6  /** The operator applied, as `===→!==`. */
7  operator: string
8  /** The line before and after the change, trimmed. */
9  original: string
10  mutated: string
11  /** killed: the tests failed; survived: they passed; timeout: they ran past the limit; skipped: the line had changed. */
12  outcome?: 'killed' | 'survived' | 'timeout' | 'skipped'
13}
14
15/** A /mutate run. */
16export type MutationRun = {
17  status: 'running' | 'done' | 'failed' | 'stopped'
18  command: string
19  root: string
20  startedAt: number
21  finishedAt?: number
22  mutants: Mutant[]
23  /** How many have run. */
24  ran: number
25  /** Why it failed or stopped, or a note on how it went. */
26  note?: string
27}
28
29declare module 'claude-code' {
30  interface PluginState {
31    'mutation-tap': {
32      run: MutationRun | null
33      /** Set while a run is asked to stop after the mutant in hand. */
34      isStopping: boolean
35    }
36  }
37}
38