@cruxy/cli 1.0.3 → 1.0.5

package/dist/testing/run-tests-tool.d.ts

@@ -1,64 +0,0 @@
-import { z } from "zod";
-import type { Tool, ToolContext } from "../tools/types.js";
-import type { TestCommand, TestRunner } from "./types.js";
-/**
- * The `run_tests` tool (C.13): execute the project's test suite and return a
- * structured result the model can iterate on (edit → re-run → repeat). The
- * iteration loop itself is the ordinary agent loop; this module contributes
- * the two guarantees that make it trustworthy — honest green (exit-code-only)
- * and a hard cap on consecutive failing runs.
- */
-/**
- * Counts consecutive FAILING test executions; a green run resets it. When the
- * count reaches the cap, `trip` LATCHES: every further attempt is refused with
- * the coded CRUXY_E_TEST_ITERATION_LIMIT result (nothing executes) for the rest
- * of the episode. Because a refused attempt never runs, {@link record} is never
- * reached and the counter stays pinned at the cap — the breaker cannot re-arm
- * itself mid-episode. (This replaces a bug where `trip` zeroed the counter as it
- * tripped, so the very next call ran again and the "cap" was a speed bump, not a
- * stop: the model could burn the whole turn re-running a failing suite.)
- *
- * The latch is cleared by {@link reset}, called at the top of each user turn
- * (see `Session.send`) — so a fresh instruction starts with the full budget,
- * but the model cannot bypass the cap by simply calling the tool again within
- * one episode. A green run mid-streak still re-arms the budget via {@link record}.
- * Per-turn work stays bounded regardless via `agent.maxIterations`.
- */
-export declare class TestIterationBudget {
-    private failedRuns;
-    /** Runs already spent in the current failing streak. */
-    get spent(): number;
-    /**
-     * True when the next run must be refused. Latches at the cap: once the streak
-     * reaches `maxIterations` this keeps returning true (the refused call never
-     * executes, so {@link record} never runs and the counter stays pinned) until
-     * {@link reset} clears it at the next user turn.
-     */
-    trip(maxIterations: number): boolean;
-    record(passed: boolean): void;
-    /**
-     * Clear the failing streak, re-arming the breaker. Called at the start of each
-     * user turn so a new instruction starts fresh; within one turn the latch holds.
-     */
-    reset(): void;
-}
-declare const parameters: z.ZodObject<{
-    command: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    command?: string | undefined;
-}, {
-    command?: string | undefined;
-}>;
-export interface RunTestsToolDeps {
-    /**
-     * Execution seam (tests inject a fake). When unset, the runner is chosen per
-     * run from `ctx.sandbox`: present → {@link SandboxTestRunner} (run in the box,
-     * C.16), absent → host {@link CommandTestRunner} — unchanged.
-     */
-    runner?: TestRunner;
-    /** Detection seam (defaults to config + package.json detection). */
-    detect?: (ctx: ToolContext) => TestCommand | null;
-}
-/** Build the `run_tests` tool. One instance = one session's iteration budget. */
-export declare function makeRunTestsTool(deps?: RunTestsToolDeps): Tool<typeof parameters>;
-export {};

package/dist/testing/runner.d.ts

@@ -1,26 +0,0 @@
-import type { TestRunner, TestRunOptions, TestRunResult } from "./types.js";
-/**
- * The shipped {@link TestRunner}: spawn the command via the system shell (the
- * same detached-group + kill-tree discipline as `run_command`), capture a
- * TAIL-biased, byte-capped transcript (failures live at the end of test
- * output), and derive `passed` from the exit code — the only source of truth.
- * A timeout, a signal kill, or a spawn error is a *failed result*, never a
- * thrown exception and never a fabricated success.
- */
-export declare class CommandTestRunner implements TestRunner {
-    run(command: string, opts: TestRunOptions): Promise<TestRunResult>;
-}
-/**
- * A rolling, tail-biased capture: whole chunks are dropped from the FRONT
- * once the byte cap is exceeded, so the end of the output — where test
- * runners print their failure summaries — always survives.
- */
-export declare class TailCapture {
-    private readonly cap;
-    private chunks;
-    private bytes;
-    truncated: boolean;
-    constructor(cap: number);
-    push(buf: Buffer): void;
-    text(): string;
-}

