jeopi-cli 16.2.14 → 16.2.15

package/dist/types/cli/gallery-fixtures/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export declare const galleryFixtures: {
+    [x: string]: import("./types").GalleryFixture;
+};

package/dist/types/cli/gallery-fixtures/interaction.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the todo / ask / resolve interaction tools. */
+import type { GalleryFixture } from "./types";
+export declare const interactionFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/memory.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const memoryFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/misc.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the ask / resolve / ssh / github / inspect_image tools. */
+import type { GalleryFixture } from "./types";
+export declare const miscFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/search.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the search tools (grep, search_tool_bm25, ast_grep). */
+import type { GalleryFixture } from "./types";
+export declare const searchFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/shell.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the shell tools (bash, eval). */
+import type { GalleryFixture } from "./types";
+export declare const shellFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Types for `jeopi gallery` sample data. See {@link ./index} for the aggregated
+ * fixture registry and the contract each fixture must satisfy.
+ */
+import type { EditMode } from "../../edit";
+/** A tool result snapshot, matching the shape `ToolExecutionComponent` consumes. */
+export interface GalleryResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+}
+export type GalleryFixtureState = "streaming" | "progress" | "success" | "error";
+export interface GalleryFixture {
+    /** Display label for the tool header (defaults to the tool name). */
+    label?: string;
+    /** Edit mode for edit-like tools so the streaming preview dispatches correctly. */
+    editMode?: EditMode;
+    /**
+     * Custom gallery-only renderer for fixtures that are not one ToolExecutionComponent
+     * (for example the read-group transcript component).
+     */
+    renderState?: (state: GalleryFixtureState, width: number, expanded: boolean) => readonly string[] | Promise<readonly string[]>;
+    /**
+     * Set for tools whose real `AgentTool` attaches `renderCall`/`renderResult`
+     * directly on the instance (e.g. `task`). The harness then attaches
+     * the registry renderer onto the fake tool so the component routes through
+     * the custom-tool branch — the same path production takes — instead of the
+     * built-in registry branch. The two branches can diverge, so exercising the
+     * real one keeps the gallery honest for these tools.
+     */
+    customRendered?: boolean;
+    /**
+     * Renderer-registry key to use when the fixture key is a variant of a tool
+     * (e.g. `irc_wait` → `irc`). Defaults to the fixture key.
+     */
+    renderer?: string;
+    /**
+     * Arguments shown during the streaming state — a partial view of {@link args}
+     * as if the tool-call JSON were still arriving. May include `__partialJson`
+     * for renderers (bash, edit) that surface fields before the object closes.
+     * Defaults to {@link args} when omitted.
+     */
+    streamingArgs?: unknown;
+    /** Complete arguments shown for the in-progress, success, and error states. */
+    args: unknown;
+    /** Successful result. */
+    result: GalleryResult;
+    /** Failed result. Falls back to a generic error when omitted. */
+    errorResult?: GalleryResult;
+}

package/dist/types/cli/gallery-fixtures/web.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const webFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-screenshot.d.ts

@@ -0,0 +1,35 @@
+import type { GallerySection } from "./gallery-cli";
+/** Nerd Font family so the gallery's icon glyphs (PUA) render instead of tofu. */
+export declare const DEFAULT_SCREENSHOT_FONT = "JetBrainsMono Nerd Font";
+export declare const DEFAULT_SCREENSHOT_FONT_SIZE = 18;
+export interface GalleryScreenshotOptions {
+    /** Gallery render width in columns (matches the ANSI line width). */
+    width: number;
+    /** VHS `FontFamily`. */
+    font?: string;
+    /** VHS `FontSize`. */
+    fontSize?: number;
+    /**
+     * Output destination. When omitted, PNGs land in a fresh temp directory.
+     * With multiple images the path is suffixed (`name-01.png`, `name-02.png`).
+     */
+    out?: string;
+}
+/**
+ * Capture the gallery sections as one or more PNGs and return their absolute
+ * paths. Tall galleries are split across images so no single capture exceeds
+ * the terminal-canvas height limit.
+ */
+export declare function captureGalleryScreenshots(sections: GallerySection[], options: GalleryScreenshotOptions): Promise<string[]>;
+/**
+ * Resolve a chunk's PNG path. A single image keeps the bare name (or the exact
+ * `out`); multiple images gain a zero-padded `-NN` suffix so they sort and never
+ * collide.
+ */
+export declare function resolveScreenshotOutputPath(out: string | undefined, baseDir: string, index: number, total: number): string;
+/**
+ * Group whole tool sections into chunks that stay under `rowBudget` rows. A
+ * single section larger than the budget gets its own (taller) image rather than
+ * being split mid-renderer.
+ */
+export declare function chunkGallerySections(sections: GallerySection[], rowBudget: number): GallerySection[][];

