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.

		@@ -1,0 +1,29 @@
	1	+import Git from '../git'
	2	+import type { Backend, BackendHost, BackendProbe } from './types'
	3	+
	4	+/**
	5	+ * The backend holding the session's directory: the first of `probes` that
	6	+ * answers one, else git when a git working tree holds it, else none. The
	7	+ * probes go first so a probe may claim a working copy by its own rule
	8	+ * (the nearer of two markers, say); a probe answers null wherever git
	9	+ * should govern.
	10	+ *
	11	+ * @param host the bound host's runner and probes
	12	+ * @param probes probes for other version-control systems, in order
	13	+ * (INSTALLED_BACKEND_PROBES at the pane; none as published)
	14	+ * @returns the pinned backend, or null outside any working tree
	15	+ */
	16	+export async function backendOf(
	17	+ host: BackendHost,
	18	+ probes: Iterable<BackendProbe>,
	19	+): Promise<Backend \| null> {
	20	+ for (const probe of probes) {
	21	+ const backend = await probe(host)
	22	+
	23	+ if (backend) {
	24	+ return backend
	25	+ }
	26	+ }
	27	+
	28	+ return Git.gitBackendOf(host)
	29	+}

		@@ -1,0 +1,5 @@
	1	+export * from './backend-of.js'
	2	+export * from './installed-backend-probes.js'
	3	+export * from './types'
	4	+
	5	+export * as default from '.'

		@@ -1,0 +1,15 @@
	1	+import type { BackendProbe } from './types'
	2	+
	3	+/**
	4	+ * The plugin's backend-extension point: probes for version-control systems
	5	+ * other than git, consulted in insertion order before git (backendOf); a
	6	+ * probe answers null wherever git should govern. Empty as shipped, so the
	7	+ * plugin reads git alone. A host
	8	+ * that compiles the module in may add a probe once, before the plugin
	9	+ * registers; the module runs natively, so that probe is what
	10	+ * `session.start` sees. The module contract offers no other channel: the
	11	+ * options `register` receives are the manifest's userConfig, and the
	12	+ * shipped scan requires `register` itself to be a plain exported function.
	13	+ */
	14	+// module-state-allow: module-evaluation code wiring — a compiling host adds its probe functions (code references, not runtime input) once before registration and never removes or rebinds them; tests pass probes to backendOf directly; a per-Host copy would hold the same functions
	15	+export const INSTALLED_BACKEND_PROBES = new Set<BackendProbe>()

		@@ -1,0 +1,46 @@
	1	+import type Git from '../../../git'
	2	+import type { BackendWords } from '../backend-words'
	3	+
	4	+/**
	5	+ * The version-control system behind the pane, pinned once per session:
	6	+ * where its working tree is, which comparisons it offers, how it words
	7	+ * them, and the three reads the pane makes of it.
	8	+ *
	9	+ * Git is the plugin's own backend; a host may install probes for others,
	10	+ * consulted where no git working tree holds the directory (backendOf).
	11	+ */
	12	+export type Backend = {
	13	+ /**
	14	+ * The working tree's top; every row's path is relative to it.
	15	+ */
	16	+ repository: Pick<Git.Repository, 'toplevel'>
	17	+
	18	+ /**
	19	+ * The base modes the picker offers, in picker order.
	20	+ */
	21	+ baseModes: readonly Git.BaseMode[]
	22	+
	23	+ /**
	24	+ * The pane's words for what this backend compares and runs.
	25	+ */
	26	+ words: BackendWords
	27	+
	28	+ /**
	29	+ * One fetch of the working tree against the mode's base (Git.fetchDiff).
	30	+ */
	31	+ fetchDiff: (mode: Git.BaseMode) => Promise<Git.FetchOutcome>
	32	+
	33	+ /**
	34	+ * One row's hunks against the base its fetch read (Git.fetchFileHunks).
	35	+ */
	36	+ fetchFileHunks: (
	37	+ data: Git.DiffData,
	38	+ file: Git.FileStat,
	39	+ ) => Promise<Git.FileHunks \| null>
	40	+
	41	+ /**
	42	+ * A string that changes when the checked-out commit moves
	43	+ * (Git.headKeyOf); empty when it cannot be read this tick.
	44	+ */
	45	+ headKeyOf: () => Promise<string>
	46	+}

		@@ -1,0 +1,3 @@
	1	+export type * from './backend.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,22 @@
	1	+import type Git from '../../../git'
	2	+import type Host from '../../../host'
	3	+
	4	+/**
	5	+ * What pinning a backend takes from the bound host: the raw process
	6	+ * runner (each backend names its own program, argv lead, environment and
	7	+ * timeout), the file probes, the engine's clock, the session's start as it
	8	+ * stands at each fetch (a later `session.start` moves it), and the
	9	+ * branch-base listener.
	10	+ */
	11	+export type BackendHost = Pick<Host.Host, 'run' \| 'readFile'> &
	12	+ Pick<Git.GitDeps, 'mtimeOf' \| 'entryKindsOf' \| 'onBranchBase'> & {
	13	+ /**
	14	+ * The engine's clock, in milliseconds (`$.clock.now`).
	15	+ */
	16	+ nowMs: () => number
	17	+
	18	+ /**
	19	+ * When the current session began, read at each fetch.
	20	+ */
	21	+ sessionStartMsOf: () => number
	22	+ }

		@@ -1,0 +1,3 @@
	1	+export type * from './backend-host.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,9 @@
	1	+import type { Backend } from '../backend'
	2	+import type { BackendHost } from '../backend-host'
	3	+
	4	+/**
	5	+ * Probes the session's directory for one backend's working tree: the
	6	+ * backend when it holds the directory, null when it does not or when git
	7	+ * should govern it instead (Git.gitBackendOf is git's).
	8	+ */
	9	+export type BackendProbe = (host: BackendHost) => Promise<Backend \| null>

		@@ -1,0 +1,3 @@
	1	+export type * from './backend-probe.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,27 @@
	1	+/**
	2	+ * The words the pane draws that name the backend: what uncommitted mode
	3	+ * compares against, the command whose failure the empty state names, the
	4	+ * tool that lists untracked files, and the note under an untracked row.
	5	+ */
	6	+export type BackendWords = {
	7	+ /**
	8	+ * What the working tree is compared with outside branch mode: `HEAD`.
	9	+ */
	10	+ base: string
	11	+
	12	+ /**
	13	+ * The command a failed fetch could not read: `git diff`.
	14	+ */
	15	+ diffCommand: string
	16	+
	17	+ /**
	18	+ * The program that lists untracked files: `git`.
	19	+ */
	20	+ lister: string
	21	+
	22	+ /**
	23	+ * The dim lines under an untracked row: what it is, and how to get its
	24	+ * line counts (a pasteable command only when the path is safe to paste).
	25	+ */
	26	+ untrackedNoteOf: (path: string, isPasteable: boolean) => readonly string[]
	27	+}

		@@ -1,0 +1,11 @@
	1	+import type Types from '../types'
	2	+
	3	+/**
	4	+ * What a child that never ran, was killed, or timed out reads as: exit code
	5	+ * -1 and no output, so a runner never rejects (GitRun).
	6	+ */
	7	+export const FAILED_RUN: Types.RunResult = Object.freeze({
	8	+ exitCode: -1,
	9	+ stdout: '',
	10	+ stderr: '',
	11	+})

		@@ -1,0 +1,66 @@
	1	+import type Backend from '../backend'
	2	+import Limits from '../limits'
	3	+import Argv from './argv'
	4	+import { FAILED_RUN } from './failed-run'
	5	+import { fetchDiff } from './fetch-diff.js'
	6	+import { fetchFileHunks } from './fetch-file-hunks.js'
	7	+import { GIT_BASE_MODES } from './git-base-modes'
	8	+import { GIT_WORDS } from './git-words'
	9	+import Probes from './probes'
	10	+import type Types from './types'
	11	+
	12	+/**
	13	+ * The git backend over the session's directory: the repository read with
	14	+ * one `rev-parse` in that directory, then every child pinned to it
	15	+ * (`--git-dir`, `--work-tree`, cwd the top) under the C locale and the
	16	+ * fetch's timeout (gitDiff.ts execPinnedGit).
	17	+ *
	18	+ * @param host the bound host's runner and probes
	19	+ * @returns the backend, or null outside a git working tree
	20	+ */
	21	+export async function gitBackendOf(
	22	+ host: Backend.BackendHost,
	23	+): Promise<Backend.Backend \| null> {
	24	+ const runOf =
	25	+ (pinned: Types.Repository \| null): Types.GitRun =>
	26	+ async argv => {
	27	+ try {
	28	+ return await host.run(
	29	+ ['git', ...(pinned ? Argv.pinnedLeadOf(pinned) : []), ...argv],
	30	+ {
	31	+ timeoutMs: Limits.GIT_TIMEOUT_MS,
	32	+ env: Argv.GIT_CHILD_ENV,
	33	+ ...(pinned && { cwd: pinned.toplevel }),
	34	+ },
	35	+ )
	36	+ } catch {
	37	+ return FAILED_RUN
	38	+ }
	39	+ }

		@@ -1,8 +1,12 @@
1	1	export * from './argv'
2	2	export * from './cut-hunks'
3	3	export * from './empty-file-hunks'
	4	+export * from './failed-run'
4	5	export * from './fetch-diff.js'
5	6	export * from './fetch-file-hunks.js'
	7	+export * from './git-backend-of.js'
	8	+export * from './git-base-modes'
	9	+export * from './git-words'
6	10	export * from './hunk-of'
7	11	export * from './large-file-hunks'
8	12	export * from './parse'

		@@ -3,15 +3,17 @@
3	3	import { MOST_UTF8_BYTES } from './most-utf8-bytes'
4	4
5	5	/**
6		- * Whether a `-z` listing arrived whole: every record NUL-terminated and
7		- * the text short of the host's output cap, so no record was cut or lost.
	6	+ * Whether a listing arrived whole: every record terminated (NUL for git's
	7	+ * `-z` listings, a newline for line records) and the text short of the
	8	+ * host's output cap, so no record was cut or lost.
8	9	*
9	10	* A cut inside a multi-byte character costs the decoded text up to
10	11	* MOST_UTF8_BYTES, hence the margin under the cap.
11	12	*
12	13	* @param stdout the listing as `$.process.run` returned it
	14	+ * @param terminator what ends every record; NUL when absent
13	15	* @returns whether it can be parsed as the whole answer
14	16	*/
15		-export const isWholeListing = (stdout: string) =>
16		- (stdout === '' \|\| stdout.endsWith('\0')) &&
	17	+export const isWholeListing = (stdout: string, terminator = '\0') =>
	18	+ (stdout === '' \|\| stdout.endsWith(terminator)) &&
17	19	isUnderUtf8Ceiling(stdout, Limits.HOST_OUTPUT_CAP_BYTES - MOST_UTF8_BYTES)

		@@ -1,0 +1,3 @@
	1	+export type * from './backend-words.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,6 @@
	1	+export * from './backend'
	2	+export * from './backend-host'
	3	+export * from './backend-probe'
	4	+export * from './backend-words'
	5	+
	6	+export * as default from '.'

		@@ -1,0 +1,3 @@
	1	+export * from './failed-run.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,10 @@
	1	+import type Types from '../types'
	2	+
	3	+/**
	4	+ * The comparisons git offers, in picker order: all three.
	5	+ */
	6	+export const GIT_BASE_MODES: readonly Types.BaseMode[] = Object.freeze([
	7	+ 'session',
	8	+ 'uncommitted',
	9	+ 'branch',
	10	+])

		@@ -1,0 +1,3 @@
	1	+export * from './git-base-modes.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,17 @@
	1	+import type Backend from '../../backend'
	2	+
	3	+/**
	4	+ * The pane's git words: compared with HEAD, read by `git diff`, untracked
	5	+ * files listed by git and staged with `git add ':/…'` (DiffDetailView's).
	6	+ */
	7	+export const GIT_WORDS: Backend.BackendWords = Object.freeze({
	8	+ base: 'HEAD',
	9	+ diffCommand: 'git diff',
	10	+ lister: 'git',
	11	+ untrackedNoteOf: (path: string, isPasteable: boolean) => [
	12	+ 'New file not yet staged.',
	13	+ isPasteable
	14	+ ? `Run \`git add ':/${path}'\` to see line counts.`
	15	+ : 'Stage it with git add to see line counts.',
	16	+ ],
	17	+})

		@@ -1,0 +1,3 @@
	1	+export * from './git-words.js'
	2	+
	3	+export * as default from '.'

		@@ -22,6 +22,7 @@
22	22	export * from './transient-state-files'
23	23	export * from './unstaged-numstat.js'
24	24	export * from './untracked-files'
	25	+export * from './untracked-rows-of'
25	26	export * from './untracked-place'
26	27
27	28	export * as default from '.'

		@@ -13,7 +13,7 @@
13	13	* @returns the rows, tagged
14	14	*/
15	15	export async function tagPreSession(
16		- context: Pick<Types.FetchContext, 'deps' \| 'stamps'>,
	16	+ context: Types.DatingContext,
17	17	files: readonly Types.FileStat[],
18	18	): Promise<readonly Types.FileStat[]> {
19	19	const datings = await datingsOf(

		@@ -1,25 +1,20 @@
1		-import Limits from '../../../limits'
2	1	import Argv from '../../argv'
3	2	import GitParse from '../../parse'
4	3	import type Types from '../../types'
5		-import { datingsOf } from '../datings-of'
6	4	import type { UntrackedPlace } from '../untracked-place'
	5	+import { untrackedRowsOf } from '../untracked-rows-of'
7	6
8	7	/**
9		- * The untracked, unignored files as 0/0 rows: the session's own first,
10		- * then, when the scope asks, the tagged pre-session ones, up to the slots.
	8	+ * The untracked, unignored files as 0/0 rows (untrackedRowsOf), listed
	9	+ * with `ls-files -z`. A listing not given whole: no answer.
11	10	*
12		- * At most MAX_UNTRACKED_PROBES are dated; a file past that or past the
13		- * listing budget reads as pre-session, an undatable one as the session's
14		- * (the built-in panel's rule). A listing not given whole: no answer.
15		- *
16	11	* @param context the fetch: its pinned git, stamp probe and session start
17	12	* @param place the free row slots and the scope
18	13	* @returns the rows to merge after the tracked ones, or null when the
19	14	* `-z` listing failed, timed out or was cut
20	15	*/
21	16	export async function untrackedFiles(
22		- context: Pick<Types.FetchContext, 'run' \| 'deps' \| 'stamps'>,
	17	+ context: Pick<Types.FetchContext, 'run'> & Types.DatingContext,
23	18	place: UntrackedPlace,
24	19	): Promise<readonly Types.FileStat[] \| null> {
25	20	if (place.slots <= 0) {
		@@ -40,34 +35,6 @@
40	35	}
41	36
42	37	const paths = listing.stdout.split('\0').filter(path => path !== '')
43		- const probedPaths = paths.slice(0, Limits.MAX_UNTRACKED_PROBES)
44		- const datings = await datingsOf(
45		- context.stamps,
46		- context.deps.sessionStartMs,
47		- probedPaths,
48		- )
49		- const probed = probedPaths.map(path => ({
50		- path,
51		- isPreSession: datings.get(path) !== 'session',
52		- }))
53		- const isWithPreSession = place.scope === 'with-pre-session'
54		- const earlier = isWithPreSession
55		- ? [
56		- ...probed.filter(file => file.isPreSession),
57		- ...paths
58		- .slice(Limits.MAX_UNTRACKED_PROBES)
59		- .map(path => ({ path, isPreSession: true })),
60		- ]
61		- : []
62		- const ordered = [...probed.filter(file => !file.isPreSession), ...earlier]
63	38
64		- return ordered.slice(0, place.slots).map(file => ({
65		- path: file.path,
66		- renamedFrom: null,
67		- added: 0,
68		- removed: 0,
69		- isBinary: false,
70		- isUntracked: true,
71		- isPreSession: file.isPreSession,
72		- }))
	39	+ return untrackedRowsOf(context, paths, place)
73	40	}

		@@ -1,0 +1,3 @@
	1	+export * from './untracked-rows-of.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,54 @@
	1	+import Limits from '../../../limits'
	2	+import type Types from '../../types'
	3	+import { datingsOf } from '../datings-of'
	4	+import type { UntrackedPlace } from '../untracked-place'
	5	+
	6	+/**
	7	+ * Listed untracked paths as 0/0 rows: the session's own first, then,
	8	+ * when the scope asks, the tagged pre-session ones, up to the slots.
	9	+ *
	10	+ * At most MAX_UNTRACKED_PROBES are dated; a file past that or past the
	11	+ * listing budget reads as pre-session, an undatable one as the session's
	12	+ * (the built-in panel's rule).
	13	+ *
	14	+ * @param context the fetch's stamp probe and session start
	15	+ * @param paths the untracked paths, root-relative, as the lister printed them
	16	+ * @param place the free row slots and the scope
	17	+ * @returns the rows to merge after the tracked ones
	18	+ */
	19	+export async function untrackedRowsOf(
	20	+ context: Types.DatingContext,
	21	+ paths: readonly string[],
	22	+ place: UntrackedPlace,
	23	+): Promise<readonly Types.FileStat[]> {
	24	+ const probedPaths = paths.slice(0, Limits.MAX_UNTRACKED_PROBES)
	25	+ const datings = await datingsOf(
	26	+ context.stamps,
	27	+ context.deps.sessionStartMs,
	28	+ probedPaths,
	29	+ )
	30	+ const probed = probedPaths.map(path => ({
	31	+ path,
	32	+ isPreSession: datings.get(path) !== 'session',
	33	+ }))
	34	+ const isWithPreSession = place.scope === 'with-pre-session'
	35	+ const earlier = isWithPreSession
	36	+ ? [
	37	+ ...probed.filter(file => file.isPreSession),
	38	+ ...paths
	39	+ .slice(Limits.MAX_UNTRACKED_PROBES)
	40	+ .map(path => ({ path, isPreSession: true })),
	41	+ ]
	42	+ : []
	43	+ const ordered = [...probed.filter(file => !file.isPreSession), ...earlier]
	44	+
	45	+ return ordered.slice(0, place.slots).map(file => ({
	46	+ path: file.path,
	47	+ renamedFrom: null,
	48	+ added: 0,
	49	+ removed: 0,
	50	+ isBinary: false,
	51	+ isUntracked: true,
	52	+ isPreSession: file.isPreSession,
	53	+ }))
	54	+}

		@@ -20,6 +20,6 @@
20	20	case 'head-is-base':
21	21	return { kind: 'branch', baseBranch: base.baseBranch, baseRef: 'HEAD' }
22	22	case 'none':
23		- return { kind: 'working-tree' }
	23	+ return { kind: 'working-tree', base: 'HEAD' }
24	24	}
25	25	}

		@@ -48,7 +48,7 @@
48	48	return {
49	49	kind: 'data',
50	50	data: diffDataOf(context, merged, {
51		- source: { kind: 'working-tree' },
	51	+ source: { kind: 'working-tree', base: 'HEAD' },
52	52	baseRef: '--cached',
53	53	isUnborn: true,
54	54	stalePaths: unstaged.files.map(file => file.path),

		@@ -1,4 +1,5 @@
1	1	export * from './merged-result-of'
	2	+export * from './merged-with-untracked'
2	3	export * from './with-untracked.js'
3	4
4	5	export * as default from '.'

		@@ -1,0 +1,3 @@
	1	+export * from './merged-with-untracked.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,32 @@
	1	+import type Types from '../../../types'
	2	+import { mergedResultOf } from '../merged-result-of'
	3	+
	4	+/**
	5	+ * A tier's tracked rows and totals with a listed set of untracked rows
	6	+ * after them (gitDiff.ts mergeSessionUntrackedFiles), or flagged withheld
	7	+ * when the lister gave no whole listing.
	8	+ *
	9	+ * A path a tracked row already holds keeps that row and counts once.
	10	+ *
	11	+ * @param result the tier's tracked rows and totals
	12	+ * @param untracked the untracked rows, or null when their listing was withheld
	13	+ * @returns the merged rows and totals, and whether the listing was withheld
	14	+ */
	15	+export function mergedWithUntracked(
	16	+ result: Types.NumstatResult,
	17	+ untracked: readonly Types.FileStat[] \| null,
	18	+): Types.MergedResult {
	19	+ if (!untracked) {
	20	+ return mergedResultOf(result, { isUntrackedWithheld: true })
	21	+ }
	22	+
	23	+ const tracked = new Set(result.files.map(file => file.path))
	24	+ const fresh = untracked.filter(file => !tracked.has(file.path))
	25	+ const filesCount = result.stats.filesCount + fresh.length
	26	+ const stats = { ...result.stats, filesCount }
	27	+
	28	+ return mergedResultOf(
	29	+ { stats, files: [...result.files, ...fresh] },
	30	+ { isUntrackedWithheld: false },
	31	+ )
	32	+}

		@@ -3,14 +3,14 @@
3	3	import type Types from '../../types'
4	4	import { isPastDetails } from '../is-past-details'
5	5	import { mergedResultOf } from './merged-result-of'
	6	+import { mergedWithUntracked } from './merged-with-untracked'
6	7
7	8	/**
8		- * A tier's rows with the untracked files merged after them, as the built-in
9		- * panel merges the session's untracked files.
	9	+ * A tier's rows with the untracked files merged after them
	10	+ * (mergedWithUntracked).
10	11	*
11		- * A path a numstat row already holds keeps that row and counts once. Past
12		- * MAX_FILES_FOR_DETAILS nothing is listed; a listing git withheld leaves
13		- * the tracked rows as they are and says so, as the built-in degrades.
	12	+ * Past MAX_FILES_FOR_DETAILS nothing is listed; a listing git withheld
	13	+ * leaves the tracked rows as they are and says so, as the built-in degrades.
14	14	*
15	15	* @param context the fetch
16	16	* @param result the tier's tracked rows and totals
		@@ -26,22 +26,11 @@
26	26	return mergedResultOf(result, { isUntrackedWithheld: false })
27	27	}
28	28
29		- const tracked = new Set(result.files.map(file => file.path))
30		- const untracked = await Probes.untrackedFiles(context, {
31		- slots: Limits.MAX_FILES - result.files.length,
32		- scope,
33		- })
34		-
35		- if (!untracked) {
36		- return mergedResultOf(result, { isUntrackedWithheld: true })
37		- }
38		-
39		- const fresh = untracked.filter(file => !tracked.has(file.path))
40		- const filesCount = result.stats.filesCount + fresh.length
41		- const stats = { ...result.stats, filesCount }
42		-
43		- return mergedResultOf(
44		- { stats, files: [...result.files, ...fresh] },
45		- { isUntrackedWithheld: false },
	29	+ return mergedWithUntracked(
	30	+ result,
	31	+ await Probes.untrackedFiles(context, {
	32	+ slots: Limits.MAX_FILES - result.files.length,
	33	+ scope,
	34	+ }),
46	35	)
47	36	}

		@@ -5,7 +5,7 @@
5	5	* every body current.
6	6	*/
7	7	export const WORKING_TREE_BASIS: DiffDataOf.DiffBasis = Object.freeze({
8		- source: Object.freeze({ kind: 'working-tree' }),
	8	+ source: Object.freeze({ kind: 'working-tree', base: 'HEAD' }),
9	9	baseRef: 'HEAD',
10	10	isUnborn: false,
11	11	stalePaths: Object.freeze([]),

		@@ -1,0 +1,11 @@
	1	+import type { GitDeps } from '../git-deps'
	2	+import type { StampProbe } from '../stamp-probe'
	3	+
	4	+/**
	5	+ * What dating a path against the session takes: the session's start and
	6	+ * one stamp probe over the working tree's top.
	7	+ */
	8	+export type DatingContext = {
	9	+ deps: Pick<GitDeps, 'sessionStartMs'>
	10	+ stamps: StampProbe
	11	+}