package/dist/testing/sandbox-runner.d.ts

@@ -1,16 +0,0 @@
-import type { SandboxService } from "../sandbox/index.js";
-import type { TestRunner, TestRunOptions, TestRunResult } from "./types.js";
-/**
- * A {@link TestRunner} that runs the suite inside the C.16 sandbox instead of
- * on the host. It maps the neutral sandbox {@link ExecResult} onto the exact
- * same {@link TestRunResult} the host {@link CommandTestRunner} produces — so
- * honest-green (`passed = exitCode === 0`), tail-biased capture, and the
- * timeout note all hold identically inside the box. A container-start failure
- * is NOT swallowed into a result: `sandbox.exec` throws a coded error that
- * propagates (fail loud), never a fabricated pass.
- */
-export declare class SandboxTestRunner implements TestRunner {
-    private readonly sandbox;
-    constructor(sandbox: SandboxService);
-    run(command: string, opts: TestRunOptions): Promise<TestRunResult>;
-}

package/dist/testing/types.d.ts

@@ -1,66 +0,0 @@
-/**
- * Types for the test-execution loop (C.13): run the project's test suite,
- * parse what's honestly parseable, and let the agent iterate on failures
- * under a hard cap. The cardinal rule lives in `runner.ts`: **passed is
- * derived from the exit code and nothing else.**
- */
-import type { ShellSelection } from "../tools/shell/resolve-shell.js";
-/** A resolved test command and where it came from — shown, never guessed. */
-export interface TestCommand {
-    command: string;
-    source: "config" | "package-json";
-}
-/** One extracted failure. Every field beyond `name`/`message` is best-effort. */
-export interface TestFailure {
-    name: string;
-    message: string;
-    file?: string;
-    line?: number;
-}
-/** The structured outcome of one test-suite execution. */
-export interface TestRunResult {
-    /** `exitCode === 0`, full stop — never inferred from output text. */
-    passed: boolean;
-    /** The command's exit code; `null` when killed by signal or never spawned. */
-    exitCode: number | null;
-    /** Measured wall time of the execution. */
-    durationMs: number;
-    /** Total tests, only when a parser confidently extracted it. */
-    total?: number;
-    /** Best-effort extracted failures; may be empty even when `passed` is false. */
-    failures: TestFailure[];
-    /** Tail-biased captured stdout+stderr, capped at `test.captureBytes`. */
-    output: string;
-    /** Whether the head of the output was dropped to honor the byte cap. */
-    outputTruncated: boolean;
-}
-/** Execution bounds handed to a runner per run. */
-export interface TestRunOptions {
-    cwd: string;
-    /** Kill the run (and its process tree) after this many ms. */
-    timeoutMs: number;
-    /** Cap on captured output bytes (tail-biased). */
-    captureBytes: number;
-    /** Shell selection, so the host runner routes through the resolved shell (Git
-     * Bash / PowerShell on Windows) — the same seam as run_command. The sandbox
-     * runner ignores it (the container has its own shell). */
-    shell: ShellSelection;
-}
-/**
- * The swappable execution seam (same discipline as VectorStore/ForgeProvider):
- * the shipped {@link CommandTestRunner} spawns the command via the resolved
- * shell; tests inject fakes, and a future framework-native runner (e.g. a
- * vitest API runner) slots in without touching the tool.
- */
-export interface TestRunner {
-    run(command: string, opts: TestRunOptions): Promise<TestRunResult>;
-}
-/**
- * A pluggable best-effort failure extractor: given the captured output,
- * return whatever structure it can positively recognize — and nothing it
- * can't. Parsers never touch `passed` and never fabricate counts.
- */
-export type FailureParser = (output: string) => {
-    failures: TestFailure[];
-    total?: number;
-};

package/dist/theme/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./tokens.js";
-export * from "./resolve.js";

package/dist/theme/resolve.d.ts