package/dist/types/cli/gc-cli.d.ts

@@ -0,0 +1,58 @@
+export interface GcCommandFlags {
+    apply?: boolean;
+    json?: boolean;
+    agentDir?: string;
+    blobs?: boolean;
+    archive?: boolean;
+    wal?: boolean;
+    coldArchiveAfterDays?: number;
+    retainNewestGlobal?: number;
+    retainNewestPerCwd?: number;
+}
+export interface GcCommandArgs {
+    flags: GcCommandFlags;
+}
+export interface BlobGcResult {
+    referenced: number;
+    candidates: number;
+    wouldDelete: number;
+    deleted: number;
+    bytes: number;
+    errors: string[];
+}
+export interface ArchiveGcResult {
+    scanned: number;
+    skippedActive: number;
+    keptNewestGlobal: number;
+    keptNewestPerCwd: number;
+    wouldArchive: number;
+    archived: number;
+    historyRowsDeleted: number;
+    ftsRebuilt: boolean;
+    errors: string[];
+}
+export interface WalCheckpointResult {
+    dbPath: string;
+    walBytes: number;
+    wouldCheckpoint: boolean;
+    checkpointed: boolean;
+    busy: number;
+    log: number;
+    checkpointedFrames: number;
+}
+export interface WalGcResult {
+    databases: WalCheckpointResult[];
+    walBytes: number;
+    wouldCheckpoint: boolean;
+    checkpointed: boolean;
+}
+export interface GcResult {
+    agentDir: string;
+    apply: boolean;
+    blobs?: BlobGcResult;
+    archive?: ArchiveGcResult;
+    wal?: WalGcResult;
+    lockPath: string;
+}
+export declare function collectGcErrors(result: GcResult): string[];
+export declare function runGcCommand(args: GcCommandArgs): Promise<GcResult>;

package/dist/types/cli/grep-cli.d.ts

@@ -0,0 +1,17 @@
+import { GrepOutputMode } from "jeopi-natives";
+export interface GrepCommandArgs {
+    pattern: string;
+    path: string;
+    glob?: string;
+    limit: number;
+    context: number;
+    mode: GrepOutputMode;
+    gitignore: boolean;
+}
+/**
+ * Parse grep subcommand arguments.
+ * Returns undefined if not a grep command.
+ */
+export declare function parseGrepArgs(args: string[]): GrepCommandArgs | undefined;
+export declare function runGrepCommand(cmd: GrepCommandArgs): Promise<void>;
+export declare function printGrepHelp(): void;

package/dist/types/cli/grievances-cli.d.ts

@@ -0,0 +1,37 @@
+export interface ListGrievancesOptions {
+    limit: number;
+    tool?: string;
+    json: boolean;
+}
+export interface CleanGrievancesOptions {
+    /** Delete a single grievance by id. */
+    id?: number;
+    /** Delete every grievance recorded for this tool name. */
+    tool?: string;
+    /** Delete every grievance regardless of tool/id. */
+    all?: boolean;
+    /** Output the deletion count as JSON instead of a status message. */
+    json?: boolean;
+}
+export interface PushGrievancesOptions {
+    /** Emit the {@link FlushResult} as JSON instead of a status line. */
+    json?: boolean;
+}
+export declare function listGrievances(options: ListGrievancesOptions): Promise<void>;
+/**
+ * Delete grievances from the auto-QA database.
+ *
+ * Selectors are mutually exclusive in intent — exactly one of `id`, `tool`, or
+ * `all` is required. Multiple selectors are rejected to prevent ambiguous deletes
+ * (e.g. `--id 5 --all` would be a footgun). Returns silently when the database
+ * does not exist yet.
+ */
+export declare function cleanGrievances(options: CleanGrievancesOptions): Promise<void>;
+/**
+ * Manually drain every unpushed grievance to the configured backend,
+ * ignoring the user-facing consent gate (manual push is the user's
+ * explicit "yes ship these now" intent).
+ *
+ * Requires endpoint configuration (default `qa.jeopi.sh/v1/grievances`).
+ */
+export declare function pushGrievances(options: PushGrievancesOptions): Promise<void>;

