surshar / claude-code

Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows - all through natural language commands.

		@@ -17,6 +17,7 @@
17	17	}
18	18
19	19	const kept: string[] = []
	20	+
20	21	let used = ASK_CUT_NOTE.length
21	22
22	23	for (const line of text.split('\n')) {

		@@ -20,6 +20,7 @@
20	20	const files: Types.FileStat[] = []
21	21	const stats = { filesCount: 0, linesAdded: 0, linesRemoved: 0 }
22	22	const records = stdout.split('\0')
	23	+
23	24	let at = 0
24	25
25	26	while (at < records.length) {

		@@ -41,6 +41,7 @@
41	41
42	42	async function kindOf(path: string): Promise<Types.WalkKind> {
43	43	const names = path === '' ? [] : path.split('/')
	44	+
44	45	let directory = ''
45	46
46	47	for (const [depth, name] of names.entries()) {

		@@ -43,8 +43,11 @@
43	43	let isRefreshQueued = false
44	44	let generation = 0
45	45	let bodyKey: string \| null = null
	46	+
46	47	const polled = { toplevel: '', headKey: '' }
	48	+
47	49	let model: PaneState.PaneModel = PaneState.INITIAL_MODEL
	50	+
48	51	const timers = new Map<'refresh' \| 'redraw' \| 'poll', Timer>()
49	52	const loggedBaseKinds = new Set<'ok' \| 'sad'>()
50	53

		@@ -23,6 +23,7 @@
23	23	*/
24	24	export function codeBlocksOf(hunks: readonly Git.Hunk[]): Types.CodeBody {
25	25	const blocks: Types.CodeBlock[] = []
	26	+
26	27	let chars = 0
27	28	let nodes = 0
28	29	let isTruncated = false

		@@ -19,6 +19,7 @@
19	19	maxChars: number,
20	20	): Pick<Git.FileHunks, 'hunks' \| 'isTruncated'> {
21	21	const hunks: Git.Hunk[] = []
	22	+
22	23	let rest = hunk
23	24	let isTruncated = false
24	25

		@@ -18,6 +18,7 @@
18	18	}
19	19
20	20	const characters = [...text]
	21	+
21	22	let kept = ''
22	23
23	24	for (let at = characters.length - 1; at >= 0; at--) {

		@@ -18,6 +18,7 @@
18	18
19	19	for (const [index, word] of words.entries()) {
20	20	const wordWidth = cellWidth(word)
	21	+
21	22	let rowWidth = cellWidth(rows[rows.length - 1] ?? '')
22	23
23	24	if (index !== 0) {
		@@ -39,6 +40,7 @@
39	40	}
40	41
41	42	const characters = [...word]
	43	+
42	44	let visible = cellWidth(rows[rows.length - 1] ?? '')
43	45
44	46	for (const [at, character] of characters.entries()) {

		@@ -1,0 +1,33 @@
	1	+import { describe, expect, test, tier } from 'claude-code/testing'
	2	+
	3	+import Ask from '../../hooks/ask'
	4	+import Fixtures from '../fixtures'
	5	+
	6	+tier('builtin')
	7	+
	8	+describe('fitted-ask-text-of', () => {
	9	+ test('an ask that fits rides whole', () => {
	10	+ expect(
	11	+ Ask.fittedAskTextOf(Fixtures.ASK_TEXT, Fixtures.ASK_TEXT.length),
	12	+ ).toBe(Fixtures.ASK_TEXT)
	13	+ })
	14	+
	15	+ test('an ask past the room keeps its first lines and the cut note', () => {
	16	+ const fitted = Ask.fittedAskTextOf(
	17	+ Fixtures.ASK_TEXT,
	18	+ Fixtures.ROOM_FOR_TWO_LINES,
	19	+ )
	20	+
	21	+ expect(fitted).toBe(
	22	+ `${Fixtures.ASK_LINES.slice(0, 2).join('\n')}\n${Ask.ASK_CUT_NOTE}`,
	23	+ )
	24	+
	25	+ expect(fitted?.length).toBeLessThanOrEqual(Fixtures.ROOM_FOR_TWO_LINES)
	26	+ })
	27	+
	28	+ test('an ask whose first hunk line does not fit is not attached', () => {
	29	+ expect(
	30	+ Ask.fittedAskTextOf(Fixtures.ASK_TEXT, Fixtures.ROOM_FOR_ONE_LINE),
	31	+ ).toBeUndefined()
	32	+ })
	33	+})

		@@ -1,0 +1,62 @@
	1	+import { describe, expect, test, tier } from 'claude-code/testing'
	2	+
	3	+import Backend from '../../hooks/backend'
	4	+import Fixtures from '../fixtures'
	5	+
	6	+tier('builtin')
	7	+
	8	+describe('backend-of', () => {
	9	+ test('as published: no probes, so git or nothing', async () => {
	10	+ const inGit = Fixtures.gitHostOf()
	11	+ const outside = Fixtures.recordingBackendHostOf({})
	12	+
	13	+ expect((await Backend.backendOf(inGit.host, []))?.words.lister).toBe('git')
	14	+ expect(await Backend.backendOf(outside.host, [])).toBeNull()
	15	+ expect([inGit.programs, outside.programs]).toEqual([['git'], ['git']])
	16	+ })
	17	+
	18	+ test('a declining probe leaves a git working tree to git', async () => {
	19	+ const declining = Fixtures.recordingProbeOf(null)
	20	+ const inGit = Fixtures.gitHostOf()
	21	+ const backend = await Backend.backendOf(inGit.host, [declining.probe])
	22	+
	23	+ expect(backend?.words.lister).toBe('git')
	24	+ expect(backend?.baseModes).toEqual(['session', 'uncommitted', 'branch'])
	25	+ expect(declining.asked).toEqual([inGit.host])
	26	+ expect(inGit.programs).toEqual(['git'])
	27	+ })
	28	+
	29	+ test('a probe that answers pins before git is asked', async () => {
	30	+ const inGit = Fixtures.gitHostOf()
	31	+
	32	+ const backend = await Backend.backendOf(inGit.host, [
	33	+ Fixtures.recordingProbeOf('/home/me/src').probe,
	34	+ ])
	35	+
	36	+ expect(backend?.repository).toEqual({ toplevel: '/home/me/src' })
	37	+ expect(inGit.programs).toEqual([])
	38	+ })
	39	+
	40	+ test('the probes are asked in order and the first answer pins', async () => {
	41	+ const declining = Fixtures.recordingProbeOf(null)
	42	+ const first = Fixtures.recordingProbeOf('/first')
	43	+ const second = Fixtures.recordingProbeOf('/second')
	44	+ const { host } = Fixtures.recordingBackendHostOf({})
	45	+
	46	+ const backend = await Backend.backendOf(host, [
	47	+ declining.probe,
	48	+ first.probe,
	49	+ second.probe,
	50	+ ])
	51	+
	52	+ expect(backend?.repository).toEqual({ toplevel: '/first' })
	53	+
	54	+ expect([
	55	+ declining.asked.length,
	56	+ first.asked.length,
	57	+ second.asked.length,
	58	+ ]).toEqual([1, 1, 0])
	59	+
	60	+ expect(declining.asked[0]).toBe(host)
	61	+ })
	62	+})

		@@ -1,0 +1,40 @@
	1	+import { describe, expect, test, tier } from 'claude-code/testing'
	2	+
	3	+import Classify from '../../hooks/classify'
	4	+
	5	+tier('builtin')
	6	+
	7	+describe('is-noise-file', () => {
	8	+ test('tests, fixtures and snapshots are noise', () => {
	9	+ for (const path of [
	10	+ 'test/a.ts',
	11	+ 'src/x/__tests__/y.ts',
	12	+ 'lib/foo.test.tsx',
	13	+ 'pkg/bar_test.go',
	14	+ 'web/fixtures/data.json',
	15	+ 'ui/__snapshots__/a.snap',
	16	+ ]) {
	17	+ expect(Classify.isNoiseFile(path), path).toBe(true)
	18	+ }
	19	+ })
	20	+
	21	+ test('lockfiles, builds, minified and generated files are noise', () => {
	22	+ for (const path of [
	23	+ 'bun.lock',
	24	+ 'package-lock.json',
	25	+ 'dist/index.js',
	26	+ 'assets/app.min.js',
	27	+ 'types/api.d.ts',
	28	+ 'src/constants/prompts.generated/x.ts',
	29	+ 'proto/service.pb.go',
	30	+ ]) {
	31	+ expect(Classify.isNoiseFile(path), path).toBe(true)
	32	+ }
	33	+ })
	34	+
	35	+ test('source is not, even with test inside a longer word', () => {
	36	+ for (const path of ['src/contest/entry.ts', 'src/latest.ts', 'README.md']) {
	37	+ expect(Classify.isNoiseFile(path), path).toBe(false)
	38	+ }
	39	+ })

		@@ -1,0 +1,12 @@
	1	+/**
	2	+ * The lines of an armed ask: where it came from, then one hunk long enough
	3	+ * that two lines and the cut note take less room than the whole.
	4	+ */
	5	+export const ASK_LINES: readonly string[] = [
	6	+ 'The user attached the diff of a.txt from the diff pane to this prompt:',
	7	+ '@@ -1,3 +1,3 @@',
	8	+ '-the first old line of a.txt, long enough to take up some room',
	9	+ '-the second old line of a.txt, long enough to take up some room',
	10	+ '+the first new line of a.txt, long enough to take up some room',
	11	+ '+the second new line of a.txt, long enough to take up some room',
	12	+]

		@@ -1,0 +1,6 @@
	1	+import { ASK_LINES } from './ask-lines.js'
	2	+
	3	+/**
	4	+ * ASK_LINES as the one text an armed ask carries.
	5	+ */
	6	+export const ASK_TEXT = ASK_LINES.join('\n')

		@@ -1,0 +1,6 @@
	1	+export * from './ask-lines.js'
	2	+export * from './ask-text.js'
	3	+export * from './room-for-one-line.js'
	4	+export * from './room-for-two-lines.js'
	5	+
	6	+export * as default from '.'

		@@ -1,0 +1,8 @@
	1	+import Ask from '../../../hooks/ask'
	2	+import { ASK_LINES } from './ask-lines.js'
	3	+
	4	+/**
	5	+ * Room for ASK_LINES' heading line and the cut note only, so no hunk line.
	6	+ */
	7	+export const ROOM_FOR_ONE_LINE =
	8	+ (ASK_LINES[0]?.length ?? 0) + 1 + Ask.ASK_CUT_NOTE.length

		@@ -1,0 +1,11 @@
	1	+import Ask from '../../../hooks/ask'
	2	+import { ASK_LINES } from './ask-lines.js'
	3	+
	4	+/**
	5	+ * Room for ASK_LINES' first two lines and the cut note, each line with its
	6	+ * newline, and not a character more.
	7	+ */
	8	+export const ROOM_FOR_TWO_LINES = ASK_LINES.slice(0, 2).reduce(
	9	+ (sum, line) => sum + line.length + 1,
	10	+ Ask.ASK_CUT_NOTE.length,
	11	+)

		@@ -1,0 +1,20 @@
	1	+import type Backend from '../../../hooks/backend'
	2	+
	3	+/**
	4	+ * A backend host around one runner: every other member answers nothing (no
	5	+ * file, no mtime, no listing, time zero, a base callback that ignores).
	6	+ *
	7	+ * @param run the host's runner
	8	+ * @returns the host
	9	+ */
	10	+export const backendHostOf = (
	11	+ run: Backend.BackendHost['run'],
	12	+): Backend.BackendHost => ({
	13	+ run,
	14	+ readFile: () => Promise.reject(new Error('ENOENT')),
	15	+ mtimeOf: () => Promise.resolve(null),
	16	+ entryKindsOf: () => Promise.resolve(null),
	17	+ nowMs: () => Promise.resolve(0),
	18	+ sessionStartMsOf: () => 0,
	19	+ onBranchBase: () => undefined,
	20	+})

		@@ -1,0 +1,13 @@
	1	+import Scripted from '../scripted'
	2	+import { GIT_WORKTREE } from './git-worktree.js'
	3	+import { recordingBackendHostOf } from './recording-backend-host-of.js'
	4	+import type { RecordingBackendHost } from './recording-backend-host.js'
	5	+
	6	+/**
	7	+ * A recording backend host inside a git working tree: `rev-parse` answers
	8	+ * the three lines, nothing else is scripted.
	9	+ *
	10	+ * @returns the host and the programs it ran
	11	+ */
	12	+export const gitHostOf = (): RecordingBackendHost =>
	13	+ recordingBackendHostOf({ 'rev-parse': Scripted.ok(GIT_WORKTREE) })

		@@ -1,0 +1,5 @@
	1	+/**
	2	+ * `git rev-parse`'s three lines inside a working tree at /r: the toplevel,
	3	+ * the git dir, the common dir.
	4	+ */
	5	+export const GIT_WORKTREE = '/r\n/r/.git\n/r/.git\n'

		@@ -1,0 +1,10 @@
	1	+export * from './backend-host-of.js'
	2	+export * from './git-host-of.js'
	3	+export * from './git-worktree.js'
	4	+export type * from './recording-backend-host.js'
	5	+export * from './recording-backend-host-of.js'
	6	+export type * from './recording-probe.js'
	7	+export * from './recording-probe-of.js'
	8	+export * from './stub-backend-of.js'
	9	+
	10	+export * as default from '.'

		@@ -1,0 +1,27 @@
	1	+import type { ProcessRunResult } from 'claude-code'
	2	+
	3	+import Scripted from '../scripted'
	4	+import { backendHostOf } from './backend-host-of.js'
	5	+import type { RecordingBackendHost } from './recording-backend-host.js'
	6	+
	7	+/**
	8	+ * A backend host whose runner answers from a script and notes each program
	9	+ * it was asked to run.
	10	+ *
	11	+ * @param script git's answers by subcommand
	12	+ * @returns the host and the programs it ran, in order
	13	+ */
	14	+export function recordingBackendHostOf(
	15	+ script: Readonly<Record<string, ProcessRunResult>>,
	16	+): RecordingBackendHost {
	17	+ const programs: (string \| undefined)[] = []
	18	+ const scripted = Scripted.scriptedGitOf(script)
	19	+
	20	+ const host = backendHostOf(([program, ...rest]) => {
	21	+ programs.push(program)
	22	+
	23	+ return scripted.run(rest)
	24	+ })
	25	+
	26	+ return { host, programs }
	27	+}

		@@ -1,0 +1,24 @@
	1	+import type Backend from '../../../hooks/backend'
	2	+import type { RecordingProbe } from './recording-probe.js'
	3	+import { stubBackendOf } from './stub-backend-of.js'
	4	+
	5	+/**
	6	+ * A backend probe that notes each host it is asked about and answers a stub
	7	+ * backend at the toplevel, or declines (null) when given none.
	8	+ *
	9	+ * @param toplevel the working copy's root, or null to decline
	10	+ * @returns the probe and the hosts it was asked about, in order
	11	+ */
	12	+export function recordingProbeOf(toplevel: string \| null): RecordingProbe {
	13	+ const asked: Backend.BackendHost[] = []
	14	+ const answer = toplevel === null ? null : stubBackendOf(toplevel)
	15	+
	16	+ return {
	17	+ asked,
	18	+ probe: host => {
	19	+ asked.push(host)
	20	+
	21	+ return Promise.resolve(answer)
	22	+ },
	23	+ }
	24	+}

		@@ -1,0 +1,9 @@
	1	+import type Backend from '../../../hooks/backend'
	2	+
	3	+/**
	4	+ * A backend probe under test with the hosts it was asked about, in order.
	5	+ */
	6	+export type RecordingProbe = {
	7	+ probe: Backend.BackendProbe
	8	+ asked: readonly Backend.BackendHost[]
	9	+}

		@@ -1,0 +1,18 @@
	1	+import type { Backend } from '../../../hooks/backend'
	2	+import Git from '../../../hooks/git'
	3	+
	4	+/**
	5	+ * A backend that holds a working copy at a toplevel and fetches nothing,
	6	+ * its lister word the toplevel so a test can tell which probe pinned.
	7	+ *
	8	+ * @param toplevel the working copy's root
	9	+ * @returns the backend
	10	+ */
	11	+export const stubBackendOf = (toplevel: string): Backend => ({
	12	+ repository: { toplevel },
	13	+ baseModes: ['uncommitted'],
	14	+ words: { ...Git.GIT_WORDS, lister: toplevel },
	15	+ fetchDiff: () => Promise.resolve({ kind: 'unavailable' }),
	16	+ fetchFileHunks: () => Promise.resolve(null),
	17	+ headKeyOf: () => Promise.resolve(''),
	18	+})

		@@ -1,0 +1,9 @@
	1	+import type Git from '../../../hooks/git'
	2	+
	3	+/**
	4	+ * A working-tree source whose backend names its own base, a short sha.
	5	+ */
	6	+export const AT_SHA: Git.DiffSource = {
	7	+ kind: 'working-tree',
	8	+ base: '8634408015c1',
	9	+}

		@@ -1,0 +1,5 @@
	1	+export * from './at-sha.js'
	2	+export * from './one-file.js'
	3	+export * from './working-tree.js'
	4	+
	5	+export * as default from '.'

		@@ -1,0 +1,4 @@
	1	+/**
	2	+ * A hunk length past what one turn's diff keeps whole.
	3	+ */
	4	+export const BIG_LINES = 1000

		@@ -1,0 +1,4 @@
	1	+/**
	2	+ * What `rev-parse HEAD` answers on the feature branch.
	3	+ */
	4	+export const FEATURE_HEAD = 'cccccccccccccccccccccccccccccccccccccccc'

		@@ -1,0 +1,5 @@
	1	+export * from './feature-head.js'
	2	+export * from './local-base.js'
	3	+export * from './origin-base.js'
	4	+
	5	+export * as default from '.'

		@@ -1,0 +1,5 @@
	1	+/**
	2	+ * The merge-base of HEAD and the local default branch, when it differs
	3	+ * from the remote's.
	4	+ */
	5	+export const LOCAL_BASE = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'

		@@ -1,0 +1,4 @@
	1	+/**
	2	+ * The merge-base of HEAD and the remote's default branch.
	3	+ */
	4	+export const ORIGIN_BASE = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'

		@@ -1,0 +1,11 @@
	1	+import type Git from '../../hooks/git'
	2	+
	3	+/**
	4	+ * Where every model and view fixture sits: a plain checkout at `/r` whose
	5	+ * git dir is its common dir.
	6	+ */
	7	+export const CHECKOUT: Git.Repository = {
	8	+ toplevel: '/r',
	9	+ gitDir: '/r/.git',
	10	+ commonDir: '/r/.git',
	11	+}

		@@ -1,0 +1,19 @@
	1	+import type { ParsedHunk } from './parsed-hunk.js'
	2	+
	3	+/**
	4	+ * Whether each hunk starts where the one before it ended, on both sides:
	5	+ * the sub-hunks of one hunk split leave no line out and repeat none.
	6	+ *
	7	+ * @param parts the hunks in order
	8	+ * @returns true when they abut
	9	+ */
	10	+export const areContiguous = (parts: readonly ParsedHunk[]): boolean =>
	11	+ parts.slice(1).every((part, at) => {
	12	+ const before = parts[at]
	13	+
	14	+ return (
	15	+ before !== undefined &&
	16	+ part.oldStart === before.oldStart + before.oldLines &&
	17	+ part.newStart === before.newStart + before.newLines
	18	+ )
	19	+ })

		@@ -1,0 +1,36 @@
	1	+import type { ParsedHunk } from './parsed-hunk.js'
	2	+
	3	+/**
	4	+ * The hunks a unified-diff `Code` source holds, read as a surface reads
	5	+ * them.
	6	+ *
	7	+ * Each `@@ -a,b +c,d @@` header opens one and the lines under it are its
	8	+ * body; a source that opens with no header holds none.
	9	+ *
	10	+ * @param source the `Code` element's source
	11	+ * @returns the hunks in order
	12	+ */
	13	+export function hunksOf(source: string): ParsedHunk[] {
	14	+ const hunks: ParsedHunk[] = []
	15	+
	16	+ for (const line of source.split('\n')) {
	17	+ const header = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line)
	18	+ const last = hunks.at(-1)
	19	+
	20	+ if (header) {
	21	+ hunks.push({
	22	+ oldStart: Number(header[1]),
	23	+ oldLines: Number(header[2] ?? 1),
	24	+ newStart: Number(header[3]),
	25	+ newLines: Number(header[4] ?? 1),
	26	+ lines: [],
	27	+ })
	28	+ } else if (last) {
	29	+ hunks[hunks.length - 1] = { ...last, lines: [...last.lines, line] }
	30	+ } else {
	31	+ return []
	32	+ }
	33	+ }
	34	+
	35	+ return hunks
	36	+}