@@ -1,43 +0,0 @@
-import { type Theme, type ThemeCapabilities } from "./tokens.js";
-/**
- * Theme resolution (U.1/U.11) — the ONE place picocolors is used. The axes are
- * fully independent by construction:
- *
- * - `color` drives the stylers only. `pc.createColors(false)` is the identity,
- *   so NO_COLOR yields zero ANSI bytes (dim/bold vanish too) — asserted in the
- *   tests.
- * - the glyph table is chosen by `screenReader` (words) → else `unicode`
- *   (✓/✗) → else ASCII (`[ok]`/`[x]`). Never touches color: a NO_COLOR unicode
- *   terminal still prints ✓/✗ (glyphs aren't ANSI), a colored CRUXY_ASCII
- *   terminal prints a colored `[ok]`, and a screen reader gets colorless words.
- */
-export declare function resolveTheme(caps: ThemeCapabilities): Theme;
-/**
- * Whether the terminal can render unicode glyphs. `TERM=dumb` and an explicit
- * `CRUXY_ASCII` opt-in fall back to the ASCII table; everything else (real
- * terminals AND pipes) keeps unicode — piping ✓/✗ to a file is fine, and this
- * preserves pre-U.1 behavior for non-TTY output.
- *
- * The single source of the rule: `render/capabilities.ts` calls this to fill
- * `RenderCapabilities.unicode`, and the boolean-seam surfaces (errors,
- * approval, plan, onboarding, CLI commands) call it to build a theme without a
- * signature change.
- */
-export declare function detectUnicode(env?: NodeJS.ProcessEnv): boolean;
-/**
- * Whether the user asked for screen-reader mode (U.11) — opt-in via
- * `CRUXY_SCREEN_READER` or the ecosystem `ACCESSIBLE` flag (set-and-non-empty).
- * Deliberately NOT inferred from a pipe: auto-wording every non-TTY stream would
- * change existing CI/plain output. The single source of the rule, called by
- * `render/capabilities.ts` (to fill `RenderCapabilities.screenReader`) and by
- * the boolean-seam {@link themeForColor} surfaces (approval, plan, onboarding).
- */
-export declare function detectScreenReader(env?: NodeJS.ProcessEnv): boolean;
-/**
- * Build a theme for a surface that only knows a `color` boolean (the U.3
- * PromptIO, error formatting, plan/onboarding/CLI copy). Unicode and
- * screen-reader mode are detected from the environment so these surfaces still
- * degrade on dumb terminals and speak words to a screen reader, with no change
- * to their public boolean signatures.
- */
-export declare function themeForColor(color: boolean, env?: NodeJS.ProcessEnv): Theme;

package/dist/theme/tokens.d.ts