package/dist/types/cli/initial-message.d.ts

@@ -0,0 +1,17 @@
+import type { ImageContent } from "jeopi-ai";
+import type { Args } from "./args";
+export interface InitialMessageInput {
+    parsed: Args;
+    fileText?: string;
+    fileImages?: ImageContent[];
+    stdinContent?: string;
+}
+export interface InitialMessageResult {
+    initialMessage?: string;
+    initialImages?: ImageContent[];
+}
+/**
+ * Combine stdin content, @file text, and the first CLI message into a single
+ * initial prompt for non-interactive mode.
+ */
+export declare function buildInitialMessage({ parsed, fileText, fileImages, stdinContent, }: InitialMessageInput): InitialMessageResult;

package/dist/types/cli/models-cli.d.ts

@@ -0,0 +1,62 @@
+/**
+ * `jeopi models` — list, search, and refresh available models.
+ *
+ * Subcommands:
+ * - `ls` (default): list every available model grouped by provider.
+ * - `find <substring>`: list models whose provider, id, or name contains the substring.
+ * - `refresh`: force an online catalog re-fetch (ignoring the model cache TTL),
+ *   then list. This is the supported replacement for `rm -rf ~/.jeopi/models.db`
+ *   when a provider ships a new model that the 24h cache has not picked up yet.
+ *
+ * `ls`/`find` use the cache when fresh (`online-if-uncached`); only `refresh`
+ * forces the network (`online`).
+ */
+import { ModelRegistry } from "../config/model-registry";
+export type ModelsAction = "ls" | "find" | "refresh";
+export interface ModelsCommandArgs {
+    action: ModelsAction;
+    /** Search substring for `find`, or optional filter for `ls`. */
+    pattern?: string;
+    flags: {
+        json?: boolean;
+        /** CLI `-e <path>` extension paths to load before listing (issue #905). */
+        extensions?: string[];
+        /** Skip extension discovery; only load explicit `extensions`. */
+        noExtensions?: boolean;
+        /** Extra `config.yml` overlays to apply for this invocation. */
+        config?: string[];
+    };
+}
+/** Resolve the two positional args into an action + filter (provider names fall through to `ls`). */
+export declare function resolveModelsArgs(first: string | undefined, second: string | undefined): {
+    action: ModelsAction;
+    pattern: string | undefined;
+};
+/**
+ * Options for {@link runModelsListing}: render the catalog from a caller-supplied
+ * registry. Loads extensions (CLI `-e` paths and configured `settings.extensions`)
+ * and discovers their providers before rendering so extension-contributed models
+ * appear (issue #905). The caller is responsible for refreshing built-in providers.
+ */
+export interface RunModelsListingOptions {
+    modelRegistry: ModelRegistry;
+    cwd: string;
+    action?: ModelsAction;
+    pattern?: string;
+    json?: boolean;
+    /** CLI-supplied extension paths (e.g. from `-e <path>`). */
+    additionalExtensionPaths?: string[];
+    /** Extension paths configured under `extensions:` in user settings. */
+    settingsExtensions?: string[];
+    /** Disabled extension ids from settings (`disabledExtensions`). */
+    disabledExtensionIds?: string[];
+    /** When true, skip discovery and only load `additionalExtensionPaths`. */
+    disableExtensionDiscovery?: boolean;
+}
+export declare function runModelsListing(options: RunModelsListingOptions): Promise<void>;
+/**
+ * Entry point for the standalone `jeopi models` command: bootstraps auth storage,
+ * settings, and the model registry, force/cache-refreshes built-in providers per
+ * the chosen action, then delegates to {@link runModelsListing}.
+ */
+export declare function runModelsCommand(command: ModelsCommandArgs): Promise<void>;

