negative-space

1import { atom, derive, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { NegativeTrigger, TestDigest } from '../types'
5import { candidatesOf, digestOf, isTestPath, KIND_LABEL, keyOf, requestOf, summaryOf, triggersOf, withTest } from './space'
6
7const triggers = atom({ plugin: 'negative-space', key: 'triggers' } as const, [] as NegativeTrigger[])
8const tests = atom({ plugin: 'negative-space', key: 'tests' } as const, {} as Record<string, TestDigest>)
9const dismissed = atom({ plugin: 'negative-space', key: 'dismissed' } as const, [] as string[])
10const isShown = atom({ plugin: 'negative-space', key: 'isShown' } as const, false)
11
12const KEEP = 200
13
14type Edit = { path: string; before: string; after: string }
15
16function editsOf(tool: string, input: Record<string, unknown>, written: string | undefined): Edit[] {
17  const path = typeof input.file_path === 'string' ? input.file_path : undefined
18  if (path === undefined) return []
19  if (tool === 'Edit') return [{ path, before: String(input.old_string ?? ''), after: String(input.new_string ?? '') }]
20  if (tool === 'MultiEdit' && Array.isArray(input.edits)) {
21    return (input.edits as Record<string, unknown>[]).map(one => ({ path, before: String(one.old_string ?? ''), after: String(one.new_string ?? '') }))
22  }
23  if (tool === 'Write') return [{ path, before: written ?? '', after: String(input.content ?? '') }]
24  return []
25}
26
27// Counted again only when a trigger, a test or a dismissal changed: the band reads it at every draw.
28const candidates = derive([triggers, tests, dismissed], candidatesOf)
29const open = ($: EngineInterface) => read($, candidates)
30
31export const register: Register = on => {
32  on('session.start', async ($, e, next) => {
33    await $.command.register({ name: 'negative-space', description: '認可・入力検証・エラー処理の追加に対し、拒否ケースや境界値のテスト不足候補を一覧' })
34    return next(e)
35  })
36
37  on('tool.call', async ($, e, next) => {
38    const tool = String(e.tool)
39    if (tool !== 'Edit' && tool !== 'Write' && tool !== 'MultiEdit') return next(e)
40    const input = e as unknown as Record<string, unknown>
41    const path = typeof input.file_path === 'string' ? input.file_path : undefined
42    if (path === undefined) return next(e)
43    // The whole file before and after, so a trigger knows the function it sits in.
44    const before = await $.fs.read(path).then(String).catch(() => undefined)
45
46    const ran = await next(e)
47    if (ran.deny !== undefined || ran.isError === true) return ran
48
49    const after = await $.fs.read(path).then(String).catch(() => undefined)
50    const at = await $.clock.now()
51    for (const one of after !== undefined ? [{ path, before: before ?? '', after }] : editsOf(tool, input, before)) {
52      if (isTestPath(one.path)) {
53        // What the test says now: the file as it stands, or an Edit's new text added to what was seen.
54        const known = await read($, triggers)
55        const isWhole = after !== undefined || tool === 'Write'
56        await update($, tests, all => withTest(all, one.path, digestOf(one.after), isWhole, known))
57        continue
58      }
59      const found = triggersOf(one.path, one.before, one.after, at)
60      if (found.length === 0) continue
61      await update($, triggers, list => {
62        const fresh = found.filter(f => !list.some(old => keyOf(old) === keyOf(f)))
63        return [...list, ...fresh].slice(-KEEP)
64      })
65    }
66    return ran
67  }).catch(($, e, next) => next(e)) // an observer: a failure here never changes the call
68
69  // A test Claude reads counts too: what it already covers is not asked for again.
70  on('tool.call', { tool: 'Read' }, async ($, e, next) => {
71    const ran = await next(e)
72    if (ran.deny === undefined && ran.isError !== true && isTestPath(e.file_path)) {
73      // A read of the whole file says what it is now; one of a part adds to what was seen.
74      const isWhole = e.offset === undefined && e.limit === undefined
75      const known = await read($, triggers)
76      const digest = digestOf(ran.text ?? '')
77      await update($, tests, all => withTest(all, e.file_path, digest, isWhole, known))
78    }
79    return ran
80  }).catch(($, e, next) => next(e))
81
82  on('turn.complete', async ($, e, next) => {
83    if (e.agentId === undefined && (await open($)).length > 0) await update($, isShown, () => true)
84    return next(e)
85  })
86
87  on('command.run', { command: 'negative-space' }, async $ => {
88    const list = await open($)
89    const all = await read($, triggers)
90    if (all.length === 0) return { text: '🕳 このセッションの編集に、認可・入力検証・エラー処理の追加は見つかっていません。' }
91    if (list.length === 0) return { text: `🕳 契機 ${all.length}件。テスト不足の候補はありません（このセッションで触れたテストが拒否・境界の場合に触れています）。` }
92    return {
93      text: [
94        `🕳 テスト不足の候補 ${list.length}件（契機 ${all.length}件・自動推定のため見当違いもあります）`,
95        ...list.map(one => `- ${one.path}: ${KIND_LABEL[one.kind]} — ${one.ask}\n    契機: ${one.line}`),
96      ].join('\n'),
97    }
98  })
99
100  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
101    if (e.props.hasSurvey || !(await read($, isShown))) return next(e)
102    const list = await open($)
103    if (list.length === 0) return next(e)
104
105    const { Box, Button, Text } = $.ui.resolve(e)
106    const below = await next(e)
107    return (
108      <Box flexDirection="column">
109        <Box>
110          <Text color="magenta" wrap="truncate-end">{`🕳 拒否/境界のテスト不足候補 ${list.length}件: ${summaryOf(list)} `}</Text>
111          <Button key="ask" label="Claude に頼む" onPress={() => $.prompt.fill({ text: requestOf(list), mode: 'insert' })} />
112          <Button
113            key="dismiss"
114            label="不要"
115            role="dismiss"
116            onPress={async () => {
117              // What was drawn and is still open: one closed since is not dismissed, one come since not unseen.
118              const still = new Set((await open($)).map(one => one.key))
119              const drawn = list.map(one => one.key).filter(key => still.has(key))
120              await update($, dismissed, keys => [...new Set([...keys, ...drawn])])
121              await update($, isShown, () => false)
122            }}
123          />
124        </Box>
125        {below}
126      </Box>
127    )
128  })
129}
130