@@ -1,125 +0,0 @@
-/**
- * The terminal design system (U.1): one typed {@link Theme} of semantic tokens
- * — color *roles* (never raw hues at call sites), a glyph set with ASCII
- * fallbacks, and structure primitives. Every rendered surface resolves ONE
- * theme (from {@link RenderCapabilities}) and references roles like
- * `theme.danger(x)` / `theme.glyph.success`, so the CLI reads as one product
- * and NO_COLOR / dumb-terminal degradation is handled in exactly one place.
- *
- * Picocolors is imported only by `resolve.ts`; this file is pure types + the
- * two glyph tables.
- */
-/** A text styler: wraps a string in ANSI, or the identity under NO_COLOR. */
-export type Styler = (text: string) => string;
-/**
- * Language-token colors for the streaming syntax highlighter. A distinct
- * sub-palette (not status semantics), centralized here so every color choice
- * lives in the theme.
- */
-export interface ThemeSyntax {
-    keyword: Styler;
-    string: Styler;
-    number: Styler;
-    comment: Styler;
-}
-/**
- * The glyph vocabulary. Concrete strings (resolved to the unicode or ASCII
- * table), so a call site writes `theme.glyph.success`, never a literal "✓".
- */
-export interface ThemeGlyphs {
-    /** Success / done. */
-    success: string;
-    /** Failure / error. */
-    failure: string;
-    /** Not-yet-started (plan step). */
-    pending: string;
-    /** In-progress marker (static, non-animated). */
-    running: string;
-    /** Selected-row pointer in pickers. */
-    pointer: string;
-    /** Input caret (REPL prompt, fuzzy query). */
-    caret: string;
-    /** Next-step / relation arrow. */
-    arrow: string;
-    caretUp: string;
-    caretDown: string;
-    /**
-     * Cache-hit marker for the usage line (`cached ↻N`). Decorative — the word
-     * "cached" carries the meaning, so it degrades to empty on ASCII / screen
-     * reader rather than a cryptic symbol.
-     */
-    cached: string;
-    /** Text-cursor bar in the fuzzy query line. */
-    cursorBar: string;
-    bullet: string;
-    /** Inline separator (the ` · ` joiner uses this). */
-    sep: string;
-    /** Truncation marker. */
-    ellipsis: string;
-    /** Subagent activity marker. */
-    play: string;
-    /** Animated spinner frames (used only where cursor control exists). */
-    spinnerFrames: readonly string[];
-    /** Non-animated spinner glyph (no-cursor terminals). */
-    spinnerStatic: string;
-}
-/**
- * The resolved design system handed to a surface. Color roles are stylers
- * (identity under NO_COLOR); `glyph`/`sep` are concrete strings; the structure
- * helpers give consistent indentation, headings, and key/value alignment.
- */
-export interface Theme {
-    /** Errors, destructive risk, failure. (red) */
-    danger: Styler;
-    /** Reversible-mutation risk, warnings. (yellow) */
-    warning: Styler;
-    /** Done / ok. (green) */
-    success: Styler;
-    /** Brand / interactive / links / pointers. (cyan) */
-    accent: Styler;
-    /** Secondary text: hints, causes, codes, rationale. (dim) */
-    muted: Styler;
-    /** Emphasis / headings — a weight, hue-independent; composes with a color. (bold) */
-    strong: Styler;
-    /** Syntax-highlighting sub-palette. */
-    syntax: ThemeSyntax;
-    /** Glyph vocabulary (unicode or ASCII per capabilities). */
-    glyph: ThemeGlyphs;
-    /** Bold heading (alias of {@link strong}, named for intent). */
-    heading: Styler;
-    /** Prefix every line with `2 * level` spaces. */
-    indent(text: string, level?: number): string;
-    /** Aligned `key  value` with a bold key (optionally padded to `keyWidth`). */
-    kv(key: string, value: string, keyWidth?: number): string;
-    /** The inline joiner, e.g. ` · ` (unicode) / ` - ` (ascii). */
-    sep: string;
-    readonly color: boolean;
-    readonly unicode: boolean;
-}
-/** The axes a theme is resolved from — a structural subset of RenderCapabilities. */
-export interface ThemeCapabilities {
-    color: boolean;
-    unicode: boolean;
-    /**
-     * Screen-reader mode (U.11): status glyphs render as words. Optional so every
-     * existing `{color, unicode}` caller is unchanged (defaults to off). When set
-     * it takes precedence over `unicode` for the glyph table.
-     */
-    screenReader?: boolean;
-}
-/** The unicode glyph table (real terminals). */
-export declare const UNICODE_GLYPHS: ThemeGlyphs;
-/**
- * The ASCII glyph table (TERM=dumb / CRUXY_ASCII). Readable, single-byte, no
- * mojibake — the intentional U.1 degradation for unicode-unsafe terminals.
- */
-export declare const ASCII_GLYPHS: ThemeGlyphs;
-/**
- * The screen-reader glyph table (U.11): the status glyphs a screen reader would
- * otherwise announce as bare punctuation are spelled as words — `done`,
- * `failed`, `working`, `pending` — so `✓ read_file` becomes `done read_file`.
- * Structural glyphs stay ASCII-legible (a pointer/caret has no useful word).
- * This is the entire "worded status" of screen-reader mode: swap the table,
- * reuse every existing renderer/theme code path unchanged.
- */
-export declare const SCREEN_READER_GLYPHS: ThemeGlyphs;