package/dist/types/cli/plugin-cli.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plugin CLI command handlers.
+ *
+ * Handles `jeopi plugin <command>` subcommands for plugin lifecycle management.
+ */
+export type PluginAction = "install" | "uninstall" | "list" | "link" | "doctor" | "features" | "config" | "enable" | "disable" | "marketplace" | "discover" | "upgrade";
+export interface PluginCommandArgs {
+    action: PluginAction;
+    args: string[];
+    flags: {
+        json?: boolean;
+        fix?: boolean;
+        force?: boolean;
+        dryRun?: boolean;
+        local?: boolean;
+        enable?: string;
+        disable?: string;
+        set?: string;
+        scope?: "user" | "project";
+    };
+}
+/**
+ * Parse plugin subcommand arguments.
+ * Returns undefined if not a plugin command.
+ */
+export declare function parsePluginArgs(args: string[]): PluginCommandArgs | undefined;
+export { classifyInstallTarget } from "./classify-install-target";
+/**
+ * Run a plugin command.
+ */
+export declare function runPluginCommand(cmd: PluginCommandArgs): Promise<void>;
+export declare function printPluginHelp(): void;

package/dist/types/cli/profile-alias.d.ts

@@ -0,0 +1,29 @@
+export type ProfileAliasShell = "bash" | "zsh" | "fish" | "powershell" | "pwsh";
+export interface ProfileAliasCommand {
+    display: string;
+    posix: string;
+    fish: string;
+    powerShell: string;
+}
+export interface ProfileAliasInstallOptions {
+    profile: string;
+    aliasName: string;
+    shellPath?: string;
+    platform?: NodeJS.Platform;
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+    readFile?: (filePath: string) => Promise<string>;
+    command?: ProfileAliasCommand;
+    writeFile?: (filePath: string, content: string) => Promise<void>;
+}
+export interface ProfileAliasInstallResult {
+    shell: ProfileAliasShell;
+    configPath: string;
+    aliasName: string;
+    profile: string;
+    command: string;
+    reloadedWith: string;
+}
+export declare function resolveProfileAliasCommandFromProcess(argv?: readonly string[], cwd?: string): ProfileAliasCommand;
+export declare function readProfileAliasConfigFile(filePath: string, readText?: (filePath: string) => Promise<string>): Promise<string>;
+export declare function installProfileAlias(options: ProfileAliasInstallOptions): Promise<ProfileAliasInstallResult>;