1// The negative space, pure: what an edit added that refuses, validates or fails, and which
2// of the tests it calls for no test this session touched has written yet.
3
4import type { NegativeTrigger, TestDigest } from '../types'
5
6const TEST_PATH = /(?:^|\/)(?:tests?|__tests__|spec|specs)\/|\.(?: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|ex|exs|scala)$/
8
9export const isTestPath = (path: string): boolean => TEST_PATH.test(path)
10export const isSourcePath = (path: string): boolean => SOURCE.test(path) && !isTestPath(path)
11
12const PATTERNS: Record<NegativeTrigger['kind'], RegExp> = {
13  auth: /\b(?:authori[sz]e\w*|authenticate\w*|isAuthenticated|requireAuth\w*|require_?login|login_required|permission\w*|[a-z]\w*Permissions?|permitted|can\?|cannot\?|forbid\w*|Forbidden\w*|Unauthori[sz]ed\w*|isAdmin|is_admin|admin_required|ownerId|owner_id|currentUser|current_user|session\.user|policy|@PreAuthorize|@Secured|@RolesAllowed)\b|\b(?:401|403)\b/,
14  validation:
15    /\b(?:validat\w*|isValid|is_valid|sanitize\w*|BadRequest\w*|ValueError|InvalidArgument\w*|ArgumentError|RangeError|ValidationError|@Valid|@NotNull|@Size|@Min|@Max|Joi\.|yup\.|z\.(?:object|string|number|array|enum|union)|field_validator|validator)\b|\b(?:400|422)\b|\.(?:min|max|length|regex|email|url|uuid|positive|nonnegative|int|nonempty)\(|\bif\b[^\n]{0,200}?(?:<=?|(?<!=)>=?)\s*-?\d|\b(?:maxLength|minLength|maximum|minimum|max_length|min_length)\s*[:=]/,
16  error:
17    /\b(?:catch|except|rescue|recover|throw|raise|panic!|reject|onError|on_error|fallback|retry|retries|timeout|ErrorBoundary)\b|\bErr\(|\breturn\s+(?:nil,\s*)?(?:err|fmt\.Errorf|errors\.New)\b/,
18}
19
20/** What a test of that kind says when it tries the refusal, the bad input or the failure. */
21const COVERS: Record<NegativeTrigger['kind'], RegExp> = {
22  auth: /\b(?:401|403|forbidden|unauthori[sz]ed|denied|deny|not allowed|permission|anonymous|guest|other user|another user|non-?admin|without (?:a )?(?:token|login|session)|logged out)\b|拒否|権限/i,
23  validation: /\b(?:invalid|rejects?|throws?|toThrow|raises|assertRaises|pytest\.raises|400|422|empty|blank|too (?:long|short|large|small)|negative|out of range|malformed|boundary)\b|不正|境界|空/i,
24  error: /\b(?:throws?|toThrow|rejects?|raises|assertRaises|pytest\.raises|fails?|failure|failing|timeout|times out|retry|Err\b|should_panic|mockRejected\w*|unavailable|500|503)\b|失敗|エラー/i,
25}
26
27export const KIND_LABEL: Record<NegativeTrigger['kind'], string> = { auth: '認可', validation: '入力検証', error: 'エラー処理' }
28
29const QUESTION: Record<NegativeTrigger['kind'], string> = {
30  auth: '権限のない/未ログイン/他人のリソースで拒否されるか',
31  validation: '不正・空・型違いの入力で拒否されるか',
32  error: '失敗（例外・タイムアウト・依存先エラー）時にどう振る舞うか',
33}
34
35const MAX_LINE = 2_000
36const clip = (text: string, max = 100) => (text.length > max ? `${text.slice(0, max - 1)}…` : text)
37
38/** Lines of `after` not matched by an equal line of `before`, trimmed, in order, each with where it stands in `after`. */
39export function addedAt(before: string, after: string): { line: string; index: number }[] {
40  const left = new Map<string, number>()
41  for (const line of before.split('\n')) left.set(line.trim(), (left.get(line.trim()) ?? 0) + 1)
42  const added: { line: string; index: number }[] = []
43  after.split('\n').forEach((raw, index) => {
44    const line = raw.trim()
45    const n = left.get(line) ?? 0
46    if (n > 0) left.set(line, n - 1)
47    else if (line !== '') added.push({ line, index })
48  })
49  return added
50}
51
52/** Lines of `after` not matched by an equal line of `before`, trimmed, in order. */
53export const addedLines = (before: string, after: string): string[] => addedAt(before, after).map(one => one.line)
54
55const isComment = (line: string) => /^(?:\/\/|\/\*|\*|#(?!\[)|--)/.test(line)
56const isImport = (line: string) => /^(?:import\b|from\s+\S+\s+import\b|use\s|require\(|#include|using\s)/.test(line)
57
58/** Numbers a line bounds by: `x > 100`, `.max(255)`, `maxLength: 20`; HTTP statuses left out. */
59export function boundsOf(line: string): number[] {
60  const found = new Set<number>()
61  const pick = (text: string | undefined) => {
62    if (text === undefined) return
63    const n = Number(text)
64    if (Number.isFinite(n) && !(n >= 400 && n < 600 && Number.isInteger(n))) found.add(n)
65  }
66  // `=>` is an arrow, not a comparison.
67  for (const m of line.matchAll(/(?:<=?|(?<!=)>=?|===?|!==?)\s*(-?\d+(?:\.\d+)?)\b/g)) pick(m[1])
68  for (const m of line.matchAll(/\b(-?\d+(?:\.\d+)?)\s*(?:<=?|>=?)(?!>)/g)) pick(m[1])
69  for (const m of line.matchAll(/\.(?:min|max|length|gte?|lte?|size)\(\s*(-?\d+(?:\.\d+)?)/g)) pick(m[1])
70  for (const m of line.matchAll(/\b(?:maxLength|minLength|maximum|minimum|max_length|min_length|max|min)\s*[:=]\s*(-?\d+(?:\.\d+)?)/g)) pick(m[1])
71  return [...found]
72}
73
74const DECLARATION =
75  /(?:\bfunction\s*\*?\s*([A-Za-z_$][\w$]*)|\b(?:def|fn)\s+([A-Za-z_]\w*)|\bfunc\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)|\b([A-Za-z_$][\w$]*)\s*[:=]\s*(?:async\s*)?(?:function\b|\([^)]*\)\s*(?::[^=]+)?=>|[A-Za-z_$][\w$]*\s*=>)|^\s*(?:(?:public|private|protected|static|async|override)\s+)*([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?::[^{]+)?\{)/
76const STOP = new Set(
77  'if else for while switch case return throw await async const let var new this self super true false null nil none undefined typeof instanceof catch try except raise rescue finally function def class import from export default value values result results error errors err req res request response status data body item items length string number boolean object array console log ok some none'.split(
78    ' ',
79  ),
80)
81
82/** The function enclosing a line of a file: the nearest declaration above it. */
83export function enclosingName(lines: readonly string[], index: number): string | undefined {
84  for (let i = index; i >= 0 && i > index - 200; i -= 1) {
85    const m = (lines[i] ?? '').match(DECLARATION)
86    const name = m?.slice(1).find(Boolean)
87    if (name !== undefined && !STOP.has(name.toLowerCase())) return name
88  }
89  return undefined
90}
91
92/** Names worth finding in a test of this line: identifiers of four letters or more, common words left out. */
93export function namesOn(line: string): string[] {
94  const found = (line.replace(/(['"`])(?:\\.|(?!\1).)*\1/g, ' ').match(/[A-Za-z_$][\w$]{3,}/g) ?? []).filter(word => !STOP.has(word.toLowerCase()))
95  return [...new Set(found)].slice(0, 5)
96}
97
98/** The triggers among the lines an edit added to a source file; `after` is the file (or the edit's text) after it. */
99export function triggersOf(path: string, before: string, after: string, at: number): NegativeTrigger[] {
100  if (!isSourcePath(path)) return []
101  const out: NegativeTrigger[] = []
102  const lines = after.split('\n')
103  for (const { line, index } of addedAt(before, after)) {
104    // A minified bundle's line is no code to test, and its length would make every pattern slow.
105    if (line.length > MAX_LINE || isComment(line) || isImport(line)) continue
106    const kinds = (['auth', 'validation', 'error'] as const).filter(kind => PATTERNS[kind].test(line))
107    if (kinds.length === 0) continue
108    // The function this very line sits in, not the first other line that reads the same.
109    const enclosing = enclosingName(lines, index)
110    const names = [...new Set([...(enclosing === undefined ? [] : [enclosing]), ...namesOn(line)])]
111    for (const kind of kinds) out.push({ kind, path, line: clip(line), bounds: kind === 'validation' ? boundsOf(line) : [], names, at })
112  }
113  return out
114}
115
116export const keyOf = (one: Pick<NegativeTrigger, 'kind' | 'path' | 'line'>): string => `${one.kind}\u0000${one.path}\u0000${one.line}`
117
118const stemOf = (path: string) => {
119  const name = path.slice(path.lastIndexOf('/') + 1)
120  return name.replace(/\.[^.]+$/, '').replace(/(?:[._-](?:test|spec))$|^test_|_test$|Tests?$/i, '').toLowerCase()
121}
122
123const MAX_WORDS = 4_000
124const MAX_NUMBERS = 1_000
125
126/**
127 * What a test's text says, for the candidates: the kinds whose case it tries, its identifiers,
128 * its numbers. Read's line numbers (`  12\t…`) are taken off first: a line number is no bound tried.
129 */
130export function digestOf(text: string): TestDigest {
131  const body = text.replace(/^[ \t]*\d+\t/gm, '')
132  const covers = (['auth', 'validation', 'error'] as const).filter(kind => COVERS[kind].test(body))
133  // A name is no longer than this: a fixture's long run of letters is no name a trigger has.
134  const words = new Set((body.match(/[A-Za-z_$][\w$]*/g) ?? []).filter(word => word.length <= 64))
135  const numbers = new Set<string>()
136  for (const m of body.matchAll(/(?<![\w.])-?\d+(?:\.\d+)?(?![\w.])/g)) {
137    numbers.add(m[0])
138    if (m[0].startsWith('-')) numbers.add(m[0].slice(1))
139  }
140  return { covers, words: [...words].slice(0, MAX_WORDS), numbers: [...numbers].slice(0, MAX_NUMBERS) }
141}
142
143/** Two looks at one test file as one: a partial read adds to what a full one saw. */
144export function mergeDigest(a: TestDigest, b: TestDigest): TestDigest {
145  return {
146    covers: [...new Set([...a.covers, ...b.covers])],
147    words: [...new Set([...a.words, ...b.words])].slice(0, MAX_WORDS),
148    numbers: [...new Set([...a.numbers, ...b.numbers])].slice(0, MAX_NUMBERS),
149  }
150}
151
152// Held from an earlier version as text, a test is read as its digest.
153const asDigest = (value: TestDigest | string): TestDigest => (typeof value === 'string' ? digestOf(value) : value)
154
155/** What the tests that speak of a source file say together: the session's tests whose name holds its stem. */
156export function testsFor(path: string, tests: Readonly<Record<string, TestDigest | string>>): TestDigest {
157  const stem = stemOf(path)
158  const covers = new Set<NegativeTrigger['kind']>()
159  const words = new Set<string>()
160  const numbers = new Set<string>()
161  // Every matching file whole: a cap here would cut the newest test, the one just written to close it.
162  for (const [test, value] of Object.entries(tests)) {
163    if (stem === '' || !stemOf(test).includes(stem)) continue
164    const one = asDigest(value)
165    for (const kind of one.covers) covers.add(kind)
166    for (const word of one.words) words.add(word)
167    for (const n of one.numbers) numbers.add(n)
168  }
169  return { covers: [...covers], words: [...words], numbers: [...numbers] }
170}
171
172// Well under the 4 MiB the engine holds a state value to: past it every write would be refused.
173export const MAX_TESTS_CHARS = 1_500_000
174
175/**
176 * The tests with one file's digest put in (`isWhole`: the file as it stands, else added to what
177 * was seen), newest last. Past MAX_TESTS_CHARS the oldest leave, those no trigger's file is
178 * tested by first: a test that closed a candidate stays while reading others.
179 */
180export function withTest(
181  all: Readonly<Record<string, TestDigest>>,
182  path: string,
183  digest: TestDigest,
184  isWhole: boolean,
185  triggers: readonly Pick<NegativeTrigger, 'path'>[] = [],
186): Record<string, TestDigest> {
187  const { [path]: had, ...others } = all
188  const put = isWhole || had === undefined ? digest : mergeDigest(asDigest(had), digest)
189  const entries: [string, TestDigest][] = [...Object.entries(others), [path, put]]
190  const stems = [...new Set(triggers.map(one => stemOf(one.path)).filter(stem => stem !== ''))]
191  const isRelevant = (test: string) => stems.some(stem => stemOf(test).includes(stem))
192  let size = JSON.stringify(Object.fromEntries(entries)).length
193  // Among tests a trigger needs, the largest leave first: a small one closing a candidate costs little to keep.
194  const sizeOf = (one: TestDigest) => JSON.stringify(one).length
195  const relevant = entries.slice(0, -1).filter(([test]) => isRelevant(test)).sort(([, a], [, b]) => sizeOf(b) - sizeOf(a))
196  const order = [...entries.slice(0, -1).filter(([test]) => !isRelevant(test)), ...relevant]
197  const gone = new Set<string>()
198  for (const [test, one] of order) {
199    if (size <= MAX_TESTS_CHARS) break
200    gone.add(test)
201    size -= JSON.stringify(one).length + test.length + 6
202  }
203  return Object.fromEntries(entries.filter(([test]) => !gone.has(test)))
204}
205
206/** One test to write: what to try, and why (the trigger line). */
207export type Candidate = { key: string; kind: NegativeTrigger['kind']; path: string; line: string; ask: string }
208
209/**
210 * The candidates the session's tests leave open: per trigger, its kind's refusal or failure
211 * case unless a test of that file says one, and each bound N unless N is in a test there.
212 */
213export function candidatesOf(
214  triggers: readonly NegativeTrigger[],
215  tests: Readonly<Record<string, TestDigest | string>>,
216  dismissed: readonly string[],
217): Candidate[] {
218  const out: Candidate[] = []
219  const seen = new Set<string>()
220  const judged = new Set<string>()
221  const skip = new Set(dismissed)
222  const byPath = new Map<string, { digest: TestDigest; words: Set<string>; numbers: Set<string> }>()
223  const testsOf = (path: string) => {
224    let held = byPath.get(path)
225    if (held === undefined) {
226      const digest = testsFor(path, tests)
227      held = { digest, words: new Set(digest.words), numbers: new Set(digest.numbers) }
228      byPath.set(path, held)
229    }
230    return held
231  }
232  for (const one of triggers) {
233    const { digest, words, numbers } = testsOf(one.path)
234    const base = keyOf(one)
235    const add = (key: string, ask: string) => {
236      if (seen.has(key) || skip.has(key)) return
237      seen.add(key)
238      out.push({ key, kind: one.kind, path: one.path, line: one.line, ask })
239    }
240    // One question per file and kind: three validation lines in a file want the same test. It is
241    // covered by a test that tries the case and names what was changed (the function, a name on
242    // a trigger line), not by a stray word somewhere in a test file.
243    const kindKey = `${one.kind}\u0000${one.path}`
244    if (!judged.has(kindKey)) {
245      judged.add(kindKey)
246      const names = triggers.filter(t => t.kind === one.kind && t.path === one.path).flatMap(t => t.names ?? [])
247      const isNamed = names.length === 0 || names.some(name => words.has(name))
248      if (!digest.covers.includes(one.kind) || !isNamed) add(kindKey, QUESTION[one.kind])
249    }
250    for (const n of one.bounds) {
251      // A decimal bound's neighbours as it is written: 1.1 asks for 0.1 and 2.1, never 0.10000000000000009.
252      const places = (String(n).split('.')[1] ?? '').length
253      const [below, above] = [n - 1, n + 1].map(v => Number(v.toFixed(places)))
254      const tried = [below, n, above].filter(v => numbers.has(String(v)))
255      if (tried.length < 2) add(`${base}\u0000${n}`, `境界値 ${below} / ${n} / ${above}`)
256    }
257  }
258  return out
259}
260
261export function summaryOf(list: readonly Candidate[]): string {
262  const files = [...new Set(list.map(one => one.path.slice(one.path.lastIndexOf('/') + 1)))]
263  const kinds = [...new Set(list.map(one => KIND_LABEL[one.kind]))]
264  return `${kinds.join('・')} (${files.slice(0, 3).join(', ')}${files.length > 3 ? ` ほか${files.length - 3}` : ''})`
265}
266
267const quoted = (line: string) => line.replace(/[\u0000-\u001F\u007F-\u009F\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, '').replace(/`/g, "'")
268
269/** The request the band puts in the prompt: the candidates as a list for Claude to check. */
270export function requestOf(list: readonly Candidate[]): string {
271  return [
272    '次の拒否ケース・境界値のテストが不足している可能性があります。既存テストで足りているものは理由を、足りないものは追加してください:',
273    // The trigger line is source text quoted as data: controls and bidi marks out, backticks made plain.
274    ...list.map(one => `- ${one.path}: ${KIND_LABEL[one.kind]} — ${one.ask}（契機: \`${quoted(one.line)}\`）`),
275  ].join('\n')
276}
277

1/** Code an edit added that calls for a test of what it refuses or where it breaks. */
2export type NegativeTrigger = {
3  /** auth: who may do it; validation: what input is taken; error: what happens when it fails. */
4  kind: 'auth' | 'validation' | 'error'
5  /** The source file, as the tool named it. */
6  path: string
7  /** The added line that triggered it, clipped. */
8  line: string
9  /** Numbers the line compares against or bounds by: each wants N-1, N and N+1 tried. */
10  bounds: number[]
11  /** What a test of it would name: the function the line sits in, and the names on the line. */
12  names: string[]
13  at: number
14}
15
16/** What a test file says, as far as the candidates ask: which cases it tries, its names and numbers. */
17export type TestDigest = {
18  /** The kinds whose refusal or failure case the file tries (`403`, `invalid`, `toThrow`…). */
19  covers: NegativeTrigger['kind'][]
20  /** The identifiers in it, each once. */
21  words: string[]
22  /** The numbers in it, each once (a negative one also without its sign). */
23  numbers: string[]
24}
25
26declare module 'claude-code' {
27  interface PluginState {
28    'negative-space': {
29      /** Triggers from this session's edits, newest last, one per path, kind and line. */
30      triggers: NegativeTrigger[]
31      /** Test file path to what it says, as this session's edits and reads have shown it. */
32      tests: Record<string, TestDigest>
33      /** Keys of candidates the person dismissed. */
34      dismissed: string[]
35      /** Whether the band is up: set when a turn ends with open candidates. */
36      isShown: boolean
37    }
38  }
39}
40