package/dist/tools/create-pull-request.d.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "./types.js";
-/**
- * Open a pull request from the agent's work (C.15): branch → conventional commit
- * → push → open PR, all behind the one U.3 approval. The model authors `title`
- * and `body`; anything omitted is filled deterministically (no second LLM call —
- * the agent IS the LLM). The token is resolved from the environment / `gh`; it is
- * never prompted for or stored.
- */
-declare const parameters: z.ZodObject<{
-    root: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    body: z.ZodOptional<z.ZodString>;
-    base: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    root?: string | undefined;
-    body?: string | undefined;
-    base?: string | undefined;
-    title?: string | undefined;
-}, {
-    root?: string | undefined;
-    body?: string | undefined;
-    base?: string | undefined;
-    title?: string | undefined;
-}>;
-export declare const createPullRequestTool: Tool<typeof parameters>;
-export {};

package/dist/tools/file/apply-patch.d.ts

@@ -1,94 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../types.js";
-declare const parameters: z.ZodObject<{
-    operations: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        type: z.ZodLiteral<"update">;
-        path: z.ZodString;
-        hunks: z.ZodArray<z.ZodObject<{
-            oldStr: z.ZodString;
-            newStr: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            oldStr: string;
-            newStr: string;
-        }, {
-            oldStr: string;
-            newStr: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-        type: "update";
-        hunks: {
-            oldStr: string;
-            newStr: string;
-        }[];
-    }, {
-        path: string;
-        type: "update";
-        hunks: {
-            oldStr: string;
-            newStr: string;
-        }[];
-    }>, z.ZodObject<{
-        type: z.ZodLiteral<"create">;
-        path: z.ZodString;
-        content: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-        type: "create";
-        content: string;
-    }, {
-        path: string;
-        type: "create";
-        content: string;
-    }>, z.ZodObject<{
-        type: z.ZodLiteral<"delete">;
-        path: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-        type: "delete";
-    }, {
-        path: string;
-        type: "delete";
-    }>]>, "many">;
-}, "strip", z.ZodTypeAny, {
-    operations: ({
-        path: string;
-        type: "update";
-        hunks: {
-            oldStr: string;
-            newStr: string;
-        }[];
-    } | {
-        path: string;
-        type: "create";
-        content: string;
-    } | {
-        path: string;
-        type: "delete";
-    })[];
-}, {
-    operations: ({
-        path: string;
-        type: "update";
-        hunks: {
-            oldStr: string;
-            newStr: string;
-        }[];
-    } | {
-        path: string;
-        type: "create";
-        content: string;
-    } | {
-        path: string;
-        type: "delete";
-    })[];
-}>;
-/**
- * Apply a set of file edits across one or more files in a single, atomic,
- * reviewed operation. The entire patch is validated up front — every path
- * resolved inside the project, every `update` hunk confirmed to match exactly
- * once, every `create` confirmed absent and `delete` confirmed present — and if
- * anything fails, nothing is written. A single approval covers the whole patch.
- */
-export declare const applyPatchTool: Tool<typeof parameters>;
-export {};

package/dist/tools/file/edit-file.d.ts

@@ -1,12 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../types.js";
-/**
- * Replace one exact, unique occurrence of `old_str` with `new_str` in a file.
- * The uniqueness requirement is checked before approval so the model can fix an
- * ambiguous match without burning a prompt; gated on `ctx.approve` before writing.
- */
-export declare const editFileTool: Tool<z.ZodObject<{
-    path: z.ZodString;
-    old_str: z.ZodString;
-    new_str: z.ZodString;
-}>>;

package/dist/tools/file/glob.d.ts

@@ -1,17 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../types.js";
-/**
- * Find files by glob pattern within the workspace. Read-only — no approval.
- * The pattern is constrained to a root (no absolute or `..` patterns) so glob
- * can't reach outside, consistent with the other file tools.
- *
- * Multi-repo (C.26, Funnel B): with more than one declared root, glob fans every
- * root — an independent walk rooted at each root's own `absPath` — and labels each
- * match `‹root› ▸ path`. There is no path to confine here; the boundary is which
- * root's `absPath` each walk starts from, so a match can only ever come from the
- * root its label names. A `root` argument scopes the walk to that one root.
- */
-export declare const globTool: Tool<z.ZodObject<{
-    pattern: z.ZodString;
-    root: z.ZodOptional<z.ZodString>;
-}>>;