package/dist/types/cli/profile-bootstrap.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bootstrap-time argv preparser for the global `--profile` / `--alias` flags.
+ *
+ * Profile selection MUST happen before any module reads `getAgentDir()` (notably
+ * `jeopi-utils/env`, which eagerly loads `.env` from the agent directory
+ * during its own import). The full `parseArgs` from `./args.ts` lives downstream
+ * of those imports, so we can't rely on it for profile bootstrap — we have to
+ * crack open argv before the lazy command modules load.
+ *
+ * Because of that, this preparser must respect the same value-consumption
+ * contract as `args.ts`: known string-valued flags usually consume the next
+ * token even when it starts with `-`, except for string flags that can be
+ * shadowed by preloaded boolean extensions (currently `--plan`). Optional-value
+ * flags (`--resume`, `--session`, `-r`) consume the next token only when it
+ * doesn't look like another flag. Without this, `jeopi --system-prompt --profile
+ * foo` silently activates profile `foo`
+ * instead of passing the literal `--profile` to the system prompt and `foo`
+ * as a positional message.
+ *
+ * The shared classification lives in {@link ./flag-tables}, imported below,
+ * so the bootstrap and `args.ts` reference one source of truth instead of
+ * maintaining parallel constants.
+ *
+ * An unclassified bare long option (one not in any flag table) is treated as a
+ * possible extension string flag, but the bootstrap mirrors `parseArgs`'
+ * extension-flag rules ({@link ./args}): a string extension flag consumes its
+ * successor ONLY when that successor is value-like (does not start with `-`), and
+ * a boolean extension flag consumes nothing. So the successor is forwarded
+ * untouched (and never read as a global `--profile`/`--alias`) only when it is
+ * value-like; a flag-looking successor is left for normal processing, so
+ * `jeopi --some-ext-flag --profile work` still selects a profile. Known value-less
+ * launch flags ({@link VALUELESS_FLAGS}) are exempt so a trailing profile after
+ * them also activates (`jeopi --print --profile work`).
+ */
+export interface ProfileBootstrapResult {
+    argv: string[];
+    profile?: string;
+    aliasName?: string;
+}
+/**
+ * Strip `--profile` / `--alias` from argv while preserving the surrounding
+ * argument structure, returning the residual argv to hand to the launch parser
+ * and the captured flag values.
+ *
+ * Global flag extraction stops only when the first residual argv token names a
+ * registered command that owns its own flags (e.g. `grep`): everything from
+ * that token onward is forwarded verbatim so a subcommand's own flags and
+ * positionals are never stolen (`jeopi grep --profile <path>` greps for
+ * `--profile`; it does not select a profile). `launch` and `acp` are explicit
+ * spellings of launch-shaped commands, so `jeopi launch --profile work` and
+ * `jeopi acp --profile work` still select profile `work`.
+ *
+ * Throws when either flag is supplied without a value.
+ */
+export declare function extractProfileFlags(argv: readonly string[]): ProfileBootstrapResult;

package/dist/types/cli/read-cli.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read CLI command handler.
+ *
+ * Handles `jeopi read` — invokes the `read` agent tool against a path/URL and
+ * prints the resulting content blocks exactly as the model would receive them
+ * (including truncation/limit notices appended by the meta-notice wrapper).
+ */
+export interface ReadCommandArgs {
+    path: string;
+}
+export declare function runReadCommand(cmd: ReadCommandArgs): Promise<void>;

package/dist/types/cli/session-picker.d.ts

@@ -0,0 +1,11 @@
+import type { SessionInfo } from "../session/session-listing";
+/**
+ * Show the TUI session selector and return the selected session, or null if
+ * cancelled. Rendered as a fullscreen overlay on the terminal's alternate
+ * screen, so the list scrolls and rows are clickable with the mouse. Tab
+ * toggles between current-folder and all-projects scope; the all-projects list
+ * is loaded lazily via `SessionManager.listAll`.
+ */
+export declare function selectSession(sessions: SessionInfo[], options?: {
+    allSessions?: SessionInfo[];
+}): Promise<SessionInfo | null>;

package/dist/types/cli/setup-cli.d.ts

@@ -0,0 +1,24 @@
+export type SetupComponent = "python" | "speech";
+export interface SetupCommandArgs {
+    component: SetupComponent;
+    flags: {
+        json?: boolean;
+        check?: boolean;
+    };
+}
+/**
+ * Parse setup subcommand arguments.
+ * Returns undefined if not a setup command.
+ */
+export declare function parseSetupArgs(args: string[]): SetupCommandArgs | undefined;
+/**
+ * Install Python packages using uv (preferred) or pip.
+ */
+/**
+ * Run the setup command.
+ */
+export declare function runSetupCommand(cmd: SetupCommandArgs): Promise<void>;
+/**
+ * Print setup command help.
+ */
+export declare function printSetupHelp(): void;

package/dist/types/cli/setup-model-picker.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Standalone TUI model picker used by `jeopi setup speech`.
+ *
+ * Mirrors {@link ./session-picker.ts} for the standalone-TUI lifecycle: spin up
+ * a one-shot {@link TUI} over a {@link SelectList}, resolve on select/cancel, and
+ * tear the UI down. The standalone TUI auto-renders on input, so no manual
+ * render wiring is needed beyond `addChild`/`setFocus`/`start`.
+ */
+import { type SelectItem } from "jeopi-tui";
+/**
+ * Show a single-column model picker and resolve with the chosen item's value,
+ * or `null` if the user cancelled. `currentValue` pre-selects the matching row.
+ */
+export declare function selectSetupModel(title: string, items: SelectItem[], currentValue: string): Promise<string | null>;

package/dist/types/cli/shell-cli.d.ts

@@ -0,0 +1,8 @@
+export interface ShellCommandArgs {
+    cwd?: string;
+    timeoutMs?: number;
+    noSnapshot?: boolean;
+}
+export declare function parseShellArgs(args: string[]): ShellCommandArgs | undefined;
+export declare function runShellCommand(cmd: ShellCommandArgs): Promise<void>;
+export declare function printShellHelp(): void;

package/dist/types/cli/ssh-cli.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SSH CLI command handlers.
+ *
+ * Handles `jeopi ssh <command>` subcommands for SSH host configuration management.
+ */
+export type SSHAction = "add" | "remove" | "list";
+export interface SSHCommandArgs {
+    action: SSHAction;
+    args: string[];
+    flags: {
+        json?: boolean;
+        host?: string;
+        user?: string;
+        port?: string;
+        key?: string;
+        desc?: string;
+        compat?: boolean;
+        scope?: "project" | "user";
+    };
+}
+export declare function runSSHCommand(cmd: SSHCommandArgs): Promise<void>;

package/dist/types/cli/startup-cwd.d.ts

@@ -0,0 +1,2 @@
+import type { Args } from "./args";
+export declare function applyStartupCwd(parsed: Args): Promise<void>;

package/dist/types/cli/stats-cli.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stats CLI command handlers.
+ *
+ * Handles `jeopi stats` subcommand for viewing AI usage statistics.
+ */
+export interface StatsCommandArgs {
+    port: number;
+    json: boolean;
+    summary: boolean;
+}
+/**
+ * Parse stats subcommand arguments.
+ * Returns undefined if not a stats command.
+ */
+export declare function parseStatsArgs(args: string[]): StatsCommandArgs | undefined;
+export declare function runStatsCommand(cmd: StatsCommandArgs): Promise<void>;
+export declare function printStatsHelp(): void;

package/dist/types/cli/tiny-models-cli.d.ts

@@ -0,0 +1,11 @@
+import { type TinyLocalModelKey } from "../tiny/models";
+export type TinyModelsAction = "download" | "list";
+export interface TinyModelsCommandArgs {
+    action: TinyModelsAction;
+    model?: string;
+    flags: {
+        json?: boolean;
+    };
+}
+export declare function resolveModels(model: string | undefined): TinyLocalModelKey[];
+export declare function runTinyModelsCommand(command: TinyModelsCommandArgs): Promise<void>;

package/dist/types/cli/ttsr-cli.d.ts

@@ -0,0 +1,39 @@
+export type TtsrAction = "test" | "list" | "scan";
+export declare const TTSR_ACTIONS: TtsrAction[];
+export declare const TTSR_SOURCES: TtsrMatchSource[];
+export type TtsrMatchSource = "text" | "thinking" | "tool";
+export interface TtsrTestArgs {
+    /** Inline snippet text. */
+    snippet?: string;
+    /** Snippet file path, or `-` for stdin. */
+    file?: string;
+    /** Path to a rule markdown file to test in isolation (skips project loading). */
+    rule?: string;
+    /** TTSR match source; when omitted, inferred from --file (tool for source files, text otherwise). */
+    source?: TtsrMatchSource;
+    /** Tool name when `source === "tool"` (e.g. "edit", "write"). */
+    tool?: string;
+    /** Candidate file path used for scope/glob matching and AST language inference. */
+    filePath?: string;
+    /** Show every evaluated rule, not just triggered ones. */
+    verbose?: boolean;
+}
+export interface TtsrScanArgs {
+    /** Directory to glob and scan files in. */
+    directory?: string;
+    /** Path to a rule markdown file to test in isolation (skips project loading). */
+    rule?: string;
+    /** Respect gitignore files while discovering scan candidates. Defaults to true. */
+    gitignore?: boolean;
+    /** Maximum file size to scan in bytes; 0 disables the limit. */
+    maxBytes?: number;
+    /** Show details. */
+    verbose?: boolean;
+}
+export interface TtsrCommandArgs {
+    action: TtsrAction;
+    test?: TtsrTestArgs;
+    scan?: TtsrScanArgs;
+    json?: boolean;
+}
+export declare function runTtsrCommand(cmd: TtsrCommandArgs): Promise<void>;