git-jev-stage 0.1.0

package/dist/index.js

@@ -0,0 +1,1851 @@
+// src/core/errors.ts
+var JevCoreError = class extends Error {
+};
+var ProviderError = class extends JevCoreError {
+  code = "provider";
+  status;
+  requestId;
+  retryable;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderError";
+    this.status = options?.status;
+    this.requestId = options?.requestId;
+    this.retryable = options?.retryable ?? false;
+  }
+};
+var RequestTooLargeError = class extends JevCoreError {
+  code = "request-too-large";
+  estimatedTokens;
+  tokenCeiling;
+  constructor(estimatedTokens, tokenCeiling, options) {
+    super(
+      `the request needs about ${estimatedTokens} tokens, over the ceiling of ${tokenCeiling}`,
+      options
+    );
+    this.name = "RequestTooLargeError";
+    this.estimatedTokens = estimatedTokens;
+    this.tokenCeiling = tokenCeiling;
+  }
+};
+var ProviderConfigError = class extends JevCoreError {
+  code = "provider-config";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderConfigError";
+  }
+};
+
+// src/core/fakeProvider.ts
+import { readFileSync } from "node:fs";
+
+// src/core/jevClient.ts
+import process2 from "node:process";
+import {
+  APIConnectionError,
+  APIError,
+  choice,
+  TypeSafeClient
+} from "@typesafe-ai/sdk";
+var DEFAULT_MODEL = "jev-latest";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var TypeSafeJevProvider = class {
+  model;
+  #client;
+  constructor(options = {}) {
+    const apiKey = options.apiKey?.trim() ?? "";
+    if (apiKey.length === 0) {
+      throw new ProviderConfigError("TYPESAFE_API_KEY is not set");
+    }
+    const model = options.model?.trim() ?? "";
+    this.model = model.length > 0 ? model : DEFAULT_MODEL;
+    const config = {
+      apiKey,
+      logLevel: "off",
+      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      retry: { maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES }
+    };
+    const baseURL = options.baseURL?.trim() ?? "";
+    if (baseURL.length > 0) {
+      config.baseURL = baseURL;
+    }
+    if (options.fetch !== void 0) {
+      config.fetch = options.fetch;
+    }
+    this.#client = createClient(config);
+  }
+  async classify(request, options) {
+    const specs = Object.entries(request.questions);
+    if (specs.length === 0) {
+      return { outcomes: {}, usage: { inputTokens: 0, outputTokens: 0 }, model: this.model };
+    }
+    const questions = {};
+    for (const [id, spec] of specs) {
+      questions[id] = choice(spec.instructions, { ...spec.options });
+    }
+    const requestOptions = options?.signal === void 0 ? {} : { signal: options.signal };
+    let payload;
+    let requestId;
+    try {
+      const response = await this.#client.systemOne(
+        { state: toStatePayload(request.state), questions, model: this.model },
+        requestOptions
+      ).withResponse();
+      payload = response.data;
+      requestId = response.requestId;
+    } catch (error) {
+      throw toProviderError(error);
+    }
+    const answers = readAnswers(payload);
+    const outcomes = {};
+    for (const [id, spec] of specs) {
+      const raw = answers[id];
+      outcomes[id] = raw === void 0 ? { kind: "missing" } : validateChoiceAnswer(raw, Object.keys(spec.options));
+    }
+    return {
+      outcomes,
+      usage: readUsage(payload),
+      model: readModel(payload) ?? this.model,
+      ...requestId === void 0 ? {} : { requestId }
+    };
+  }
+};
+function createProviderFromEnv(env = process2.env) {
+  const apiKey = env.TYPESAFE_API_KEY?.trim() ?? "";
+  if (apiKey.length === 0) {
+    return void 0;
+  }
+  const baseURL = env.TYPESAFE_BASE_URL?.trim() ?? "";
+  return new TypeSafeJevProvider({ apiKey, ...baseURL.length > 0 ? { baseURL } : {} });
+}
+function validateChoiceAnswer(raw, options) {
+  const labels = options;
+  if (!isRecord(raw)) {
+    return { kind: "invalid", reason: "answer is not an object" };
+  }
+  if (raw.type !== "choice") {
+    return { kind: "invalid", reason: "answer type is not choice" };
+  }
+  const selected = raw.choice;
+  if (typeof selected !== "string" || !labels.includes(selected)) {
+    return { kind: "invalid", reason: "choice is not one of the options" };
+  }
+  const confidence = raw.confidence;
+  if (!isProbability(confidence)) {
+    return { kind: "invalid", reason: "confidence is not a number between 0 and 1" };
+  }
+  const rawProbabilities = raw.probabilities;
+  if (!isRecord(rawProbabilities)) {
+    return { kind: "invalid", reason: "probabilities is not an object" };
+  }
+  const probabilities = {};
+  for (const [label, probability] of Object.entries(rawProbabilities)) {
+    if (!labels.includes(label)) {
+      return { kind: "invalid", reason: "probabilities has a label that is not an option" };
+    }
+    if (!isProbability(probability)) {
+      return {
+        kind: "invalid",
+        reason: "probabilities has a value that is not a number between 0 and 1"
+      };
+    }
+    probabilities[label] = probability;
+  }
+  return {
+    kind: "answer",
+    answer: {
+      choice: selected,
+      confidence,
+      probabilities
+    }
+  };
+}
+function createClient(config) {
+  try {
+    return new TypeSafeClient(config);
+  } catch (error) {
+    throw new ProviderConfigError("the TypeSafe client rejected its configuration", {
+      cause: error
+    });
+  }
+}
+function toProviderError(error) {
+  if (error instanceof APIError) {
+    return new ProviderError(`TypeSafe request failed (${error.status})`, {
+      status: error.status,
+      requestId: error.requestId,
+      retryable: error.status === 429 || error.status >= 500,
+      cause: error
+    });
+  }
+  if (error instanceof APIConnectionError) {
+    return new ProviderError("TypeSafe request failed (network)", {
+      retryable: true,
+      cause: error
+    });
+  }
+  return new ProviderError("TypeSafe request failed (network)", {
+    retryable: false,
+    cause: error
+  });
+}
+function toStatePayload(state) {
+  if (typeof state === "number" || typeof state === "boolean") {
+    return String(state);
+  }
+  return state;
+}
+function readAnswers(payload) {
+  if (!isRecord(payload)) {
+    return {};
+  }
+  const answers = payload.answers;
+  return isRecord(answers) ? answers : {};
+}
+function readUsage(payload) {
+  if (!isRecord(payload)) {
+    return { inputTokens: 0, outputTokens: 0 };
+  }
+  const usage = payload.usage;
+  if (!isRecord(usage)) {
+    return { inputTokens: 0, outputTokens: 0 };
+  }
+  return {
+    inputTokens: readCount(usage.input_tokens),
+    outputTokens: readCount(usage.output_tokens)
+  };
+}
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function readModel(payload) {
+  if (!isRecord(payload)) {
+    return void 0;
+  }
+  const model = payload.model;
+  return typeof model === "string" && model.length > 0 ? model : void 0;
+}
+function isProbability(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/fakeProvider.ts
+var FakeProvider = class _FakeProvider {
+  requests = [];
+  #script;
+  constructor(script = {}) {
+    this.#script = script;
+  }
+  async classify(request, options) {
+    const recorded = widenRequest(request);
+    this.requests.push(recorded);
+    this.#script.onRequest?.(recorded);
+    const delayMs = this.#script.delayMs ?? 0;
+    if (delayMs > 0) {
+      await delay(delayMs);
+    }
+    options?.signal?.throwIfAborted();
+    const scriptedError = this.#script.error;
+    if (scriptedError !== void 0) {
+      throw scriptedError;
+    }
+    const outcomes = {};
+    for (const [id, spec] of Object.entries(request.questions)) {
+      const scripted = this.#script.answers?.[id] ?? this.#script.defaultAnswer;
+      outcomes[id] = scripted === void 0 ? { kind: "missing" } : validateChoiceAnswer(toPayload(scripted), Object.keys(spec.options));
+    }
+    return { outcomes, usage: { inputTokens: 0, outputTokens: 0 }, model: "fake" };
+  }
+  static fromJsonFile(path) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(path, "utf8"));
+    } catch (error) {
+      throw new ProviderConfigError(`the fake provider script at ${path} could not be read`, {
+        cause: error
+      });
+    }
+    if (!isRecord2(parsed)) {
+      throw new ProviderConfigError(`the fake provider script at ${path} is not an object`);
+    }
+    const script = {};
+    const answers = parsed.answers;
+    if (answers !== void 0) {
+      if (!isRecord2(answers)) {
+        throw new ProviderConfigError(`answers in ${path} is not an object`);
+      }
+      const scripted = {};
+      for (const [id, value] of Object.entries(answers)) {
+        scripted[id] = toScriptedAnswer(value);
+      }
+      script.answers = scripted;
+    }
+    const defaultAnswer = parsed.defaultAnswer;
+    if (defaultAnswer !== void 0) {
+      const answer = isRecord2(defaultAnswer) ? toChoiceAnswer(defaultAnswer) : void 0;
+      if (answer === void 0) {
+        throw new ProviderConfigError(`defaultAnswer in ${path} is not a choice answer`);
+      }
+      script.defaultAnswer = answer;
+    }
+    const errorMessage = parsed.errorMessage;
+    if (errorMessage !== void 0) {
+      if (typeof errorMessage !== "string" || errorMessage.length === 0) {
+        throw new ProviderConfigError(`errorMessage in ${path} is not a non-empty string`);
+      }
+      script.error = new ProviderError(errorMessage, { retryable: false });
+    }
+    return new _FakeProvider(script);
+  }
+};
+function toPayload(scripted) {
+  if ("raw" in scripted) {
+    return scripted.raw;
+  }
+  return {
+    type: "choice",
+    choice: scripted.choice,
+    confidence: scripted.confidence,
+    probabilities: scripted.probabilities
+  };
+}
+function toScriptedAnswer(value) {
+  if (!isRecord2(value)) {
+    return { raw: value };
+  }
+  if ("raw" in value) {
+    return { raw: value.raw };
+  }
+  return toChoiceAnswer(value) ?? { raw: value };
+}
+function toChoiceAnswer(value) {
+  const selected = value.choice;
+  const confidence = value.confidence;
+  const rawProbabilities = value.probabilities;
+  if (typeof selected !== "string" || typeof confidence !== "number") {
+    return void 0;
+  }
+  if (!isRecord2(rawProbabilities)) {
+    return void 0;
+  }
+  const probabilities = {};
+  for (const [label, probability] of Object.entries(rawProbabilities)) {
+    if (typeof probability !== "number") {
+      return void 0;
+    }
+    probabilities[label] = probability;
+  }
+  return { choice: selected, confidence, probabilities };
+}
+function widenRequest(request) {
+  const questions = {};
+  for (const [id, spec] of Object.entries(request.questions)) {
+    questions[id] = { instructions: spec.instructions, options: { ...spec.options } };
+  }
+  return { state: request.state, questions };
+}
+function delay(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/tokens.ts
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_TOKEN_CEILING = 25e3;
+var DEFAULT_PER_QUESTION_TOKENS = 40;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateJsonTokens(value) {
+  return estimateTokens(JSON.stringify(value));
+}
+
+// src/core/windowing.ts
+var DEFAULT_CONCURRENCY = 4;
+function buildWindows(items, options) {
+  const ceiling = options.tokenCeiling ?? DEFAULT_TOKEN_CEILING;
+  const perQuestionTokens = options.perQuestionTokens ?? DEFAULT_PER_QUESTION_TOKENS;
+  const withContext = options.neighborContext ?? true;
+  const shared = options.sharedTokens;
+  const entries = items.map((item, index) => ({
+    index,
+    id: item.id,
+    tokens: estimateTokens(item.text)
+  }));
+  const neighbors = buildNeighborIndex(items, entries);
+  const packed = [];
+  let current = [];
+  let currentCost = shared;
+  for (const entry of entries) {
+    const askCost = entry.tokens + perQuestionTokens;
+    if (shared + askCost > ceiling) {
+      if (current.length > 0) {
+        packed.push(current);
+        current = [];
+        currentCost = shared;
+      }
+      packed.push([entry]);
+      continue;
+    }
+    if (current.length > 0 && currentCost + askCost > ceiling) {
+      packed.push(current);
+      current = [];
+      currentCost = shared;
+    }
+    current.push(entry);
+    currentCost += askCost;
+  }
+  if (current.length > 0) {
+    packed.push(current);
+  }
+  return packed.map((asks) => {
+    const asked = new Set(asks.map((entry) => entry.index));
+    const context = [];
+    let cost = shared;
+    for (const entry of asks) {
+      cost += entry.tokens + perQuestionTokens;
+    }
+    if (withContext) {
+      const taken = /* @__PURE__ */ new Set();
+      for (const entry of asks) {
+        for (const candidate of neighbors.get(entry.index) ?? []) {
+          if (asked.has(candidate.index) || taken.has(candidate.index)) {
+            continue;
+          }
+          if (cost + candidate.tokens > ceiling) {
+            continue;
+          }
+          taken.add(candidate.index);
+          context.push(candidate);
+          cost += candidate.tokens;
+        }
+      }
+    }
+    return {
+      askIds: asks.map((entry) => entry.id),
+      contextIds: context.map((entry) => entry.id),
+      estimatedTokens: cost
+    };
+  });
+}
+async function runWindows(windows, fn, options = {}) {
+  options.signal?.throwIfAborted();
+  if (windows.length === 0) {
+    return [];
+  }
+  const concurrency = Math.max(1, Math.trunc(options.concurrency ?? DEFAULT_CONCURRENCY));
+  const results = new Array(windows.length);
+  const controller = new AbortController();
+  const external = options.signal;
+  const forwardAbort = () => {
+    controller.abort(external?.reason);
+  };
+  external?.addEventListener("abort", forwardAbort, { once: true });
+  let cursor = 0;
+  let failed = false;
+  let failure;
+  const worker = async () => {
+    while (!failed) {
+      const index = cursor;
+      cursor += 1;
+      const window = windows[index];
+      if (window === void 0) {
+        return;
+      }
+      try {
+        results[index] = await fn(window, index, controller.signal);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+          controller.abort();
+        }
+        return;
+      }
+    }
+  };
+  try {
+    await Promise.all(
+      Array.from({ length: Math.min(concurrency, windows.length) }, () => worker())
+    );
+  } finally {
+    external?.removeEventListener("abort", forwardAbort);
+  }
+  if (failed) {
+    throw failure;
+  }
+  return results;
+}
+function buildNeighborIndex(items, entries) {
+  const groups = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    const entry = entries[index];
+    if (entry === void 0) {
+      return;
+    }
+    const bucket = groups.get(item.group);
+    if (bucket === void 0) {
+      groups.set(item.group, [entry]);
+    } else {
+      bucket.push(entry);
+    }
+  });
+  const neighbors = /* @__PURE__ */ new Map();
+  for (const bucket of groups.values()) {
+    const ordered = [...bucket].sort((left, right) => {
+      const leftItem = items[left.index];
+      const rightItem = items[right.index];
+      if (leftItem === void 0 || rightItem === void 0) {
+        return left.index - right.index;
+      }
+      return leftItem.ordinal - rightItem.ordinal || left.index - right.index;
+    });
+    ordered.forEach((entry, position) => {
+      const candidates = [];
+      const previous = ordered[position - 1];
+      const next = ordered[position + 1];
+      if (previous !== void 0) {
+        candidates.push(previous);
+      }
+      if (next !== void 0) {
+        candidates.push(next);
+      }
+      neighbors.set(entry.index, candidates);
+    });
+  }
+  return neighbors;
+}
+
+// src/errors.ts
+var JevStageError = class extends Error {
+  exitCode = 1;
+};
+var UsageError = class extends JevStageError {
+  code = "usage";
+  exitCode = 2;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UsageError";
+  }
+};
+var NotARepositoryError = class extends JevStageError {
+  code = "not-a-repository";
+  constructor(message = "not a git repository", options) {
+    super(message, options);
+    this.name = "NotARepositoryError";
+  }
+};
+var UnbornRepositoryError = class extends JevStageError {
+  code = "unborn-repository";
+  constructor(message = "the repository has no commits yet", options) {
+    super(message, options);
+    this.name = "UnbornRepositoryError";
+  }
+};
+var UnsupportedGitVersionError = class extends JevStageError {
+  code = "unsupported-git-version";
+  found;
+  minimum;
+  constructor(found, minimum, options) {
+    super(`git ${found} is too old; ${minimum} or newer is required`, options);
+    this.name = "UnsupportedGitVersionError";
+    this.found = found;
+    this.minimum = minimum;
+  }
+};
+var UnmergedEntriesError = class extends JevStageError {
+  code = "unmerged-entries";
+  paths;
+  constructor(paths, options) {
+    super(`resolve the unmerged paths first: ${paths.join(", ")}`, options);
+    this.name = "UnmergedEntriesError";
+    this.paths = [...paths];
+  }
+};
+var UnsupportedEntryError = class extends JevStageError {
+  code = "unsupported-entry";
+  kind;
+  paths;
+  constructor(kind, paths, options) {
+    super(`${kind} entries cannot be staged by hunk: ${paths.join(", ")}`, options);
+    this.name = "UnsupportedEntryError";
+    this.kind = kind;
+    this.paths = [...paths];
+  }
+};
+var DiffParseError = class extends JevStageError {
+  code = "diff-parse";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DiffParseError";
+  }
+};
+var UnknownHunkError = class extends JevStageError {
+  code = "unknown-hunk";
+  ids;
+  constructor(ids, options) {
+    super(`no hunk matches the selected ids: ${ids.join(", ")}`, options);
+    this.name = "UnknownHunkError";
+    this.ids = [...ids];
+  }
+};
+var PatchApplyError = class extends JevStageError {
+  code = "patch-apply";
+  stderr;
+  constructor(stderr, options) {
+    const detail = stderr.trim();
+    super(detail.length > 0 ? `git apply failed: ${detail}` : "git apply failed", options);
+    this.name = "PatchApplyError";
+    this.stderr = detail;
+  }
+};
+var STALE_SNAPSHOT_MESSAGES = {
+  head: "HEAD moved while the plan was being reviewed",
+  index: "the index changed while the plan was being reviewed",
+  diff: "the working tree changed while the plan was being reviewed"
+};
+var StaleSnapshotError = class extends JevStageError {
+  code = "stale-snapshot";
+  exitCode = 3;
+  which;
+  constructor(which, options) {
+    super(`${STALE_SNAPSHOT_MESSAGES[which]}; nothing was staged`, options);
+    this.name = "StaleSnapshotError";
+    this.which = which;
+  }
+};
+var IndexLockedError = class extends JevStageError {
+  code = "index-locked";
+  exitCode = 3;
+  lockPath;
+  constructor(lockPath, options) {
+    super(`another git process holds ${lockPath}`, options);
+    this.name = "IndexLockedError";
+    this.lockPath = lockPath;
+  }
+};
+var MissingApiKeyError = class extends JevStageError {
+  code = "missing-api-key";
+  constructor(message = "TYPESAFE_API_KEY is not set", options) {
+    super(message, options);
+    this.name = "MissingApiKeyError";
+  }
+};
+var GitCommandError = class extends JevStageError {
+  code = "git-command";
+  argv;
+  gitExitCode;
+  stderr;
+  constructor(argv, exitCode, stderr, options) {
+    const detail = stderr.trim();
+    const command = `git ${argv.join(" ")}`;
+    super(
+      detail.length > 0 ? `${command} exited ${exitCode}: ${detail}` : `${command} exited ${exitCode}`,
+      options
+    );
+    this.name = "GitCommandError";
+    this.argv = [...argv];
+    this.gitExitCode = exitCode;
+    this.stderr = detail;
+  }
+};
+
+// src/git/applySelection.ts
+import { randomBytes } from "node:crypto";
+import {
+  closeSync,
+  constants,
+  copyFileSync,
+  fsyncSync,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync,
+  writeSync
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// src/git/composePatch.ts
+function composePatch(files, selectedIds) {
+  assertKnownIds(files, selectedIds);
+  const parts = [];
+  let total2 = 0;
+  for (const file of files) {
+    const selected = selectHunks(file, selectedIds);
+    if (selected.length === 0) {
+      continue;
+    }
+    parts.push(file.headerBytes);
+    total2 += file.headerBytes.length;
+    for (const hunk of selected) {
+      parts.push(hunk.bytes);
+      total2 += hunk.bytes.length;
+    }
+  }
+  return Buffer.concat(parts, total2);
+}
+function summarizeSelection(files, selectedIds) {
+  assertKnownIds(files, selectedIds);
+  const perFile = [];
+  let hunks = 0;
+  let added = 0;
+  let removed = 0;
+  for (const file of files) {
+    const selected = selectHunks(file, selectedIds);
+    if (selected.length === 0) {
+      continue;
+    }
+    const fileAdded = total(selected, (hunk) => hunk.added);
+    const fileRemoved = total(selected, (hunk) => hunk.removed);
+    perFile.push({
+      path: file.path,
+      hunks: selected.length,
+      added: fileAdded,
+      removed: fileRemoved
+    });
+    hunks += selected.length;
+    added += fileAdded;
+    removed += fileRemoved;
+  }
+  return { files: perFile.length, hunks, added, removed, perFile };
+}
+function selectHunks(file, selectedIds) {
+  return file.hunks.filter((hunk) => selectedIds.has(hunk.id));
+}
+function assertKnownIds(files, selectedIds) {
+  const known = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const hunk of file.hunks) {
+      known.add(hunk.id);
+    }
+  }
+  const unknown = [...selectedIds].filter((id) => !known.has(id)).sort();
+  if (unknown.length > 0) {
+    throw new UnknownHunkError(unknown);
+  }
+}
+function total(hunks, pick) {
+  return hunks.reduce((sum, hunk) => sum + pick(hunk), 0);
+}
+
+// src/git/hash.ts
+import { createHash } from "node:crypto";
+var HUNK_ID_LENGTH = 16;
+var SEPARATOR = Buffer.from([0]);
+function hashBytes(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function hashHunkId(path, bytes) {
+  return createHash("sha256").update(Buffer.from(path, "utf8")).update(SEPARATOR).update(bytes).digest("hex").slice(0, HUNK_ID_LENGTH);
+}
+
+// src/git/runGit.ts
+import { spawn } from "node:child_process";
+var DEFAULT_MAX_BUFFER = 512 * 1024 * 1024;
+var NO_EXIT_CODE = -1;
+function createGitRunner(gitBinary = "git") {
+  return {
+    run(args, options) {
+      return spawnGit(gitBinary, [...args], options);
+    }
+  };
+}
+async function runGitOrThrow(git, args, options) {
+  const result = await git.run(args, options);
+  if (result.exitCode !== 0) {
+    throw new GitCommandError(args, result.exitCode, result.stderr);
+  }
+  return result;
+}
+function spawnGit(gitBinary, args, options) {
+  const maxBuffer = options?.maxBuffer ?? DEFAULT_MAX_BUFFER;
+  const extraEnv = options?.env;
+  const input = options?.stdin;
+  return new Promise((resolve2, reject) => {
+    const child = spawn(gitBinary, args, {
+      cwd: options?.cwd ?? process.cwd(),
+      env: extraEnv === void 0 ? process.env : { ...process.env, ...extraEnv },
+      windowsHide: true
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutLength = 0;
+    let settled = false;
+    const fail = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill("SIGKILL");
+      reject(error);
+    };
+    child.on("error", (error) => {
+      fail(new GitCommandError(args, NO_EXIT_CODE, error.message, { cause: error }));
+    });
+    child.stdout.on("data", (chunk) => {
+      stdoutLength += chunk.length;
+      if (stdoutLength > maxBuffer) {
+        fail(new GitCommandError(args, NO_EXIT_CODE, `stdout exceeded ${maxBuffer} bytes`));
+        return;
+      }
+      stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    child.stdin.on("error", (error) => {
+      if (error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED") {
+        return;
+      }
+      fail(new GitCommandError(args, NO_EXIT_CODE, error.message, { cause: error }));
+    });
+    if (input === void 0) {
+      child.stdin.end();
+    } else {
+      child.stdin.end(input);
+    }
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve2({
+        stdout: Buffer.concat(stdoutChunks, stdoutLength),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        exitCode: code ?? NO_EXIT_CODE
+      });
+    });
+  });
+}
+
+// src/git/snapshot.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { resolve } from "node:path";
+
+// src/git/parseDiff.ts
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var QUOTE = 34;
+var PLUS = 43;
+var MINUS = 45;
+var BACKSLASH = 92;
+var FILE_HEADER = "diff --git ";
+var HUNK_HEADER = "@@ ";
+var OLD_FILE = "--- ";
+var NEW_FILE = "+++ ";
+var NEW_FILE_MODE = "new file mode ";
+var DELETED_FILE_MODE = "deleted file mode ";
+var OLD_MODE = "old mode ";
+var NEW_MODE = "new mode ";
+var INDEX_LINE = "index ";
+var BINARY_PATCH = "GIT binary patch";
+var BINARY_FILES = "Binary files ";
+var BINARY_FILES_SUFFIX = " differ";
+var DEV_NULL = "/dev/null";
+var SYMLINK_MODE = "120000";
+var SUBMODULE_MODE = "160000";
+var SIDE_PREFIXES = ["a/", "b/"];
+var DIFF_GIT_PATHS_OVERHEAD = "a/ b/".length;
+var UNSUPPORTED_KIND_ORDER = ["binary", "symlink", "submodule"];
+var SIMPLE_ESCAPES = /* @__PURE__ */ new Map([
+  [34, 34],
+  [92, 92],
+  [97, 7],
+  [98, 8],
+  [102, 12],
+  [110, 10],
+  [114, 13],
+  [116, 9],
+  [118, 11]
+]);
+function parseUnifiedDiff(diff) {
+  const parsed = parseUnifiedDiffDetailed(diff);
+  const error = buildUnsupportedEntryError(parsed.unsupported);
+  if (error !== void 0) {
+    throw error;
+  }
+  return parsed.files;
+}
+function parseUnifiedDiffDetailed(diff) {
+  if (diff.length === 0) {
+    return { files: [], unsupported: [] };
+  }
+  const lines = splitLines(diff);
+  const sectionStarts = findSectionStarts(diff, lines);
+  if (sectionStarts[0] !== 0) {
+    throw new DiffParseError("the diff does not start with a 'diff --git' header");
+  }
+  const files = [];
+  const unsupported = [];
+  for (let index = 0; index < sectionStarts.length; index += 1) {
+    const startLine = sectionStarts[index];
+    if (startLine === void 0) {
+      continue;
+    }
+    const endLine = sectionStarts[index + 1] ?? lines.length;
+    const file = parseSection(diff, lines, startLine, endLine);
+    files.push(file.file);
+    if (file.unsupported !== void 0) {
+      unsupported.push({ path: file.file.path, kind: file.unsupported });
+    }
+  }
+  assertByteExact(diff, files);
+  return { files, unsupported };
+}
+function buildUnsupportedEntryError(entries) {
+  for (const kind of UNSUPPORTED_KIND_ORDER) {
+    const paths = entries.filter((entry) => entry.kind === kind).map((entry) => entry.path);
+    if (paths.length > 0) {
+      return new UnsupportedEntryError(kind, paths);
+    }
+  }
+  return void 0;
+}
+function parseSection(diff, lines, startLine, endLine) {
+  const headerLine = lines[startLine];
+  const lastLine = lines[endLine - 1];
+  if (headerLine === void 0 || lastLine === void 0) {
+    throw new DiffParseError("the diff ends inside a file section");
+  }
+  let firstHunkLine = endLine;
+  for (let index = startLine + 1; index < endLine; index += 1) {
+    const line = lines[index];
+    if (line !== void 0 && lineStartsWith(diff, line, HUNK_HEADER)) {
+      firstHunkLine = index;
+      break;
+    }
+  }
+  const meta = readFileMeta(diff, lines, startLine, firstHunkLine);
+  const path = resolvePath(diff, headerLine, meta);
+  const hunkStarts = findHunkStarts(diff, lines, firstHunkLine, endLine);
+  const hunks = buildHunks(diff, lines, hunkStarts, endLine, path);
+  const headerEnd = firstHunkLine < endLine ? lines[firstHunkLine]?.start ?? lastLine.end : lastLine.end;
+  return {
+    file: {
+      path,
+      kind: resolveKind(meta, hunks.length),
+      headerBytes: diff.subarray(headerLine.start, headerEnd),
+      hunks
+    },
+    unsupported: resolveUnsupportedKind(meta)
+  };
+}
+function readFileMeta(diff, lines, startLine, headerEndLine) {
+  const meta = {
+    newPath: void 0,
+    oldPath: void 0,
+    isNewFile: false,
+    isDeletedFile: false,
+    hasOldMode: false,
+    hasNewMode: false,
+    binary: false,
+    symlink: false,
+    submodule: false
+  };
+  for (let index = startLine + 1; index < headerEndLine; index += 1) {
+    const line = lines[index];
+    if (line === void 0) {
+      continue;
+    }
+    if (lineStartsWith(diff, line, NEW_FILE)) {
+      meta.newPath = pathFromSideLine(diff, line);
+      continue;
+    }
+    if (lineStartsWith(diff, line, OLD_FILE)) {
+      meta.oldPath = pathFromSideLine(diff, line);
+      continue;
+    }
+    const text = decodeLine(diff, line);
+    if (text === BINARY_PATCH) {
+      meta.binary = true;
+    } else if (text.startsWith(BINARY_FILES) && text.endsWith(BINARY_FILES_SUFFIX)) {
+      meta.binary = true;
+    } else if (text.startsWith(NEW_FILE_MODE)) {
+      meta.isNewFile = true;
+      applyMode(meta, text.slice(NEW_FILE_MODE.length));
+    } else if (text.startsWith(DELETED_FILE_MODE)) {
+      meta.isDeletedFile = true;
+      applyMode(meta, text.slice(DELETED_FILE_MODE.length));
+    } else if (text.startsWith(OLD_MODE)) {
+      meta.hasOldMode = true;
+      applyMode(meta, text.slice(OLD_MODE.length));
+    } else if (text.startsWith(NEW_MODE)) {
+      meta.hasNewMode = true;
+      applyMode(meta, text.slice(NEW_MODE.length));
+    } else if (text.startsWith(INDEX_LINE)) {
+      applyMode(meta, text.split(" ")[2] ?? "");
+    }
+  }
+  return meta;
+}
+function applyMode(meta, mode) {
+  const value = mode.trim();
+  if (value === SYMLINK_MODE) {
+    meta.symlink = true;
+  } else if (value === SUBMODULE_MODE) {
+    meta.submodule = true;
+  }
+}
+function resolveKind(meta, hunkCount) {
+  if (meta.isNewFile) {
+    return "added";
+  }
+  if (meta.isDeletedFile) {
+    return "deleted";
+  }
+  if (hunkCount === 0 && meta.hasOldMode && meta.hasNewMode && !meta.binary) {
+    return "mode-only";
+  }
+  return "modified";
+}
+function resolveUnsupportedKind(meta) {
+  if (meta.submodule) {
+    return "submodule";
+  }
+  if (meta.symlink) {
+    return "symlink";
+  }
+  if (meta.binary) {
+    return "binary";
+  }
+  return void 0;
+}
+function resolvePath(diff, headerLine, meta) {
+  if (meta.newPath !== void 0 && meta.newPath !== DEV_NULL) {
+    return meta.newPath;
+  }
+  if (meta.oldPath !== void 0 && meta.oldPath !== DEV_NULL) {
+    return meta.oldPath;
+  }
+  return pathFromFileHeaderLine(diff, headerLine);
+}
+function findSectionStarts(diff, lines) {
+  const starts = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line !== void 0 && lineStartsWith(diff, line, FILE_HEADER)) {
+      starts.push(index);
+    }
+  }
+  return starts;
+}
+function findHunkStarts(diff, lines, from, to) {
+  const starts = [];
+  for (let index = from; index < to; index += 1) {
+    const line = lines[index];
+    if (line !== void 0 && lineStartsWith(diff, line, HUNK_HEADER)) {
+      starts.push(index);
+    }
+  }
+  return starts;
+}
+function buildHunks(diff, lines, hunkStarts, sectionEndLine, path) {
+  const hunks = [];
+  for (let ordinal = 0; ordinal < hunkStarts.length; ordinal += 1) {
+    const startLine = hunkStarts[ordinal];
+    if (startLine === void 0) {
+      continue;
+    }
+    const endLine = hunkStarts[ordinal + 1] ?? sectionEndLine;
+    const first = lines[startLine];
+    const last = lines[endLine - 1];
+    if (first === void 0 || last === void 0) {
+      throw new DiffParseError("the diff ends inside a hunk");
+    }
+    const bytes = diff.subarray(first.start, last.end);
+    let added = 0;
+    let removed = 0;
+    for (let index = startLine + 1; index < endLine; index += 1) {
+      const line = lines[index];
+      if (line === void 0) {
+        continue;
+      }
+      const marker = diff[line.start];
+      if (marker === PLUS) {
+        added += 1;
+      } else if (marker === MINUS) {
+        removed += 1;
+      }
+    }
+    hunks.push({
+      id: hashHunkId(path, bytes),
+      path,
+      ordinal,
+      header: decodeLine(diff, first),
+      bytes,
+      text: bytes.toString("utf8"),
+      added,
+      removed
+    });
+  }
+  return hunks;
+}
+function assertByteExact(diff, files) {
+  const parts = [];
+  let total2 = 0;
+  for (const file of files) {
+    parts.push(file.headerBytes);
+    total2 += file.headerBytes.length;
+    for (const hunk of file.hunks) {
+      parts.push(hunk.bytes);
+      total2 += hunk.bytes.length;
+    }
+  }
+  if (total2 !== diff.length) {
+    throw new DiffParseError(`the parsed diff covers ${total2} of ${diff.length} bytes`);
+  }
+  if (!Buffer.concat(parts, total2).equals(diff)) {
+    throw new DiffParseError("the parsed diff does not reassemble to the input bytes");
+  }
+}
+function splitLines(diff) {
+  const lines = [];
+  let start = 0;
+  while (start < diff.length) {
+    const newline = diff.indexOf(LF, start);
+    if (newline === -1) {
+      lines.push({ start, end: diff.length });
+      break;
+    }
+    lines.push({ start, end: newline + 1 });
+    start = newline + 1;
+  }
+  return lines;
+}
+function lineStartsWith(diff, line, prefix) {
+  if (line.end - line.start < prefix.length) {
+    return false;
+  }
+  return diff.toString("latin1", line.start, line.start + prefix.length) === prefix;
+}
+function contentEnd(diff, line) {
+  let end = line.end;
+  if (end > line.start && diff[end - 1] === LF) {
+    end -= 1;
+  }
+  if (end > line.start && diff[end - 1] === CR) {
+    end -= 1;
+  }
+  return end;
+}
+function decodeLine(diff, line) {
+  return diff.toString("utf8", line.start, contentEnd(diff, line));
+}
+function pathFromSideLine(diff, line) {
+  const raw = diff.subarray(line.start + OLD_FILE.length, contentEnd(diff, line));
+  if (raw[0] === QUOTE) {
+    return stripSidePrefix(unquoteCStyle(raw));
+  }
+  let value = raw.toString("utf8");
+  if (value.includes(" ") && value.endsWith("	")) {
+    value = value.slice(0, -1);
+  }
+  return stripSidePrefix(value);
+}
+function pathFromFileHeaderLine(diff, line) {
+  const raw = diff.subarray(line.start + FILE_HEADER.length, contentEnd(diff, line));
+  if (raw[0] === QUOTE) {
+    const secondStart = quotedTokenEnd(raw, 0) + 1;
+    if (raw[secondStart - 1] !== SPACE || raw[secondStart] !== QUOTE) {
+      throw new DiffParseError("malformed 'diff --git' header");
+    }
+    return stripSidePrefix(unquoteCStyle(raw.subarray(secondStart)));
+  }
+  const remaining = raw.length - DIFF_GIT_PATHS_OVERHEAD;
+  if (remaining <= 0 || remaining % 2 !== 0) {
+    throw new DiffParseError("malformed 'diff --git' header");
+  }
+  return raw.subarray(raw.length - remaining / 2).toString("utf8");
+}
+function stripSidePrefix(value) {
+  if (value === DEV_NULL) {
+    return DEV_NULL;
+  }
+  for (const prefix of SIDE_PREFIXES) {
+    if (value.startsWith(prefix)) {
+      return value.slice(prefix.length);
+    }
+  }
+  return value;
+}
+function quotedTokenEnd(raw, start) {
+  let index = start + 1;
+  while (index < raw.length) {
+    const byte = raw[index];
+    if (byte === BACKSLASH) {
+      index += 2;
+      continue;
+    }
+    if (byte === QUOTE) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  throw new DiffParseError("unterminated quoted path in the diff header");
+}
+function unquoteCStyle(raw) {
+  const out = [];
+  let index = 1;
+  let closed = false;
+  while (index < raw.length) {
+    const byte = raw[index];
+    if (byte === void 0) {
+      break;
+    }
+    if (byte === QUOTE) {
+      closed = true;
+      break;
+    }
+    if (byte !== BACKSLASH) {
+      out.push(byte);
+      index += 1;
+      continue;
+    }
+    const escaped = raw[index + 1];
+    if (escaped === void 0) {
+      throw new DiffParseError("truncated escape in a quoted diff path");
+    }
+    if (escaped >= 48 && escaped <= 55) {
+      let value = 0;
+      let digits = 0;
+      while (digits < 3) {
+        const digit = raw[index + 1 + digits];
+        if (digit === void 0 || digit < 48 || digit > 55) {
+          break;
+        }
+        value = value * 8 + (digit - 48);
+        digits += 1;
+      }
+      if (value > 255) {
+        throw new DiffParseError("octal escape out of range in a quoted diff path");
+      }
+      out.push(value);
+      index += 1 + digits;
+      continue;
+    }
+    const mapped = SIMPLE_ESCAPES.get(escaped);
+    if (mapped === void 0) {
+      throw new DiffParseError("unknown escape in a quoted diff path");
+    }
+    out.push(mapped);
+    index += 2;
+  }
+  if (!closed) {
+    throw new DiffParseError("unterminated quoted path in the diff header");
+  }
+  return Buffer.from(out).toString("utf8");
+}
+
+// src/git/snapshot.ts
+var DIFF_ARGS = Object.freeze([
+  "-c",
+  "core.quotePath=true",
+  "-c",
+  "diff.suppressBlankEmpty=false",
+  "-c",
+  "diff.noprefix=false",
+  "-c",
+  "diff.mnemonicPrefix=false",
+  "diff",
+  "--no-color",
+  "--binary",
+  "--full-index",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--no-renames",
+  "--ignore-submodules=dirty",
+  "--unified=6",
+  "--src-prefix=a/",
+  "--dst-prefix=b/",
+  "--no-relative"
+]);
+var MIN_GIT_MAJOR = 2;
+var MIN_GIT_MINOR = 30;
+var MIN_GIT_VERSION = `${MIN_GIT_MAJOR}.${MIN_GIT_MINOR}`;
+var GIT_VERSION_LINE = /^git version (\d+)\.(\d+)/;
+async function captureSnapshot({ cwd, git }) {
+  const gitEnv = resolveGitEnv();
+  await assertSupportedGitVersion(git, cwd, gitEnv);
+  const locations = await resolveLocations(git, cwd, gitEnv);
+  const headOid = await resolveHeadOid(git, locations.workTree, gitEnv);
+  await assertNoUnmergedEntries(git, locations.workTree, gitEnv);
+  const diff = await runGitOrThrow(git, [...DIFF_ARGS], { cwd: locations.workTree, env: gitEnv });
+  const diffBytes = diff.stdout;
+  const parsed = parseUnifiedDiffDetailed(diffBytes);
+  const unsupported = buildUnsupportedEntryError(parsed.unsupported);
+  if (unsupported !== void 0) {
+    throw unsupported;
+  }
+  return {
+    workTree: locations.workTree,
+    gitDir: locations.gitDir,
+    indexPath: locations.indexPath,
+    gitEnv,
+    headOid,
+    indexHash: hashBytes(readIndexBytes(locations.indexPath)),
+    diffHash: hashBytes(diffBytes),
+    diffBytes,
+    files: parsed.files.filter((file) => file.hunks.length > 0),
+    skipped: parsed.files.filter((file) => file.hunks.length === 0).map((file) => ({ path: file.path, reason: skippedReason(file.kind) }))
+  };
+}
+function skippedReason(kind) {
+  return kind === "mode-only" ? "mode-only" : "empty-file";
+}
+function resolveGitEnv() {
+  const envIndex = process.env.GIT_INDEX_FILE;
+  if (envIndex === void 0 || envIndex.length === 0) {
+    return {};
+  }
+  return { GIT_INDEX_FILE: resolve(process.cwd(), envIndex) };
+}
+async function assertSupportedGitVersion(git, cwd, env) {
+  const result = await runGitOrThrow(git, ["--version"], { cwd, env });
+  const line = firstLine(result.stdout.toString("utf8"));
+  const match = GIT_VERSION_LINE.exec(line);
+  const major = Number(match?.[1]);
+  const minor = Number(match?.[2]);
+  if (!Number.isInteger(major) || !Number.isInteger(minor)) {
+    throw new UnsupportedGitVersionError(line, MIN_GIT_VERSION);
+  }
+  if (major < MIN_GIT_MAJOR || major === MIN_GIT_MAJOR && minor < MIN_GIT_MINOR) {
+    throw new UnsupportedGitVersionError(`${major}.${minor}`, MIN_GIT_VERSION);
+  }
+}
+async function resolveLocations(git, cwd, env) {
+  const result = await git.run(
+    ["rev-parse", "--show-toplevel", "--git-dir", "--git-path", "index"],
+    {
+      cwd,
+      env
+    }
+  );
+  if (result.exitCode !== 0) {
+    throw new NotARepositoryError();
+  }
+  const lines = splitOutputLines(result.stdout.toString("utf8"));
+  const workTree = lines[0];
+  const gitDir = lines[1];
+  const indexFile = lines[2];
+  if (workTree === void 0 || gitDir === void 0 || indexFile === void 0) {
+    throw new NotARepositoryError();
+  }
+  return {
+    workTree: resolve(cwd, workTree),
+    gitDir: resolve(cwd, gitDir),
+    indexPath: env.GIT_INDEX_FILE ?? resolve(cwd, indexFile)
+  };
+}
+async function resolveHeadOid(git, cwd, env) {
+  const result = await git.run(["rev-parse", "--verify", "HEAD"], { cwd, env });
+  const oid = result.stdout.toString("utf8").trim();
+  if (result.exitCode !== 0 || oid.length === 0) {
+    throw new UnbornRepositoryError();
+  }
+  return oid;
+}
+async function assertNoUnmergedEntries(git, cwd, env) {
+  const result = await runGitOrThrow(git, ["ls-files", "-u", "-z"], { cwd, env });
+  if (result.stdout.length === 0) {
+    return;
+  }
+  const paths = [];
+  for (const record of result.stdout.toString("utf8").split("\0")) {
+    if (record.length === 0) {
+      continue;
+    }
+    const tab = record.indexOf("	");
+    const path = tab === -1 ? record : record.slice(tab + 1);
+    if (!paths.includes(path)) {
+      paths.push(path);
+    }
+  }
+  if (paths.length > 0) {
+    throw new UnmergedEntriesError(paths);
+  }
+}
+function readIndexBytes(indexPath) {
+  try {
+    return readFileSync2(indexPath);
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return Buffer.alloc(0);
+    }
+    throw error;
+  }
+}
+function isMissingFile(error) {
+  if (!(error instanceof Error) || !("code" in error)) {
+    return false;
+  }
+  return error.code === "ENOENT" || error.code === "EISDIR";
+}
+function firstLine(output) {
+  return stripCarriageReturn(output.split("\n")[0] ?? "").trim();
+}
+function splitOutputLines(output) {
+  return output.split("\n").map(stripCarriageReturn).filter((line) => line.length > 0);
+}
+function stripCarriageReturn(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+
+// src/git/applySelection.ts
+var LOCK_SUFFIX = ".lock";
+var LOCK_MODE = 420;
+var TEMP_MARKER = ".jev-stage-";
+var TEMP_SUFFIX_BYTES = 8;
+var TEMP_SUFFIX = /^(\d+)-[0-9a-f]+$/;
+var ownedPaths = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+async function applyPatchToIndex({
+  snapshot,
+  patch,
+  git
+}) {
+  if (patch.length === 0) {
+    return;
+  }
+  sweepAbandonedTempIndexes(snapshot.indexPath);
+  const tempPath = await createTempIndex(snapshot, git);
+  const apply = { git, snapshot, patch, tempPath };
+  try {
+    await runApply(apply, ["apply", "--cached", "--check"]);
+    await runApply(apply, ["apply", "--cached"]);
+    await verifyTempIndex(apply);
+  } catch (error) {
+    discard(tempPath);
+    throw error;
+  }
+  const lockPath = `${snapshot.indexPath}${LOCK_SUFFIX}`;
+  const lockFd = openLock(lockPath, tempPath);
+  let lockClosed = false;
+  try {
+    await assertSnapshotIsCurrent(git, snapshot);
+    writeAll(lockFd, readFileSync3(tempPath));
+    fsyncSync(lockFd);
+    closeSync(lockFd);
+    lockClosed = true;
+    renameSync(lockPath, snapshot.indexPath);
+    untrack(lockPath);
+  } catch (error) {
+    if (!lockClosed) {
+      closeQuietly(lockFd);
+    }
+    discard(lockPath);
+    discard(tempPath);
+    throw error;
+  }
+  discard(tempPath);
+}
+async function stageHunks(snapshot, selectedIds, git) {
+  const patch = composePatch(snapshot.files, selectedIds);
+  await applyPatchToIndex({ snapshot, patch, git });
+  return patch;
+}
+function sweepAbandonedTempIndexes(indexPath) {
+  const directory = dirname(indexPath);
+  const prefix = `${basename(indexPath)}${TEMP_MARKER}`;
+  let names;
+  try {
+    names = readdirSync(directory);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.startsWith(prefix)) {
+      continue;
+    }
+    const match = TEMP_SUFFIX.exec(name.slice(prefix.length));
+    if (match === null) {
+      continue;
+    }
+    const pid = Number(match[1]);
+    if (!Number.isSafeInteger(pid) || pid <= 0 || isProcessAlive(pid)) {
+      continue;
+    }
+    removeQuietly(join(directory, name));
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !hasErrnoCode(error, "ESRCH");
+  }
+}
+async function createTempIndex(snapshot, git) {
+  const suffix = randomBytes(TEMP_SUFFIX_BYTES).toString("hex");
+  const tempPath = `${snapshot.indexPath}${TEMP_MARKER}${process.pid}-${suffix}`;
+  track(tempPath);
+  try {
+    copyFileSync(snapshot.indexPath, tempPath, constants.COPYFILE_EXCL);
+  } catch (error) {
+    if (!hasErrnoCode(error, "ENOENT")) {
+      discard(tempPath);
+      throw error;
+    }
+    try {
+      await runGitOrThrow(git, ["read-tree", "HEAD"], {
+        cwd: snapshot.workTree,
+        env: { ...snapshot.gitEnv, GIT_INDEX_FILE: tempPath }
+      });
+    } catch (readTreeError) {
+      discard(tempPath);
+      throw readTreeError;
+    }
+  }
+  return tempPath;
+}
+function tempIndexEnv(apply) {
+  return { ...apply.snapshot.gitEnv, GIT_INDEX_FILE: apply.tempPath };
+}
+async function runApply(apply, args) {
+  const result = await apply.git.run(args, {
+    cwd: apply.snapshot.workTree,
+    env: tempIndexEnv(apply),
+    stdin: apply.patch
+  });
+  if (result.exitCode !== 0) {
+    throw new PatchApplyError(result.stderr);
+  }
+}
+async function verifyTempIndex(apply) {
+  await runApply(apply, ["apply", "--cached", "--check", "-R"]);
+  const listed = await apply.git.run(["ls-files", "-s"], {
+    cwd: apply.snapshot.workTree,
+    env: tempIndexEnv(apply)
+  });
+  if (listed.exitCode !== 0) {
+    throw new PatchApplyError(listed.stderr);
+  }
+}
+async function assertSnapshotIsCurrent(git, snapshot) {
+  const head = await runGitOrThrow(git, ["rev-parse", "HEAD"], {
+    cwd: snapshot.workTree,
+    env: snapshot.gitEnv
+  });
+  if (head.stdout.toString("utf8").trim() !== snapshot.headOid) {
+    throw new StaleSnapshotError("head");
+  }
+  if (hashBytes(readIndexBytes(snapshot.indexPath)) !== snapshot.indexHash) {
+    throw new StaleSnapshotError("index");
+  }
+  const diff = await runGitOrThrow(git, [...DIFF_ARGS], {
+    cwd: snapshot.workTree,
+    env: { ...snapshot.gitEnv, GIT_INDEX_FILE: snapshot.indexPath }
+  });
+  if (hashBytes(diff.stdout) !== snapshot.diffHash) {
+    throw new StaleSnapshotError("diff");
+  }
+}
+function openLock(lockPath, tempPath) {
+  let fd;
+  try {
+    fd = openSync(lockPath, "wx", LOCK_MODE);
+  } catch (error) {
+    discard(tempPath);
+    if (hasErrnoCode(error, "EEXIST")) {
+      throw new IndexLockedError(lockPath, { cause: error });
+    }
+    throw error;
+  }
+  track(lockPath);
+  return fd;
+}
+function writeAll(fd, bytes) {
+  let offset = 0;
+  while (offset < bytes.length) {
+    offset += writeSync(fd, bytes, offset, bytes.length - offset);
+  }
+}
+function track(path) {
+  ownedPaths.add(path);
+  if (!exitHookInstalled) {
+    exitHookInstalled = true;
+    process.on("exit", cleanupOwnedPaths);
+  }
+}
+function untrack(path) {
+  ownedPaths.delete(path);
+}
+function discard(path) {
+  untrack(path);
+  removeQuietly(path);
+}
+function cleanupOwnedPaths() {
+  for (const path of [...ownedPaths]) {
+    ownedPaths.delete(path);
+    removeQuietly(path);
+  }
+}
+function removeQuietly(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+    return;
+  }
+}
+function closeQuietly(fd) {
+  try {
+    closeSync(fd);
+  } catch {
+    return;
+  }
+}
+function hasErrnoCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
+// src/selection/policy.ts
+var DEFAULT_THRESHOLD = 0.6;
+var DECISION_LABELS = Object.freeze([
+  "include",
+  "exclude",
+  "mixed"
+]);
+function decide(outcome, threshold) {
+  if (outcome.kind === "missing") {
+    return { decision: "mixed", source: "missing" };
+  }
+  if (outcome.kind === "invalid") {
+    return { decision: "mixed", source: "invalid" };
+  }
+  const { choice: choice2, confidence, probabilities } = outcome.answer;
+  if (choice2 === "mixed") {
+    return { decision: "mixed", source: "model", confidence, probabilities };
+  }
+  if (confidence >= threshold) {
+    return { decision: choice2, source: "model", confidence, probabilities };
+  }
+  return { decision: "mixed", source: "low-confidence", confidence, probabilities };
+}
+function validateThreshold(threshold) {
+  if (!Number.isFinite(threshold) || threshold <= 0 || threshold > 1) {
+    throw new UsageError(`threshold must be greater than 0 and at most 1, got ${threshold}`);
+  }
+  return threshold;
+}
+
+// src/selection/classify.ts
+var CLASSIFY_CONCURRENCY = 4;
+var BASE_INSTRUCTIONS = "Decide, for each hunk marked role=ask, whether its changed lines belong to the change described by intent. Context hunks are for reference only.";
+var EXCLUDE_INSTRUCTIONS = " Lines that match exclude never belong.";
+var HUNK_OPTIONS = Object.freeze({
+  include: "every changed line in this hunk belongs to the described change",
+  exclude: "no changed line in this hunk belongs to the described change",
+  mixed: "some changed lines belong and some do not"
+});
+async function classifyHunks(options) {
+  const { snapshot, intent, exclude, threshold, provider, tokenCeiling } = options;
+  const instructions = buildInstructions(exclude);
+  const ceiling = tokenCeiling ?? DEFAULT_TOKEN_CEILING;
+  const sharedTokens = envelopeTokens(intent, exclude);
+  const windows = buildWindows(buildItems(snapshot), {
+    sharedTokens,
+    ...tokenCeiling === void 0 ? {} : { tokenCeiling }
+  });
+  const decisions = /* @__PURE__ */ new Map();
+  const sendable = [];
+  for (const window of windows) {
+    if (window.estimatedTokens > ceiling) {
+      for (const hunkId of window.askIds) {
+        decisions.set(hunkId, { hunkId, decision: "mixed", source: "too-large" });
+      }
+      continue;
+    }
+    sendable.push(window);
+  }
+  const results = await runWindows(
+    sendable,
+    (window, _index, signal) => provider.classify(buildRequest(snapshot, intent, exclude, instructions, window), { signal }),
+    {
+      concurrency: CLASSIFY_CONCURRENCY,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    }
+  );
+  const usage = { requests: sendable.length, inputTokens: 0, outputTokens: 0 };
+  results.forEach((result, index) => {
+    usage.inputTokens += result.usage.inputTokens;
+    usage.outputTokens += result.usage.outputTokens;
+    const window = sendable[index];
+    if (window === void 0) {
+      return;
+    }
+    for (const hunkId of window.askIds) {
+      const outcome = result.outcomes[hunkId] ?? { kind: "missing" };
+      decisions.set(hunkId, { hunkId, ...decide(outcome, threshold) });
+    }
+  });
+  return { decisions, usage };
+}
+function envelopeTokens(intent, exclude) {
+  return estimateJsonTokens(buildState(intent, exclude, buildInstructions(exclude), []));
+}
+function buildInstructions(exclude) {
+  return exclude === void 0 ? BASE_INSTRUCTIONS : `${BASE_INSTRUCTIONS}${EXCLUDE_INSTRUCTIONS}`;
+}
+function buildItems(snapshot) {
+  const items = [];
+  for (const file of snapshot.files) {
+    for (const hunk of file.hunks) {
+      items.push({ id: hunk.id, text: hunk.text, group: file.path, ordinal: hunk.ordinal });
+    }
+  }
+  return items;
+}
+function buildRequest(snapshot, intent, exclude, instructions, window) {
+  const roles = /* @__PURE__ */ new Map();
+  for (const hunkId of window.contextIds) {
+    roles.set(hunkId, "context");
+  }
+  for (const hunkId of window.askIds) {
+    roles.set(hunkId, "ask");
+  }
+  const files = [];
+  for (const file of snapshot.files) {
+    const hunks = [];
+    for (const hunk of file.hunks) {
+      const role = roles.get(hunk.id);
+      if (role === void 0) {
+        continue;
+      }
+      hunks.push({ id: hunk.id, header: hunk.header, patch: hunk.text, role });
+    }
+    if (hunks.length > 0) {
+      files.push({ path: file.path, hunks });
+    }
+  }
+  const questions = {};
+  for (const hunkId of window.askIds) {
+    questions[hunkId] = {
+      instructions: `Does hunk ${hunkId} belong to the described change?`,
+      options: { ...HUNK_OPTIONS }
+    };
+  }
+  return { state: buildState(intent, exclude, instructions, files), questions };
+}
+function buildState(intent, exclude, instructions, files) {
+  return {
+    intent,
+    ...exclude === void 0 ? {} : { exclude },
+    instructions,
+    files
+  };
+}
+
+// src/library.ts
+async function planSelection(options) {
+  const threshold = validateThreshold(options.threshold ?? DEFAULT_THRESHOLD);
+  const git = options.git ?? createGitRunner();
+  const snapshot = await captureSnapshot({ cwd: options.cwd, git });
+  const { intent, exclude, provider } = options;
+  const excludeField = exclude === void 0 ? {} : { exclude };
+  if (provider === void 0) {
+    return {
+      intent,
+      ...excludeField,
+      threshold,
+      snapshot,
+      decisions: withoutProvider(snapshot),
+      usage: { requests: 0, inputTokens: 0, outputTokens: 0 }
+    };
+  }
+  const { decisions, usage } = await classifyHunks({
+    snapshot,
+    intent,
+    ...excludeField,
+    threshold,
+    provider
+  });
+  return { intent, ...excludeField, threshold, snapshot, decisions, usage };
+}
+async function applySelection(plan, options) {
+  const hunkIds = collectHunkIds(plan.snapshot);
+  const known = new Set(hunkIds);
+  const unknown = [...new Set(options.includeIds)].filter((id) => !known.has(id)).sort();
+  if (unknown.length > 0) {
+    throw new UnknownHunkError(unknown);
+  }
+  const included = new Set(options.includeIds);
+  const stagedHunkIds = hunkIds.filter((id) => included.has(id));
+  const skippedMixedIds = hunkIds.filter(
+    (id) => plan.decisions.get(id)?.decision === "mixed" && !included.has(id)
+  );
+  const git = options.git ?? createGitRunner();
+  const patchBytes = await stageHunks(plan.snapshot, included, git);
+  return { stagedHunkIds, skippedMixedIds, patchBytes };
+}
+function collectHunkIds(snapshot) {
+  const ids = [];
+  for (const file of snapshot.files) {
+    for (const hunk of file.hunks) {
+      ids.push(hunk.id);
+    }
+  }
+  return ids;
+}
+function withoutProvider(snapshot) {
+  const decisions = /* @__PURE__ */ new Map();
+  for (const hunkId of collectHunkIds(snapshot)) {
+    decisions.set(hunkId, { hunkId, decision: "mixed", source: "no-provider" });
+  }
+  return decisions;
+}
+export {
+  CHARS_PER_TOKEN,
+  DEFAULT_CONCURRENCY,
+  DEFAULT_PER_QUESTION_TOKENS,
+  DEFAULT_THRESHOLD,
+  DEFAULT_TOKEN_CEILING,
+  DIFF_ARGS,
+  DiffParseError,
+  FakeProvider,
+  GitCommandError,
+  IndexLockedError,
+  JevCoreError,
+  JevStageError,
+  MissingApiKeyError,
+  NotARepositoryError,
+  PatchApplyError,
+  ProviderConfigError,
+  ProviderError,
+  RequestTooLargeError,
+  StaleSnapshotError,
+  TypeSafeJevProvider,
+  UnbornRepositoryError,
+  UnknownHunkError,
+  UnmergedEntriesError,
+  UnsupportedEntryError,
+  UnsupportedGitVersionError,
+  UsageError,
+  applyPatchToIndex,
+  applySelection,
+  buildWindows,
+  captureSnapshot,
+  classifyHunks,
+  cleanupOwnedPaths,
+  composePatch,
+  createGitRunner,
+  createProviderFromEnv,
+  decide,
+  estimateJsonTokens,
+  estimateTokens,
+  parseUnifiedDiff,
+  planSelection,
+  runWindows,
+  stageHunks,
+  summarizeSelection,
+  validateChoiceAnswer
+};