package/dist/tools/file/grep-files.d.ts

@@ -1,43 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../types.js";
-declare const parameters: z.ZodObject<{
-    pattern: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-    glob: z.ZodOptional<z.ZodString>;
-    ignoreCase: z.ZodOptional<z.ZodBoolean>;
-    maxResults: z.ZodOptional<z.ZodNumber>;
-    root: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    pattern: string;
-    path?: string | undefined;
-    root?: string | undefined;
-    maxResults?: number | undefined;
-    glob?: string | undefined;
-    ignoreCase?: boolean | undefined;
-}, {
-    pattern: string;
-    path?: string | undefined;
-    root?: string | undefined;
-    maxResults?: number | undefined;
-    glob?: string | undefined;
-    ignoreCase?: boolean | undefined;
-}>;
-/**
- * Search file *contents* for a regex within the workspace. Read-only — no
- * approval — so the model should prefer this over shelling out to grep/rg via
- * run_command (which is platform-dependent and routes through the approval gate).
- *
- * Files are enumerated with the same glob mechanism as the `glob` tool (so
- * node_modules, .git, and build-output dirs are always ignored), binary files
- * are skipped, and the
- * search is bounded by the same root boundary as every file tool.
- *
- * Multi-repo (C.26, Funnel B): with more than one declared root and no root-
- * selecting argument, the search FANS every root — a bare relative `path` is
- * applied under each root (⚖︎JC-6) — and labels each match `‹root› ▸ path`. A
- * `root` argument, or an absolute / `‹root›/…`-prefixed `path`, scopes it to that
- * one root. Each walk starts at exactly one confined root directory, so a match
- * can only come from the root its label names.
- */
-export declare const grepFilesTool: Tool<typeof parameters>;
-export {};

package/dist/tools/file/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./paths.js";
-export * from "./read-file.js";
-export * from "./write-file.js";
-export * from "./edit-file.js";
-export * from "./apply-patch.js";
-export * from "./glob.js";
-export * from "./grep-files.js";

package/dist/tools/file/match.d.ts

@@ -1,43 +0,0 @@
-/**
- * Locating `old_str` inside a file for edit_file / apply_patch.
- *
- * Models emit `\n` line endings, but a file on disk may be `\r\n` (Windows
- * checkouts/editors) — a byte-exact `indexOf` then never matches and the model
- * can't replace existing code. We match in ordered tiers, tightest first, and
- * stop at the first tier that finds anything:
- *
- *   0. exact        — raw bytes; every currently-working edit takes this path
- *   1. eol          — CRLF and lone CR treated as LF (comparison only)
- *   2. eol+trailws  — tier 1, plus trailing whitespace ignored per line
- *
- * Looser tiers compare against a normalized copy but return offsets into the
- * ORIGINAL string, so the splice preserves every unmatched byte verbatim (the
- * file is never wholesale re-encoded). Ambiguity is never resolved by guessing:
- * more than one match at a tier is a hard error, and we do not fall through to a
- * looser tier (looser can only be more ambiguous, never less).
- */
-export type Tier = "exact" | "eol" | "eol+trailws";
-export type MatchResult = {
-    kind: "found";
-    start: number;
-    end: number;
-} | {
-    kind: "ambiguous";
-    count: number;
-    tier: Tier;
-} | {
-    kind: "none";
-};
-/**
- * Find the single occurrence of `oldStr` in `content`, tolerating line-ending
- * and trailing-whitespace differences. Returns original-string byte offsets on
- * a unique match, `ambiguous` if the tightest matching tier had >1 hit, or
- * `none` if no tier matched.
- */
-export declare function findMatch(content: string, oldStr: string): MatchResult;
-/** The file's line ending: CRLF if the first newline is `\r\n`, else LF. */
-export declare function detectEol(content: string): "\r\n" | "\n";
-/** Re-encode `text`'s line endings to `eol` so an edit matches the file. */
-export declare function applyEol(text: string, eol: "\r\n" | "\n"): string;
-/** Human phrase for the tier named in an ambiguity error. */
-export declare function tierLabel(tier: Tier): string;