jevprune 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -246,6 +246,15 @@ declare class LineRangeError extends JevpruneError {
 
 type SelectionMode = "fast-path" | "passthrough" | "jev" | "fallback";
 type DecisionReason = "fast-path" | "passthrough" | "tail" | "signature" | "context" | "blank" | "oversize" | "jev" | "collapse-min" | "head" | "fallback";
+type FallbackReason = {
+    readonly kind: "unavailable";
+    readonly detail: string;
+} | {
+    readonly kind: "size-limit";
+    readonly maxBytes: number;
+} | {
+    readonly kind: "not-utf8";
+};
 interface Decision {
     keep: boolean;
     reason: DecisionReason;
@@ -263,7 +272,7 @@ interface FooterInput {
     readonly linesOut: number;
     readonly exitCode?: number | null;
     readonly logPath?: string;
-    readonly fallbackReason?: string;
+    readonly fallbackReason?: FallbackReason;
     readonly passthroughNote?: string;
     readonly storeFailureCode?: string;
     readonly home?: string;
@@ -326,7 +335,7 @@ interface SelectInput {
 interface PassthroughInput {
     readonly bytes: number;
     readonly lines: number;
-    readonly reason?: string;
+    readonly reason?: FallbackReason;
 }
 interface SelectionResult {
     readonly mode: SelectionMode;
@@ -339,12 +348,13 @@ interface SelectionResult {
     readonly windows: number;
     readonly jevRequests: number;
     readonly jevInputTokens: number;
-    readonly fallbackReason?: string;
+    readonly fallbackReason?: FallbackReason;
     readonly decisions: Map<number, Decision>;
 }
 declare function passthroughSelection(input: PassthroughInput): SelectionResult;
 declare function questionFor(n: number): string;
 declare function selectLines(input: SelectInput): Promise<SelectionResult>;
+declare function fallbackReasonText(reason: FallbackReason): string;
 
 interface RunMeta {
     readonly id: string;
@@ -438,7 +448,7 @@ interface PruneResult {
     readonly mode: SelectionMode;
     readonly linesIn: number;
     readonly linesOut: number;
-    readonly fallbackReason?: string;
+    readonly fallbackReason?: FallbackReason;
     readonly logPath?: string;
     readonly footer: string;
 }
@@ -459,4 +469,4 @@ interface ResolvedTask {
 }
 declare function resolveTask(input: TaskInput): Promise<ResolvedTask>;
 
-export { CHARS_PER_TOKEN, type ChoiceAnswer, type ChoiceQuestionSpec, type ChoiceRequest, type ChoiceResult, type ChoiceScorer, type Config, ConfigError, DEFAULT_ALLOWLIST, DEFAULT_CONFIG, DEFAULT_JEV_MAX_RETRIES, DEFAULT_JEV_MODEL, DEFAULT_JEV_TIMEOUT_MS, DEFAULT_WINDOW_CONCURRENCY, DEFAULT_WINDOW_TIMEOUT_MS, DEFAULT_WINDOW_TOKENS, type Decision, type DecisionReason, type DroppedRange, type FakeJevCall, FakeJevClient, type FakeJevOptions, type FooterInput, type GainEntry, type GainTotals, JevAbortError, JevBudgetError, type JevClient, JevConfigError, JevCoreError, JevInputError, JevRequestError, type JevRequestOptions, JevResponseError, type JevState, JevTimeoutError, type JevUsage, JevpruneError, type KeepReason, type Line, LineRangeError, type LineTerminator, MAX_REQUEST_TOKENS, MAX_TASK_LENGTH, type MergeOptions, type MergeResult, NOT_UTF8_NOTE, NOT_UTF8_REASON, type NoulRequest, type NoulResult, type NoulScorer, type OversizeCapture, type PassthroughInput, type PlanWindowsOptions, type PruneInput, type PruneResult, type PruneStreamInput, RUBRIC, type ResolvedConfig, type ResolvedTask, type RetentionConfig, type RunMeta, RunNotFoundError, type RunRecord, RunStore, RunStoreError, type RunWindowsOptions, type RunWriter, SIGNATURE_CASE_INSENSITIVE, SIGNATURE_CASE_SENSITIVE, type SelectInput, type SelectionMode, type SelectionResult, SpawnError, TYPESAFE_API_KEY_ENV, TYPESAFE_BASE_URL_ENV, type TaskInput, type TaskSource, TranscriptError, TypeSafeJevClient, type TypeSafeJevClientConfig, UsageError, type WindowItem, type WindowJudge, type WindowPlan, byteLineStarts, collapseMarker, computeKeeps, countByteLines, createJevClientFromEnv, describeError, displayPath, estimateJsonTokens, estimateTokens, footerAfter, formatCount, formatFooter, isSignatureLine, isValidUtf8, joinLines, loadConfig, mergeDecisions, newRunId, parseThreshold, passthroughSelection, planWindows, pruneOutput, pruneStream, questionFor, resolveHome, resolveTask, runWindows, selectLines, splitLines, toJevError, validateChoiceAnswers, validateNoulAnswers, withFooter };
+export { CHARS_PER_TOKEN, type ChoiceAnswer, type ChoiceQuestionSpec, type ChoiceRequest, type ChoiceResult, type ChoiceScorer, type Config, ConfigError, DEFAULT_ALLOWLIST, DEFAULT_CONFIG, DEFAULT_JEV_MAX_RETRIES, DEFAULT_JEV_MODEL, DEFAULT_JEV_TIMEOUT_MS, DEFAULT_WINDOW_CONCURRENCY, DEFAULT_WINDOW_TIMEOUT_MS, DEFAULT_WINDOW_TOKENS, type Decision, type DecisionReason, type DroppedRange, type FakeJevCall, FakeJevClient, type FakeJevOptions, type FallbackReason, type FooterInput, type GainEntry, type GainTotals, JevAbortError, JevBudgetError, type JevClient, JevConfigError, JevCoreError, JevInputError, JevRequestError, type JevRequestOptions, JevResponseError, type JevState, JevTimeoutError, type JevUsage, JevpruneError, type KeepReason, type Line, LineRangeError, type LineTerminator, MAX_REQUEST_TOKENS, MAX_TASK_LENGTH, type MergeOptions, type MergeResult, NOT_UTF8_NOTE, NOT_UTF8_REASON, type NoulRequest, type NoulResult, type NoulScorer, type OversizeCapture, type PassthroughInput, type PlanWindowsOptions, type PruneInput, type PruneResult, type PruneStreamInput, RUBRIC, type ResolvedConfig, type ResolvedTask, type RetentionConfig, type RunMeta, RunNotFoundError, type RunRecord, RunStore, RunStoreError, type RunWindowsOptions, type RunWriter, SIGNATURE_CASE_INSENSITIVE, SIGNATURE_CASE_SENSITIVE, type SelectInput, type SelectionMode, type SelectionResult, SpawnError, TYPESAFE_API_KEY_ENV, TYPESAFE_BASE_URL_ENV, type TaskInput, type TaskSource, TranscriptError, TypeSafeJevClient, type TypeSafeJevClientConfig, UsageError, type WindowItem, type WindowJudge, type WindowPlan, byteLineStarts, collapseMarker, computeKeeps, countByteLines, createJevClientFromEnv, describeError, displayPath, estimateJsonTokens, estimateTokens, fallbackReasonText, footerAfter, formatCount, formatFooter, isSignatureLine, isValidUtf8, joinLines, loadConfig, mergeDecisions, newRunId, parseThreshold, passthroughSelection, planWindows, pruneOutput, pruneStream, questionFor, resolveHome, resolveTask, runWindows, selectLines, splitLines, toJevError, validateChoiceAnswers, validateNoulAnswers, withFooter };

package/dist/index.js

@@ -1196,7 +1196,7 @@ var DEFAULT_CONFIG = {
   concurrency: 4,
   maxPruneBytes: 16777216,
   retention: { maxRuns: 200, maxBytes: 268435456 },
-  autoWrap: true,
+  autoWrap: false,
   allowlist: DEFAULT_ALLOWLIST
 };
 function resolveHome(env = process.env) {
@@ -1320,48 +1320,6 @@ function describeValue(value) {
 // src/footer.ts
 import { homedir as homedir2 } from "os";
 import { sep } from "path";
-var LF2 = 10;
-function formatFooter(input) {
-  if (input.mode === "fast-path") return "";
-  const parts = [];
-  if (input.mode === "passthrough") {
-    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
-    const note = input.passthroughNote === void 0 ? "" : ` (${input.passthroughNote})`;
-    parts.push(`${formatCount(input.linesIn)} lines passed through${note}`);
-  } else {
-    if (input.mode === "fallback") parts.push(`fallback (no Jev: ${input.fallbackReason ?? "unknown"})`);
-    parts.push(`${formatCount(input.linesIn)} \u2192 ${formatCount(input.linesOut)} lines`);
-    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
-  }
-  if (input.storeFailureCode !== void 0) {
-    parts.push(`run store unavailable (${input.storeFailureCode})`);
-  } else if (input.logPath !== void 0) {
-    parts.push(`full output ${displayPath(input.logPath, input.home)}`);
-  }
-  return `jevprune: ${parts.join(", ")}`;
-}
-function footerAfter(lastByte, footer) {
-  if (footer.length === 0) return "";
-  const separator = lastByte === void 0 || lastByte === LF2 ? "" : "\n";
-  return `${separator}${footer}
-`;
-}
-function withFooter(kept, footer) {
-  if (footer.length === 0) return kept;
-  const separator = kept.length === 0 || kept.endsWith("\n") ? "" : "\n";
-  return `${kept}${separator}${footer}
-`;
-}
-function formatCount(value) {
-  const digits = Math.trunc(Math.abs(value)).toString();
-  const grouped = digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-  return value < 0 ? `-${grouped}` : grouped;
-}
-function displayPath(path, home = homedir2()) {
-  if (path === home) return "~";
-  if (home.length > 0 && path.startsWith(home + sep)) return `~${path.slice(home.length)}`;
-  return path;
-}
 
 // src/keeps.ts
 var SIGNATURE_CASE_SENSITIVE = /(^|\s)(FAIL|FAILED|ERROR|PANIC|FATAL)(\s|:|$)|\b[A-Z][A-Za-z]*(Error|Exception|Panic)\b|^\s*E\s{2,}\S|^npm ERR!|^\s*(Test Files|Tests|Test Suites)\s/;
@@ -1478,18 +1436,6 @@ function mergeDecisions(lines, decisions, options) {
   return { kept, dropped };
 }
 
-// src/io.ts
-async function readStreamBytes(stream) {
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
-  }
-  return Buffer.concat(chunks);
-}
-async function readStream(stream) {
-  return (await readStreamBytes(stream)).toString("utf8");
-}
-
 // src/select.ts
 var UNAUTHORIZED_REASON = "unauthorized (401)";
 var NOT_UTF8_REASON = "not valid UTF-8";
@@ -1543,7 +1489,14 @@ async function selectLines(input) {
     candidates.push({ id: `l${String(line.n)}`, n: line.n, text: line.text });
   }
   if (input.client === null) {
-    return fallbackSelection({ lines, keeps, input, reason: "no api key", bytesIn, linesIn: lines.length });
+    return fallbackSelection({
+      lines,
+      keeps,
+      input,
+      reason: { kind: "unavailable", detail: "API key not set" },
+      bytesIn,
+      linesIn: lines.length
+    });
   }
   let verdicts;
   try {
@@ -1553,7 +1506,7 @@ async function selectLines(input) {
       lines,
       keeps,
       input,
-      reason: fallbackReason(error),
+      reason: unavailableReason(error),
       bytesIn,
       linesIn: lines.length
     });
@@ -1660,7 +1613,7 @@ function oversizeSelection(input, oversize, captured, bytesIn) {
     lines,
     decisions: fallbackDecisions(lines, keeps, input.config.headLines),
     input,
-    reason: `output over ${String(input.config.maxPruneBytes)} bytes`,
+    reason: { kind: "size-limit", maxBytes: input.config.maxPruneBytes },
     bytesIn,
     linesIn: totalLines,
     totalLines
@@ -1701,7 +1654,20 @@ function fallbackResult(fallback) {
     decisions: fallback.decisions
   };
 }
-function fallbackReason(error) {
+function fallbackReasonText(reason) {
+  switch (reason.kind) {
+    case "size-limit":
+      return `output over ${String(reason.maxBytes)} bytes`;
+    case "not-utf8":
+      return NOT_UTF8_REASON;
+    case "unavailable":
+      return reason.detail;
+  }
+}
+function unavailableReason(error) {
+  return { kind: "unavailable", detail: unavailableDetail(error) };
+}
+function unavailableDetail(error) {
   if (error instanceof JevTimeoutError) return "timeout";
   if (error instanceof JevResponseError) return "invalid response";
   if (error instanceof JevRequestError) {
@@ -1741,6 +1707,207 @@ function everyLine(lines, mode, text, bytesIn) {
   };
 }
 
+// src/footer.ts
+var LF2 = 10;
+function formatFooter(input) {
+  if (input.mode === "fast-path") return "";
+  const parts = [];
+  if (input.mode === "passthrough") {
+    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
+    const note = input.passthroughNote === void 0 ? "" : ` (${input.passthroughNote})`;
+    parts.push(`${formatCount(input.linesIn)} lines passed through${note}`);
+  } else {
+    if (input.mode === "fallback") parts.push(`fallback (${fallbackNote(input.fallbackReason)})`);
+    parts.push(`${formatCount(input.linesIn)} \u2192 ${formatCount(input.linesOut)} lines`);
+    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
+  }
+  if (input.storeFailureCode !== void 0) {
+    parts.push(`full output was not saved (${input.storeFailureCode})`);
+  } else if (input.logPath !== void 0) {
+    parts.push(`full output ${displayPath(input.logPath, input.home)}`);
+  }
+  return `jevprune: ${parts.join(", ")}`;
+}
+function fallbackNote(reason) {
+  if (reason === void 0) return "Jev unavailable: unknown";
+  switch (reason.kind) {
+    case "size-limit":
+      return `output over ${String(reason.maxBytes)} bytes`;
+    case "not-utf8":
+      return NOT_UTF8_NOTE;
+    case "unavailable":
+      return `Jev unavailable: ${reason.detail}`;
+  }
+}
+function footerAfter(lastByte, footer) {
+  if (footer.length === 0) return "";
+  const separator = lastByte === void 0 || lastByte === LF2 ? "" : "\n";
+  return `${separator}${footer}
+`;
+}
+function withFooter(kept, footer) {
+  if (footer.length === 0) return kept;
+  const separator = kept.length === 0 || kept.endsWith("\n") ? "" : "\n";
+  return `${kept}${separator}${footer}
+`;
+}
+function formatCount(value) {
+  const digits = Math.trunc(Math.abs(value)).toString();
+  const grouped = digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return value < 0 ? `-${grouped}` : grouped;
+}
+function displayPath(path, home = homedir2()) {
+  if (path === home) return "~";
+  if (home.length > 0 && path.startsWith(home + sep)) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+// src/capture.ts
+var TAIL_RING_BYTES = 256 * 1024;
+var LF3 = 10;
+var CR2 = 13;
+var LineCounter = class {
+  #terminators = 0;
+  #pendingCr = false;
+  #lastByte;
+  push(chunk) {
+    for (const byte of chunk) {
+      if (this.#pendingCr) {
+        this.#pendingCr = false;
+        this.#terminators += 1;
+        if (byte === LF3) {
+          this.#lastByte = byte;
+          continue;
+        }
+      }
+      if (byte === CR2) {
+        this.#pendingCr = true;
+        this.#lastByte = byte;
+        continue;
+      }
+      if (byte === LF3) this.#terminators += 1;
+      this.#lastByte = byte;
+    }
+  }
+  get terminators() {
+    return this.#terminators + (this.#pendingCr ? 1 : 0);
+  }
+  get lines() {
+    if (this.#lastByte === void 0) return 0;
+    const endsWithTerminator = this.#lastByte === LF3 || this.#lastByte === CR2;
+    return this.terminators + (endsWithTerminator ? 0 : 1);
+  }
+};
+var CaptureBuffer = class {
+  #maxBytes;
+  #head = [];
+  #ring = [];
+  #headCounter = new LineCounter();
+  #headBytes = 0;
+  #ringBytes = 0;
+  #oversize = false;
+  constructor(maxBytes) {
+    this.#maxBytes = maxBytes;
+  }
+  get oversize() {
+    return this.#oversize;
+  }
+  get headSegmentLines() {
+    return this.#oversize ? this.#headCounter.terminators : this.#headCounter.lines;
+  }
+  push(chunk) {
+    let rest = chunk;
+    if (!this.#oversize) {
+      const room = this.#maxBytes - this.#headBytes;
+      if (rest.length <= room) {
+        this.#head.push(rest);
+        this.#headCounter.push(rest);
+        this.#headBytes += rest.length;
+        return;
+      }
+      if (room > 0) {
+        const head = rest.subarray(0, room);
+        this.#head.push(head);
+        this.#headCounter.push(head);
+        this.#headBytes += room;
+        rest = rest.subarray(room);
+      }
+      this.#oversize = true;
+    }
+    this.#ring.push(rest);
+    this.#ringBytes += rest.length;
+    this.#trimRing();
+  }
+  bytes() {
+    if (!this.#oversize) {
+      const single = this.#head.length === 1 ? this.#head[0] : void 0;
+      return single ?? Buffer.concat(this.#head);
+    }
+    const head = trimToLastTerminator(Buffer.concat(this.#head));
+    const tail = trimToFirstLine(Buffer.concat(this.#ring));
+    return Buffer.concat([head, tail]);
+  }
+  #trimRing() {
+    while (this.#ringBytes > TAIL_RING_BYTES) {
+      const first = this.#ring[0];
+      if (first === void 0) return;
+      const excess = this.#ringBytes - TAIL_RING_BYTES;
+      if (first.length <= excess) {
+        this.#ring.shift();
+        this.#ringBytes -= first.length;
+      } else {
+        this.#ring[0] = first.subarray(excess);
+        this.#ringBytes -= excess;
+      }
+    }
+  }
+};
+var OutputCapture = class {
+  #buffer;
+  #counter = new LineCounter();
+  #bytes = 0;
+  constructor(maxBytes) {
+    this.#buffer = new CaptureBuffer(maxBytes);
+  }
+  push(chunk) {
+    this.#bytes += chunk.length;
+    this.#counter.push(chunk);
+    this.#buffer.push(chunk);
+  }
+  result() {
+    return {
+      captured: this.#buffer.bytes(),
+      bytes: this.#bytes,
+      lines: this.#counter.lines,
+      headSegmentLines: this.#buffer.headSegmentLines,
+      oversize: this.#buffer.oversize
+    };
+  }
+};
+function captureBytes(bytes, maxBytes) {
+  const capture = new OutputCapture(maxBytes);
+  capture.push(bytes);
+  return capture.result();
+}
+function trimToLastTerminator(buffer) {
+  for (let index = buffer.length - 1; index >= 0; index -= 1) {
+    const byte = buffer[index];
+    if (byte === LF3 || byte === CR2) return buffer.subarray(0, index + 1);
+  }
+  return buffer.subarray(0, 0);
+}
+function trimToFirstLine(buffer) {
+  for (let index = 0; index < buffer.length; index += 1) {
+    const byte = buffer[index];
+    if (byte === LF3) return buffer.subarray(index + 1);
+    if (byte === CR2) {
+      const next = buffer[index + 1];
+      return buffer.subarray(next === LF3 ? index + 2 : index + 1);
+    }
+  }
+  return Buffer.alloc(0);
+}
+
 // src/store.ts
 import { randomBytes } from "crypto";
 import { createReadStream } from "fs";
@@ -2031,54 +2198,49 @@ function storeError(message, error) {
 
 // src/prune.ts
 async function pruneOutput(input) {
-  const env = input.env ?? process.env;
-  const config = mergeConfig(await loadConfig(env), input.config);
-  const client = input.client !== void 0 ? input.client : clientFromEnv(env);
-  const runId = newRunId();
-  const command = input.command ?? "";
-  const store = input.save === false ? null : new RunStore({ home: config.home, retention: config.retention });
+  const prepared = await prepare(input);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const selection = await selectLines({
-    text: input.text,
+  const bytes = Buffer.from(input.text, "utf8");
+  const capture = captureBytes(bytes, prepared.config.maxPruneBytes);
+  return await selectAndRecord({
+    prepared,
+    capture,
+    text: capture.oversize ? capture.captured.toString("utf8") : input.text,
     task: input.task,
-    command,
     exitCode: input.exitCode ?? null,
-    client,
-    config,
-    runId
+    startedAt,
+    logBytes: bytes
   });
-  const recorded = await recordRun({
-    store,
-    selection,
-    logText: input.text,
-    meta: {
-      id: runId,
-      command,
-      argv: [],
-      startedAt,
-      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      exitCode: input.exitCode ?? null,
-      signal: null,
-      bytes: selection.bytesIn,
-      lines: selection.linesIn,
-      task: input.task
-    }
-  });
-  return {
-    kept: selection.kept,
-    dropped: selection.dropped,
-    runId,
-    mode: selection.mode,
-    linesIn: selection.linesIn,
-    linesOut: selection.linesOut,
-    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
-    ...recorded.logPath !== void 0 ? { logPath: recorded.logPath } : {},
-    footer: recorded.footer
-  };
 }
 async function pruneStream(input) {
   const { stream, ...rest } = input;
-  return await pruneOutput({ ...rest, text: await readStream(stream) });
+  const prepared = await prepare(rest);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const sink = await openLogSink(prepared.store, prepared.runId);
+  const capture = new OutputCapture(prepared.config.maxPruneBytes);
+  try {
+    for await (const chunk of stream) {
+      const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+      capture.push(bytes);
+      await sink.write(bytes);
+    }
+  } catch (error) {
+    await sink.close();
+    await discardPartialRun(prepared.store, prepared.runId);
+    throw error;
+  }
+  await sink.close();
+  const output = capture.result();
+  const failureCode = sink.failureCode();
+  return await selectAndRecord({
+    prepared,
+    capture: output,
+    text: output.captured.toString("utf8"),
+    task: input.task,
+    exitCode: input.exitCode ?? null,
+    startedAt,
+    ...failureCode !== void 0 ? { storeFailureCode: failureCode } : {}
+  });
 }
 async function recordRun(input) {
   const { store, selection, meta } = input;
@@ -2095,7 +2257,7 @@ async function recordRun(input) {
           ...meta,
           mode: selection.mode,
           linesOut: selection.linesOut,
-          ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {}
+          ...selection.fallbackReason !== void 0 ? { fallbackReason: fallbackReasonText(selection.fallbackReason) } : {}
         });
       }
       await store.appendGain({
@@ -2106,7 +2268,7 @@ async function recordRun(input) {
         linesOut: selection.linesOut,
         bytesIn: selection.bytesIn,
         bytesOut: selection.bytesOut,
-        ...selection.fallbackReason !== void 0 ? { reason: selection.fallbackReason } : {}
+        ...selection.fallbackReason !== void 0 ? { reason: fallbackReasonText(selection.fallbackReason) } : {}
       });
       await store.enforceRetention();
     } catch (error) {
@@ -2143,6 +2305,97 @@ function mergeConfig(base, overrides) {
   }
   return { ...base, ...defined };
 }
+async function prepare(input) {
+  const env = input.env ?? process.env;
+  const config = mergeConfig(await loadConfig(env), input.config);
+  return {
+    config,
+    client: input.client !== void 0 ? input.client : clientFromEnv(env),
+    store: input.save === false ? null : new RunStore({ home: config.home, retention: config.retention }),
+    runId: newRunId(),
+    command: input.command ?? ""
+  };
+}
+async function selectAndRecord(input) {
+  const { prepared, capture } = input;
+  const selection = await selectLines({
+    text: input.text,
+    task: input.task,
+    command: prepared.command,
+    exitCode: input.exitCode,
+    ...capture.oversize ? { oversize: { lines: capture.lines, headSegmentLines: capture.headSegmentLines } } : {},
+    client: prepared.client,
+    config: prepared.config,
+    runId: prepared.runId
+  });
+  const recorded = await recordRun({
+    store: prepared.store,
+    selection,
+    ...input.logBytes !== void 0 ? { logBytes: input.logBytes } : {},
+    ...input.storeFailureCode !== void 0 ? { storeFailureCode: input.storeFailureCode } : {},
+    meta: {
+      id: prepared.runId,
+      command: prepared.command,
+      argv: [],
+      startedAt: input.startedAt,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exitCode: input.exitCode,
+      signal: null,
+      bytes: capture.bytes,
+      lines: selection.linesIn,
+      task: input.task
+    }
+  });
+  return {
+    kept: selection.kept,
+    dropped: selection.dropped,
+    runId: prepared.runId,
+    mode: selection.mode,
+    linesIn: selection.linesIn,
+    linesOut: selection.linesOut,
+    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
+    ...recorded.logPath !== void 0 ? { logPath: recorded.logPath } : {},
+    footer: recorded.footer
+  };
+}
+async function openLogSink(store, id) {
+  if (store === null) return discardingSink();
+  let writer;
+  try {
+    writer = await store.openRun({ id });
+  } catch (error) {
+    if (!(error instanceof RunStoreError)) throw error;
+    const code = error.code ?? "failed";
+    return { ...discardingSink(), failureCode: () => code };
+  }
+  return {
+    write: async (chunk) => {
+      if (writer.write(chunk)) return;
+      await new Promise((resolve2) => {
+        writer.onDrain(resolve2);
+      });
+    },
+    close: async () => {
+      await writer.close();
+    },
+    failureCode: () => writer.failure === void 0 ? void 0 : writer.failure.code ?? "failed"
+  };
+}
+async function discardPartialRun(store, id) {
+  if (store === null) return;
+  try {
+    await store.discardRun(id);
+  } catch (error) {
+    if (!(error instanceof RunStoreError)) throw error;
+  }
+}
+function discardingSink() {
+  return {
+    write: () => Promise.resolve(),
+    close: () => Promise.resolve(),
+    failureCode: () => void 0
+  };
+}
 async function writeLog(store, id, bytes) {
   const writer = await store.openRun({ id });
   writer.write(bytes);
@@ -2261,6 +2514,7 @@ export {
   displayPath,
   estimateJsonTokens,
   estimateTokens,
+  fallbackReasonText,
   footerAfter,
   formatCount,
   formatFooter,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jevprune",
-  "version": "0.1.0",
-  "description": "Keep only the lines of a command's output that matter for the current task, decided per line by Jev, with the full output saved on disk",
+  "version": "0.1.1",
+  "description": "Filter command output for coding agents using a task description.",
   "license": "MIT",
   "author": "ibrahemid",
   "repository": {