git-jev-stage 0.1.0

package/dist/git-jev-stage.js

@@ -0,0 +1,2945 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { realpathSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { pathToFileURL } from "node:url";
+
+// 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 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";
+
+// node_modules/@typesafe-ai/sdk/dist/index.mjs
+var requestIdFrom = (headers) => headers.get("x-typesafe-request-id") ?? void 0;
+var APIPromise = class APIPromise2 extends Promise {
+  #responsePromise;
+  #parseResponse;
+  #parsed;
+  constructor(responsePromise, parseResponse) {
+    super((resolve3) => resolve3(void 0));
+    this.#responsePromise = responsePromise;
+    this.#parseResponse = parseResponse;
+  }
+  /**
+  * Resolves to the raw `Response` without parsing the body. SDK requests buffer the full
+  * body under the request timeout before handoff; reading it afterwards is caller-owned.
+  * The caller owns the body; don't also `await` the parsed result on the same promise.
+  */
+  asResponse() {
+    return this.#responsePromise;
+  }
+  /** Return the parsed result, HTTP response, and request ID. */
+  async withResponse() {
+    const [data, response] = await Promise.all([this.#parse(), this.#responsePromise]);
+    return {
+      data,
+      response,
+      requestId: requestIdFrom(response.headers)
+    };
+  }
+  /** Transform the parsed result, sharing the HTTP response and a single body parse. */
+  map(fn) {
+    return new APIPromise2(this.#responsePromise, () => this.#parse().then(fn));
+  }
+  #parse() {
+    this.#parsed ??= this.#responsePromise.then(this.#parseResponse);
+    return this.#parsed;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#parse().finally(onfinally);
+  }
+};
+var ENV = {
+  /** Required API key; used when `apiKey` is omitted. */
+  apiKey: "TYPESAFE_API_KEY",
+  /** API root; defaults to `https://api.typesafe.ai`. */
+  baseURL: "TYPESAFE_BASE_URL",
+  /** Default model name; defaults to `jev-latest`. */
+  defaultModel: "TYPESAFE_DEFAULT_MODEL",
+  /** Log level; defaults to `warn`. */
+  logLevel: "TYPESAFE_LOG_LEVEL"
+};
+var readEnv = (name) => {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  return process.env[name]?.trim() || void 0;
+};
+var fromCodeOrEnv = (fromCode, envVar) => fromCode ?? readEnv(envVar);
+var range = (from, to) => Array.from({ length: to - from }, (_, i) => from + i);
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  backoffInitialMs: 500,
+  backoffMaxMs: 5e3,
+  backoffJitter: 0.25,
+  /** HTTP 408, 429, and 5xx responses. */
+  httpStatuses: /* @__PURE__ */ new Set([
+    408,
+    429,
+    ...range(500, 600)
+  ]),
+  respectRetryAfter: true,
+  /** Maximum server retry delay before falling back to backoff. */
+  maxRetryAfterMs: 6e4,
+  apiConnectionError: true,
+  apiTimeoutError: true
+};
+DEFAULT_RETRY_POLICY.maxRetries;
+var isRetryableStatus = (status, policy = DEFAULT_RETRY_POLICY) => policy.httpStatuses.has(status);
+var parseRetryAfter = (headers, now = Date.now()) => {
+  const ms = Number(headers.get("retry-after-ms"));
+  if (headers.has("retry-after-ms") && Number.isFinite(ms) && ms >= 0) return ms;
+  const raw = headers.get("retry-after");
+  if (raw === null) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1e3 : void 0;
+  const date = Date.parse(raw);
+  if (!Number.isNaN(date)) return Math.max(0, date - now);
+};
+var retryDelayMs = (attempt, headers, policy = DEFAULT_RETRY_POLICY, random = Math.random) => {
+  if (policy.respectRetryAfter && headers !== void 0) {
+    const retryAfter = parseRetryAfter(headers);
+    if (retryAfter !== void 0 && retryAfter <= policy.maxRetryAfterMs) return retryAfter;
+  }
+  const exponential = Math.min(policy.backoffInitialMs * 2 ** attempt, policy.backoffMaxMs);
+  return Math.round(exponential * (1 - random() * policy.backoffJitter));
+};
+var sleep = (ms, signal) => new Promise((resolve3, reject) => {
+  if (signal?.aborted) return reject(signal.reason);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason);
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve3();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var TypeSafeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var extractMessage = (body) => {
+  if (typeof body === "string") return body || void 0;
+  if (!isRecord(body)) return void 0;
+  const { error, message, detail } = body;
+  if (typeof error === "string") return error;
+  if (isRecord(error) && typeof error.message === "string") return error.message;
+  if (typeof message === "string") return message;
+  if (typeof detail === "string") return detail;
+  if (isRecord(detail) && typeof detail.message === "string") return detail.message;
+  if (Array.isArray(detail)) return describeValidationErrors(detail);
+};
+var describeValidationErrors = (errors) => {
+  const parts = errors.flatMap((e) => {
+    if (!isRecord(e) || typeof e.msg !== "string") return [];
+    const loc = Array.isArray(e.loc) ? e.loc.filter((x) => x !== "body").join(".") : "";
+    return [loc ? `${loc}: ${e.msg}` : e.msg];
+  });
+  return parts.length > 0 ? parts.join("; ") : void 0;
+};
+var MAX_RAW_BODY_IN_MESSAGE = 200;
+var APIError = class APIError2 extends TypeSafeError {
+  /** HTTP response status code. */
+  status;
+  /** HTTP response headers. */
+  headers;
+  /** Parsed JSON, response text, or `undefined` for an empty body. */
+  body;
+  /** Request ID from `x-typesafe-request-id`, or `undefined` when absent. */
+  requestId;
+  constructor(status, body, headers, message) {
+    super(message ?? APIError2.describe(status, body));
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.requestId = requestIdFrom(headers);
+  }
+  static describe(status, body) {
+    const detail = extractMessage(body);
+    if (detail) return `${status} ${detail}`;
+    if (body === void 0) return `${status} status code (no body)`;
+    const raw = typeof body === "string" ? body : JSON.stringify(body);
+    return `${status} ${raw.length > MAX_RAW_BODY_IN_MESSAGE ? `${raw.slice(0, MAX_RAW_BODY_IN_MESSAGE)}\u2026` : raw}`;
+  }
+  /** Create the error subclass for an HTTP status code. */
+  static fromResponse(status, body, headers) {
+    if (status === 400) return new BadRequestError(status, body, headers);
+    if (status === 401) return new AuthenticationError(status, body, headers);
+    if (status === 403) return new PermissionDeniedError(status, body, headers);
+    if (status === 404) return new NotFoundError(status, body, headers);
+    if (status === 422) return new UnprocessableEntityError(status, body, headers);
+    if (status === 429) return new RateLimitError(status, body, headers);
+    if (status >= 500) return new InternalServerError(status, body, headers);
+    return new APIError2(status, body, headers);
+  }
+};
+var BadRequestError = class extends APIError {
+};
+var AuthenticationError = class extends APIError {
+};
+var PermissionDeniedError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+  /** Server retry delay in milliseconds, or `undefined` when absent or invalid. */
+  retryAfterMs = parseRetryAfter(this.headers);
+};
+var InternalServerError = class extends APIError {
+};
+var APIConnectionError = class extends TypeSafeError {
+  constructor(message = "Connection error.", options) {
+    super(message, options);
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  /** Configured timeout in milliseconds. */
+  timeoutMs;
+  constructor(timeoutMs, options) {
+    super(`Request timed out after ${timeoutMs}ms.`, options);
+    this.timeoutMs = timeoutMs;
+  }
+};
+var APIUserAbortError = class extends TypeSafeError {
+  constructor(message = "Request was aborted.", options) {
+    super(message, options);
+  }
+};
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "off"
+];
+var DEFAULT_LOG_LEVEL = "warn";
+var isLogLevel = (value) => LOG_LEVELS.includes(value);
+var parseLogLevel = (value, source) => {
+  if (isLogLevel(value)) return value;
+  throw new TypeSafeError(`Invalid log level "${value}" from ${source}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
+};
+var PREFIX = "[typesafe-sdk]";
+var consoleLogger = {
+  debug: (message, ...args) => console.debug(`${PREFIX} ${message}`, ...args),
+  info: (message, ...args) => console.info(`${PREFIX} ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`${PREFIX} ${message}`, ...args),
+  error: (message, ...args) => console.error(`${PREFIX} ${message}`, ...args)
+};
+var RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  off: 4
+};
+var drop = () => {
+};
+var withLevel = (sink, level) => {
+  const enabled = (at) => RANK[at] >= RANK[level];
+  return {
+    debug: enabled("debug") ? (message, ...args) => sink.debug(message, ...args) : drop,
+    info: enabled("info") ? (message, ...args) => sink.info(message, ...args) : drop,
+    warn: enabled("warn") ? (message, ...args) => sink.warn(message, ...args) : drop,
+    error: enabled("error") ? (message, ...args) => sink.error(message, ...args) : drop
+  };
+};
+var KEY_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "x-api-key"
+]);
+var OPAQUE_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie"]);
+var redactKey = (value) => {
+  const [scheme, secret] = value.includes(" ") ? value.split(/\s+/, 2) : [void 0, value];
+  const tail = secret && secret.length > 8 ? secret.slice(-4) : "";
+  return `${scheme ? `${scheme} ` : ""}***${tail}`;
+};
+var redact = (name, value) => {
+  const lower = name.toLowerCase();
+  if (KEY_HEADERS.has(lower)) return redactKey(value);
+  if (OPAQUE_HEADERS.has(lower)) return "***";
+  return value;
+};
+var redactHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, redact(name, value)]));
+var choice = (instructions, criteria) => {
+  if (Array.isArray(criteria)) throw new TypeSafeError("Choice criteria must be a map of labels to descriptions, not a list.");
+  return {
+    type: "choice",
+    instructions,
+    criteria
+  };
+};
+var validateQuestions = (questions) => {
+  if (Object.keys(questions).length === 0) throw new TypeSafeError("At least one question is required.");
+  for (const [name, question] of Object.entries(questions)) {
+    if (question.type !== "score") continue;
+    if (!Array.isArray(question.criteria)) throw new TypeSafeError(`Score question "${name}" has criteria that are not a list; score criteria must be a list of descriptions indexed by score from zero.`);
+    if (question.criteria.length < 2) throw new TypeSafeError(`Score question "${name}" has ${question.criteria.length} criteria; at least two scores are required.`);
+  }
+};
+var Models = class {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  /** List the models available to the account. */
+  list(options = {}) {
+    return this.#transport.request("GET", "/v1/models", options).map(unwrapModels);
+  }
+};
+var unwrapModels = (wire) => {
+  if (Array.isArray(wire?.models)) return wire.models;
+  throw new TypeSafeError("Unexpected response shape from GET /v1/models; expected { models: [...] }.");
+};
+var g = globalThis;
+var isBrowser = () => typeof g.window !== "undefined" && typeof g.window.document !== "undefined" && typeof g.navigator !== "undefined";
+var describeRuntime = () => {
+  const platform = g.process?.platform && g.process?.arch ? ` (${g.process.platform}; ${g.process.arch})` : "";
+  if (g.Bun?.version) return `bun/${g.Bun.version}${platform}`;
+  if (g.Deno?.version?.deno) return `deno/${g.Deno.version.deno}${platform}`;
+  if (g.EdgeRuntime !== void 0) return "vercel-edge";
+  if (g.navigator?.userAgent === "Cloudflare-Workers") return "cloudflare-workers";
+  if (g.process?.versions?.node) return `node/${g.process.versions.node}${platform}`;
+  if (isBrowser()) return "browser";
+  return "unknown";
+};
+var VERSION = "0.6.0";
+var missingApiKey = () => {
+  throw new TypeSafeError(`No API key was provided. Pass \`apiKey\` to the TypeSafeClient constructor or set the ${ENV.apiKey} environment variable.`);
+};
+var missingFetch = () => {
+  throw new TypeSafeError("No global `fetch` is available in this runtime. Pass a `fetch` implementation to the TypeSafeClient constructor.");
+};
+var refuseBrowser = () => {
+  throw new TypeSafeError("TypeSafeClient is running in a browser, which would expose your API key to anyone using the page. Call the API from a server instead, or pass `dangerouslyAllowBrowser: true` if you understand the risk.");
+};
+var defaultFetch = (input, init) => globalThis.fetch(input, init);
+var assertNonNegativeInteger = (name, value) => {
+  if (!Number.isInteger(value) || value < 0) throw new TypeSafeError(`\`${name}\` must be a non-negative integer, got ${String(value)}.`);
+  return value;
+};
+var assertPositiveMs = (name, value) => {
+  if (!Number.isFinite(value) || value <= 0) throw new TypeSafeError(`\`${name}\` must be a positive number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertNonNegativeMs = (name, value) => {
+  if (!Number.isFinite(value) || value < 0) throw new TypeSafeError(`\`${name}\` must be a non-negative number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertFraction = (name, value) => {
+  if (!Number.isFinite(value) || value < 0 || value > 1) throw new TypeSafeError(`\`${name}\` must be between 0 and 1, got ${String(value)}.`);
+  return value;
+};
+var assertStatusSet = (name, statuses) => {
+  for (const status of statuses) if (!Number.isInteger(status) || status < 100 || status > 999) throw new TypeSafeError(`\`${name}\` must contain HTTP status codes, got ${String(status)}.`);
+  return statuses;
+};
+var resolveRetryPolicy = (base, overrides) => {
+  const o = overrides ?? {};
+  return {
+    maxRetries: o.maxRetries === void 0 ? base.maxRetries : assertNonNegativeInteger("retry.maxRetries", o.maxRetries),
+    backoffInitialMs: o.backoffInitialMs === void 0 ? base.backoffInitialMs : assertNonNegativeMs("retry.backoffInitialMs", o.backoffInitialMs),
+    backoffMaxMs: o.backoffMaxMs === void 0 ? base.backoffMaxMs : assertNonNegativeMs("retry.backoffMaxMs", o.backoffMaxMs),
+    backoffJitter: o.backoffJitter === void 0 ? base.backoffJitter : assertFraction("retry.backoffJitter", o.backoffJitter),
+    httpStatuses: new Set(o.httpStatuses === void 0 ? base.httpStatuses : assertStatusSet("retry.httpStatuses", o.httpStatuses)),
+    respectRetryAfter: o.respectRetryAfter ?? base.respectRetryAfter,
+    maxRetryAfterMs: o.maxRetryAfterMs === void 0 ? base.maxRetryAfterMs : assertNonNegativeMs("retry.maxRetryAfterMs", o.maxRetryAfterMs),
+    apiConnectionError: o.apiConnectionError ?? base.apiConnectionError,
+    apiTimeoutError: o.apiTimeoutError ?? base.apiTimeoutError
+  };
+};
+var isRetryableError = (err, policy) => {
+  if (err instanceof APITimeoutError) return policy.apiTimeoutError;
+  if (err instanceof APIConnectionError) return policy.apiConnectionError;
+  return false;
+};
+var resolveLogLevel = (fromCode) => {
+  if (fromCode !== void 0) return parseLogLevel(fromCode, "the `logLevel` option");
+  const fromEnv = readEnv(ENV.logLevel);
+  if (fromEnv !== void 0) return parseLogLevel(fromEnv, ENV.logLevel);
+  return DEFAULT_LOG_LEVEL;
+};
+var stripTrailingSlashes = (url) => url.replace(/\/+$/, "");
+var mergeHeaders = (...sources) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const source of sources) for (const [name, value] of Object.entries(source)) if (value === void 0) entries.delete(name.toLowerCase());
+  else entries.set(name.toLowerCase(), [name, value]);
+  return Object.fromEntries(entries.values());
+};
+var bufferResponse = async (response, signal) => {
+  const reader = response.clone().body?.getReader();
+  if (!reader) return;
+  const cancel = () => {
+    reader.cancel(signal.reason).catch(() => {
+    });
+    response.body?.cancel(signal.reason).catch(() => {
+    });
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  try {
+    if (signal.aborted) cancel();
+    signal.throwIfAborted();
+    while (!(await reader.read()).done) signal.throwIfAborted();
+    signal.throwIfAborted();
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    reader.releaseLock();
+  }
+};
+var RUNTIME = describeRuntime();
+var TypeSafeClient = class {
+  /** API key excluded from serialization and public properties. */
+  #apiKey;
+  /** API root with trailing slashes removed. */
+  baseURL;
+  /** Model used when a request omits `model`. */
+  defaultModel;
+  /** Configured log verbosity. */
+  logLevel;
+  /** The configured logger, filtered to `logLevel`. */
+  logger;
+  /** Retry settings with constructor overrides applied. */
+  retry;
+  /** Timeout per attempt in milliseconds. */
+  timeout;
+  /** Additional headers sent with each request. */
+  defaultHeaders;
+  /** HTTP fetch implementation. */
+  fetch;
+  /** The models available to the account. */
+  models;
+  #requestCount = 0;
+  /**
+  * Create a client for the TypeSafe AI API.
+  *
+  * Explicit options take precedence over environment variables, then SDK defaults.
+  * Empty or whitespace-only environment values are ignored.
+  *
+  * @throws {TypeSafeError} The API key is missing, configuration is invalid, or the runtime is unsupported.
+  */
+  constructor(config = {}) {
+    if (isBrowser() && !config.dangerouslyAllowBrowser) refuseBrowser();
+    this.#apiKey = fromCodeOrEnv(config.apiKey, ENV.apiKey) ?? missingApiKey();
+    this.baseURL = stripTrailingSlashes(fromCodeOrEnv(config.baseURL, ENV.baseURL) ?? "https://api.typesafe.ai");
+    this.defaultModel = fromCodeOrEnv(config.defaultModel, ENV.defaultModel) ?? "jev-latest";
+    this.logLevel = resolveLogLevel(config.logLevel);
+    this.logger = withLevel(config.logger ?? consoleLogger, this.logLevel);
+    this.retry = resolveRetryPolicy(DEFAULT_RETRY_POLICY, config.retry);
+    this.timeout = assertPositiveMs("timeout", config.timeout ?? 1e4);
+    this.defaultHeaders = { ...config.defaultHeaders };
+    if (config.fetch === void 0 && typeof globalThis.fetch !== "function") missingFetch();
+    this.fetch = config.fetch ?? defaultFetch;
+    const transport = {
+      request: (method, path, options) => this.#request(method, path, options),
+      defaultModel: this.defaultModel
+    };
+    this.models = new Models(transport);
+  }
+  /**
+  * Answer named questions about text or structured state.
+  *
+  * @param request - State, questions, and an optional model override.
+  * @param options - Per-call timeout, retry, headers, and cancellation settings.
+  * @returns Answers typed by question name and criteria, with model and token usage.
+  * @throws {TypeSafeError} Questions are empty, or score criteria are not a list of at least two entries.
+  * @throws {APIError} The server returns a non-2xx response after retries.
+  * @throws {APIConnectionError} The request cannot connect or times out after retries.
+  * @throws {APIUserAbortError} The caller aborts the request.
+  *
+  * @example
+  * ```ts
+  * const { answers } = await client.systemOne({
+  *   state: "I was charged twice. Please help.",
+  *   questions: { billing: noul("Is this about billing?") },
+  * });
+  * console.log(answers.billing.noul);
+  * ```
+  */
+  systemOne(request, options = {}) {
+    validateQuestions(request.questions);
+    const body = {
+      ...request,
+      model: request.model ?? this.defaultModel
+    };
+    return this.#request("POST", "/v1/systemone", {
+      ...options,
+      body
+    });
+  }
+  /** Send a request and parse its response body. */
+  #request(method, path, options = {}) {
+    const resolved = {
+      method,
+      path,
+      body: options.body,
+      headers: mergeHeaders(this.defaultHeaders, options.headers ?? {}),
+      signal: options.signal,
+      timeout: options.timeout === void 0 ? this.timeout : assertPositiveMs("timeout", options.timeout),
+      retry: resolveRetryPolicy(this.retry, options.retry)
+    };
+    const tag = `#${++this.#requestCount} ${method} ${path}`;
+    return new APIPromise(this.fetchWithRetries(tag, resolved), async (res) => {
+      const parsed = await parseBody(res);
+      this.logger.debug(`${tag} <- body`, parsed);
+      return parsed;
+    });
+  }
+  /** Retry eligible failures, logging attempt summaries at `info` and headers and bodies at `debug`. */
+  async fetchWithRetries(tag, req) {
+    const url = `${this.baseURL}${req.path}`;
+    const headers = mergeHeaders(req.headers, {
+      Authorization: `Bearer ${this.#apiKey}`,
+      Accept: "application/json",
+      "User-Agent": `typesafe-sdk/${VERSION}`,
+      "X-TypeSafe-SDK": `typesafe-sdk/${VERSION}`,
+      "X-TypeSafe-Runtime": RUNTIME,
+      "Content-Type": req.body === void 0 ? void 0 : "application/json",
+      "X-TypeSafe-Retry-Count": void 0
+    });
+    const body = req.body === void 0 ? void 0 : JSON.stringify(req.body);
+    for (let attempt = 0; ; attempt++) {
+      const retriesLeft = req.retry.maxRetries - attempt;
+      const attemptHeaders = attempt === 0 ? headers : {
+        ...headers,
+        "X-TypeSafe-Retry-Count": String(attempt)
+      };
+      this.logger.debug(`${tag} -> ${url}`, {
+        headers: redactHeaders(attemptHeaders),
+        body: req.body
+      });
+      const started = Date.now();
+      let res;
+      try {
+        res = await this.attempt(tag, url, {
+          method: req.method,
+          headers: attemptHeaders,
+          body
+        }, req);
+      } catch (err) {
+        if (err instanceof APIUserAbortError || retriesLeft <= 0) throw err;
+        if (!isRetryableError(err, req.retry)) throw err;
+        await this.backOff(tag, attempt, retriesLeft, err.message, void 0, req);
+        continue;
+      }
+      const requestId = requestIdFrom(res.headers);
+      this.logger.info(`${tag} <- ${res.status} in ${Date.now() - started}ms${requestId ? ` (request ${requestId})` : ""}`);
+      if (res.ok) return res;
+      const errorBody = await parseBody(res);
+      this.logger.debug(`${tag} <- error body`, errorBody);
+      const error = APIError.fromResponse(res.status, errorBody, res.headers);
+      if (retriesLeft <= 0 || !isRetryableStatus(res.status, req.retry)) throw error;
+      await this.backOff(tag, attempt, retriesLeft, `${res.status}`, res.headers, req);
+    }
+  }
+  /**
+  * One HTTP round trip, including body delivery, with a timeout. The caller's signal and our
+  * timer both abort the same controller; we check which fired to choose the error class.
+  */
+  async attempt(tag, url, init, { signal, timeout }) {
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(signal?.reason);
+    if (signal?.aborted) abortFromCaller();
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    const started = Date.now();
+    const elapsed = () => `${Date.now() - started}ms`;
+    try {
+      const response = await this.fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      await bufferResponse(response, controller.signal);
+      return response;
+    } catch (err) {
+      if (signal?.aborted) {
+        this.logger.info(`${tag} aborted by caller after ${elapsed()}`);
+        throw new APIUserAbortError(void 0, { cause: err });
+      }
+      if (timedOut) {
+        this.logger.info(`${tag} timed out after ${elapsed()}`);
+        throw new APITimeoutError(timeout, { cause: err });
+      }
+      this.logger.info(`${tag} connection error after ${elapsed()}`, err);
+      throw new APIConnectionError(err instanceof Error ? `Connection error: ${err.message}` : void 0, { cause: err });
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+  /** Wait before retrying; caller cancellation throws `APIUserAbortError`. */
+  async backOff(tag, attempt, retriesLeft, reason, headers, { retry, signal }) {
+    const delay2 = retryDelayMs(attempt, headers, retry);
+    const nth = attempt + 1;
+    const total2 = attempt + retriesLeft;
+    this.logger.info(`${tag} retrying in ${delay2}ms (retry ${nth}/${total2}) after ${reason}`);
+    try {
+      await sleep(delay2, signal);
+    } catch (err) {
+      this.logger.info(`${tag} aborted by caller while waiting to retry`);
+      throw new APIUserAbortError(void 0, { cause: err });
+    }
+  }
+};
+var parseBody = async (res) => {
+  const text = await res.text();
+  if (text.length === 0) return void 0;
+  if ((res.headers.get("content-type") ?? "").includes("application/json")) try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+
+// src/core/jevClient.ts
+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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(payload)) {
+    return {};
+  }
+  const answers = payload.answers;
+  return isRecord2(answers) ? answers : {};
+}
+function readUsage(payload) {
+  if (!isRecord2(payload)) {
+    return { inputTokens: 0, outputTokens: 0 };
+  }
+  const usage = payload.usage;
+  if (!isRecord2(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 (!isRecord2(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 isRecord2(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 (!isRecord3(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 (!isRecord3(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 = isRecord3(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 (!isRecord3(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 (!isRecord3(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((resolve3) => {
+    setTimeout(resolve3, ms);
+  });
+}
+function isRecord3(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((resolve3, 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;
+      resolve3({
+        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 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;
+}
+
+// src/version.ts
+var VERSION2 = "0.1.0";
+
+// src/cli/args.ts
+import { parseArgs } from "node:util";
+var PARSE_CONFIG = {
+  allowPositionals: true,
+  strict: true,
+  options: {
+    exclude: { type: "string" },
+    "dry-run": { type: "boolean" },
+    yes: { type: "boolean" },
+    json: { type: "boolean" },
+    threshold: { type: "string" },
+    "no-color": { type: "boolean" },
+    help: { type: "boolean" },
+    version: { type: "boolean" }
+  }
+};
+function usageText() {
+  return [
+    'usage: git jev-stage "<sentence>" [options]',
+    "",
+    "Stages the unstaged hunks that match the sentence.",
+    "",
+    "options:",
+    '  --exclude "<sentence>"  never stage hunks that match this sentence',
+    "  --threshold <n>         confidence needed to stage or skip a hunk, 0-1 (default 0.6)",
+    "  --dry-run               print the plan and the composed patch, stage nothing",
+    "  --yes                   skip prompts and leave mixed hunks unstaged",
+    "  --json                  print one JSON document; stages only with --yes",
+    "  --no-color              turn off color",
+    "  --help                  print this message",
+    "  --version               print the version"
+  ].join("\n");
+}
+function parseCliArgs(argv) {
+  const { values, positionals } = runParseArgs(argv);
+  const help = values.help ?? false;
+  const version = values.version ?? false;
+  const common = {
+    dryRun: values["dry-run"] ?? false,
+    yes: values.yes ?? false,
+    json: values.json ?? false,
+    threshold: parseThreshold(values.threshold),
+    color: !(values["no-color"] ?? false),
+    help,
+    version
+  };
+  if (help || version) {
+    return { intent: "", ...common };
+  }
+  const exclude = values.exclude;
+  return {
+    intent: parseIntent(positionals),
+    ...exclude === void 0 ? {} : { exclude: parseExclude(exclude) },
+    ...common
+  };
+}
+function runParseArgs(argv) {
+  try {
+    return parseArgs({ ...PARSE_CONFIG, args: [...argv] });
+  } catch (error) {
+    throw new UsageError(error instanceof Error ? error.message : String(error), { cause: error });
+  }
+}
+function parseIntent(positionals) {
+  const first = positionals[0];
+  if (first === void 0) {
+    throw new UsageError('missing sentence; git jev-stage "<sentence>"');
+  }
+  if (positionals.length > 1) {
+    throw new UsageError(
+      `expected one sentence, got ${positionals.length}; quote the whole sentence`
+    );
+  }
+  if (first.trim().length === 0) {
+    throw new UsageError("the sentence is empty");
+  }
+  return first;
+}
+function parseExclude(value) {
+  if (value.trim().length === 0) {
+    throw new UsageError("--exclude is empty");
+  }
+  return value;
+}
+function parseThreshold(value) {
+  if (value === void 0) {
+    return DEFAULT_THRESHOLD;
+  }
+  const threshold = Number(value);
+  if (!Number.isFinite(threshold) || threshold <= 0 || threshold > 1) {
+    throw new UsageError(`--threshold must be greater than 0 and at most 1, got ${value}`);
+  }
+  return threshold;
+}
+
+// src/cli/json.ts
+var JSON_INDENT = 2;
+function buildJsonDocument({
+  plan,
+  applied,
+  stagedHunkIds,
+  mixedHunkIds
+}) {
+  const { snapshot } = plan;
+  return {
+    version: VERSION2,
+    intent: plan.intent,
+    ...plan.exclude === void 0 ? {} : { exclude: plan.exclude },
+    threshold: plan.threshold,
+    head: snapshot.headOid,
+    indexHash: snapshot.indexHash,
+    diffHash: snapshot.diffHash,
+    files: snapshot.files.map((file) => ({
+      path: file.path,
+      kind: file.kind,
+      hunks: file.hunks.map((hunk) => {
+        const decision = plan.decisions.get(hunk.id);
+        return {
+          id: hunk.id,
+          header: hunk.header,
+          text: hunk.text,
+          added: hunk.added,
+          removed: hunk.removed,
+          decision: decision?.decision ?? "mixed",
+          source: decision?.source ?? "missing",
+          ...decision?.confidence === void 0 ? {} : { confidence: decision.confidence },
+          ...decision?.probabilities === void 0 ? {} : { probabilities: decision.probabilities }
+        };
+      })
+    })),
+    skipped: snapshot.skipped.map((entry) => ({ path: entry.path, reason: entry.reason })),
+    usage: plan.usage,
+    applied,
+    stagedHunkIds: [...stagedHunkIds],
+    mixedHunkIds: [...mixedHunkIds]
+  };
+}
+function renderJsonDocument(options) {
+  return `${JSON.stringify(buildJsonDocument(options), null, JSON_INDENT)}
+`;
+}
+
+// src/cli/loadEnv.ts
+import { existsSync, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+var ENV_LINE = /^([A-Za-z_][A-Za-z0-9_]*)[ \t]*=(.*)$/;
+function loadDotEnv(dir, env = process.env) {
+  const contents = readDotEnv(join2(dir, ".env"));
+  if (contents === void 0) {
+    return 0;
+  }
+  let loaded = 0;
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#")) {
+      continue;
+    }
+    const match = ENV_LINE.exec(line);
+    if (match === null) {
+      continue;
+    }
+    const key = match[1];
+    const rawValue = match[2];
+    if (key === void 0 || rawValue === void 0 || env[key] !== void 0) {
+      continue;
+    }
+    env[key] = unquote(rawValue.trim());
+    loaded += 1;
+  }
+  return loaded;
+}
+function readDotEnv(path) {
+  try {
+    return readFileSync4(path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && (error.code === "ENOENT" || error.code === "EISDIR")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function unquote(value) {
+  const first = value[0];
+  if (value.length >= 2 && (first === '"' || first === "'") && value.endsWith(first)) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function loadDotEnvFromTree(cwd, env = process.env) {
+  let dir = resolve2(cwd);
+  for (; ; ) {
+    if (existsSync(join2(dir, ".env"))) {
+      return loadDotEnv(dir, env);
+    }
+    if (existsSync(join2(dir, ".git"))) {
+      return 0;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return 0;
+    }
+    dir = parent;
+  }
+}
+
+// src/cli/prompt.ts
+var NO_TTY_MESSAGE = "no TTY; use --yes, --dry-run or --json";
+var AFFIRMATIVE = /* @__PURE__ */ new Set(["y", "yes"]);
+async function confirm(question, io) {
+  if (!io.isStdinTty) {
+    throw new UsageError(NO_TTY_MESSAGE);
+  }
+  io.stdout(`${question} [y/N] `);
+  const answer = await io.readLine();
+  return answer !== void 0 && AFFIRMATIVE.has(answer.trim().toLowerCase());
+}
+async function askHunk(hunk, io) {
+  if (!io.isStdinTty) {
+    throw new UsageError(NO_TTY_MESSAGE);
+  }
+  const body = hunk.text.endsWith("\n") ? hunk.text : `${hunk.text}
+`;
+  io.stdout(`
+${hunk.path}
+${body}`);
+  return confirm("stage this hunk?", io);
+}
+
+// src/cli/render.ts
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var DIM = "\x1B[2m";
+var ID_LENGTH = 8;
+var PROBABILITY_DIGITS = 2;
+var DECISION_MARKS = Object.freeze({
+  include: "+",
+  exclude: "-",
+  mixed: "?"
+});
+var FILE_MARKS = Object.freeze({
+  modified: "M",
+  added: "A",
+  deleted: "D",
+  "mode-only": "M"
+});
+var PROBABILITY_ORDER = Object.freeze(["include", "exclude", "mixed"]);
+function shouldColor({ requested, isTty, noColor }) {
+  return requested && isTty && (noColor === void 0 || noColor.length === 0);
+}
+function renderPlan({ plan, includeIds, color }) {
+  const lines = [];
+  for (const file of plan.snapshot.files) {
+    lines.push(`${FILE_MARKS[file.kind]} ${file.path}`);
+    for (const hunk of file.hunks) {
+      lines.push(renderHunk(hunk.id, hunk.header, plan.decisions.get(hunk.id), color));
+    }
+  }
+  for (const skipped of plan.snapshot.skipped) {
+    lines.push(`skipped: ${skipped.path} (${skipped.reason})`);
+  }
+  const summary = summarizeSelection(plan.snapshot.files, includeIds);
+  lines.push(
+    `will stage: ${count(summary.hunks, "hunk")}, ${count(summary.files, "file")} (+${summary.added} -${summary.removed})`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function renderPatch(patch, write) {
+  if (patch.length === 0) {
+    return;
+  }
+  write(patch);
+}
+function renderHunk(hunkId, header, decision, color) {
+  const resolved = decision?.decision ?? "mixed";
+  const mark = colorize(DECISION_MARKS[resolved], resolved, color);
+  const parts = [`  ${mark} ${hunkId.slice(0, ID_LENGTH)} ${header}`];
+  const probabilities = decision?.probabilities;
+  if (probabilities !== void 0) {
+    parts.push(renderProbabilities(probabilities));
+  }
+  if (decision !== void 0 && decision.source !== "model") {
+    parts.push(decision.source);
+  }
+  return parts.join("  ");
+}
+function renderProbabilities(probabilities) {
+  return PROBABILITY_ORDER.map(
+    (label) => `${label} ${(probabilities[label] ?? 0).toFixed(PROBABILITY_DIGITS)}`
+  ).join("  ");
+}
+function colorize(mark, decision, color) {
+  if (!color) {
+    return mark;
+  }
+  if (decision === "include") {
+    return `${GREEN}${mark}${RESET}`;
+  }
+  if (decision === "exclude") {
+    return `${DIM}${RED}${mark}${RESET}`;
+  }
+  return `${YELLOW}${mark}${RESET}`;
+}
+function count(n, noun) {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+
+// src/cli/main.ts
+var SIGINT_EXIT_CODE = 130;
+var SIGTERM_EXIT_CODE = 143;
+var FAKE_PROVIDER_ENV = "GIT_JEV_STAGE_FAKE_PROVIDER";
+async function run(argv, io) {
+  try {
+    loadDotEnvFromTree(io.cwd, io.env);
+    const options = parseCliArgs(argv);
+    if (options.help) {
+      io.stdout(`${usageText()}
+`);
+      return 0;
+    }
+    if (options.version) {
+      io.stdout(`${VERSION2}
+`);
+      return 0;
+    }
+    await stage(options, io);
+    return 0;
+  } catch (error) {
+    const { message, exitCode } = toExit(error);
+    io.stderr(`${message}
+`);
+    return exitCode;
+  }
+}
+async function main(argv) {
+  const reader = createLineReader();
+  const io = {
+    stdout: (text) => {
+      process.stdout.write(text);
+    },
+    stderr: (text) => {
+      process.stderr.write(text);
+    },
+    stdoutBytes: (bytes) => {
+      process.stdout.write(bytes);
+    },
+    isStdoutTty: process.stdout.isTTY === true,
+    isStdinTty: process.stdin.isTTY === true,
+    readLine: () => reader.readLine(),
+    cwd: process.cwd(),
+    env: process.env
+  };
+  const onInterrupt = createSignalHandler(SIGINT_EXIT_CODE);
+  const onTerminate = createSignalHandler(SIGTERM_EXIT_CODE);
+  process.on("SIGINT", onInterrupt);
+  process.on("SIGTERM", onTerminate);
+  try {
+    return await run(argv, io);
+  } finally {
+    process.off("SIGINT", onInterrupt);
+    process.off("SIGTERM", onTerminate);
+    reader.close();
+  }
+}
+async function stage(options, io) {
+  const interactive = !options.json && !options.yes && !options.dryRun;
+  if (interactive && !io.isStdinTty) {
+    throw new UsageError(NO_TTY_MESSAGE);
+  }
+  const provider = resolveProvider(io.env);
+  if (provider === void 0 && (options.yes || options.json)) {
+    throw new MissingApiKeyError();
+  }
+  const report = options.json ? io.stderr : io.stdout;
+  const plan = await planSelection({
+    cwd: io.cwd,
+    intent: options.intent,
+    ...options.exclude === void 0 ? {} : { exclude: options.exclude },
+    threshold: options.threshold,
+    ...provider === void 0 ? {} : { provider }
+  });
+  if (plan.snapshot.files.length === 0) {
+    if (options.json) {
+      io.stdout(renderJsonDocument({ plan, applied: false, stagedHunkIds: [], mixedHunkIds: [] }));
+      return;
+    }
+    report("nothing to stage\n");
+    return;
+  }
+  const decided = provider === void 0 && interactive ? await decideByHand(plan, io) : plan;
+  const includeIds = new Set(idsWithDecision(decided, "include"));
+  report(
+    renderPlan({
+      plan: decided,
+      includeIds,
+      color: shouldColor({
+        requested: options.color,
+        isTty: io.isStdoutTty,
+        noColor: io.env.NO_COLOR
+      })
+    })
+  );
+  if (options.dryRun) {
+    if (options.json) {
+      io.stdout(renderJsonDocument(plannedDocument(decided, includeIds)));
+      return;
+    }
+    renderPatch(composePatch(decided.snapshot.files, includeIds), io.stdoutBytes);
+    return;
+  }
+  if (interactive) {
+    for (const hunk of hunksWithDecision(decided, "mixed")) {
+      if (await askHunk(hunk, io)) {
+        includeIds.add(hunk.id);
+      }
+    }
+    const pending = summarizeSelection(decided.snapshot.files, includeIds);
+    const confirmed = await confirm(
+      `stage ${count(pending.hunks, "hunk")} in ${count(pending.files, "file")}?`,
+      io
+    );
+    if (!confirmed) {
+      report("nothing staged\n");
+      return;
+    }
+  }
+  if (options.json && !options.yes) {
+    io.stdout(renderJsonDocument(plannedDocument(decided, includeIds)));
+    return;
+  }
+  const result = await applySelection(decided, { includeIds: [...includeIds] });
+  if (options.json) {
+    io.stdout(
+      renderJsonDocument({
+        plan: decided,
+        applied: true,
+        stagedHunkIds: result.stagedHunkIds,
+        mixedHunkIds: result.skippedMixedIds
+      })
+    );
+  }
+  const staged = summarizeSelection(decided.snapshot.files, new Set(result.stagedHunkIds));
+  report(`staged ${count(staged.hunks, "hunk")} in ${count(staged.files, "file")}
+`);
+  if (result.skippedMixedIds.length > 0) {
+    report(`left unstaged: ${count(result.skippedMixedIds.length, "mixed hunk")}
+`);
+  }
+}
+function plannedDocument(plan, includeIds) {
+  return {
+    plan,
+    applied: false,
+    stagedHunkIds: [],
+    mixedHunkIds: idsWithDecision(plan, "mixed").filter((id) => !includeIds.has(id))
+  };
+}
+async function decideByHand(plan, io) {
+  io.stdout("no TYPESAFE_API_KEY, deciding by hand\n");
+  const decisions = /* @__PURE__ */ new Map();
+  for (const file of plan.snapshot.files) {
+    for (const hunk of file.hunks) {
+      const wanted = await askHunk(hunk, io);
+      decisions.set(hunk.id, {
+        hunkId: hunk.id,
+        decision: wanted ? "include" : "exclude",
+        source: "manual"
+      });
+    }
+  }
+  return { ...plan, decisions };
+}
+function resolveProvider(env) {
+  const scriptPath = env[FAKE_PROVIDER_ENV];
+  if (scriptPath !== void 0 && scriptPath.length > 0) {
+    return FakeProvider.fromJsonFile(scriptPath);
+  }
+  return createProviderFromEnv(env);
+}
+function idsWithDecision(plan, decision) {
+  return hunksWithDecision(plan, decision).map((hunk) => hunk.id);
+}
+function hunksWithDecision(plan, decision) {
+  const hunks = [];
+  for (const file of plan.snapshot.files) {
+    for (const hunk of file.hunks) {
+      if (plan.decisions.get(hunk.id)?.decision === decision) {
+        hunks.push(hunk);
+      }
+    }
+  }
+  return hunks;
+}
+function toExit(error) {
+  if (error instanceof JevStageError) {
+    return { message: `git-jev-stage: ${error.code}: ${error.message}`, exitCode: error.exitCode };
+  }
+  if (error instanceof ProviderError || error instanceof ProviderConfigError) {
+    return { message: `git-jev-stage: provider: ${error.message}`, exitCode: 1 };
+  }
+  const detail = error instanceof Error ? error.message : String(error);
+  return { message: `git-jev-stage: internal: ${detail}`, exitCode: 1 };
+}
+function createLineReader() {
+  let readerInterface;
+  let lines;
+  return {
+    async readLine() {
+      if (lines === void 0) {
+        readerInterface = createInterface({
+          input: process.stdin,
+          crlfDelay: Number.POSITIVE_INFINITY
+        });
+        lines = readerInterface[Symbol.asyncIterator]();
+      }
+      const next = await lines.next();
+      return next.done === true ? void 0 : next.value;
+    },
+    close() {
+      readerInterface?.close();
+      readerInterface = void 0;
+      lines = void 0;
+    }
+  };
+}
+function createSignalHandler(exitCode) {
+  return () => {
+    cleanupOwnedPaths();
+    process.exit(exitCode);
+  };
+}
+function isEntryPoint() {
+  const entry = process.argv[1];
+  if (entry === void 0) {
+    return false;
+  }
+  try {
+    return pathToFileURL(realpathSync(entry)).href === import.meta.url;
+  } catch {
+    return false;
+  }
+}
+if (isEntryPoint()) {
+  process.exitCode = await main(process.argv.slice(2));
+}
+export {
+  main,
+  run
+};