@visulima/vis 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/staged/tasks/exec.d.ts

@@ -1,56 +0,0 @@
-/**
- * Minimal quote-aware argv splitter. Handles single and double quotes,
- * backslash escapes (both outside and inside double quotes, matching
- * POSIX shell semantics), and collapses runs of whitespace — enough for
- * the shell-like syntax users put in their staged config without
- * dragging in `string-argv`.
- *
- * Inside single quotes everything is literal (POSIX semantics). Inside
- * double quotes, `\"` and `\\` are interpreted; other backslash
- * sequences are preserved verbatim.
- *
- * Throws `ConfigError` on unterminated quotes so typos in config fail
- * fast instead of silently swallowing the rest of the command.
- */
-export declare const parseCommandString: (input: string) => string[];
-/**
- * Platform-aware default for the maximum per-invocation argv byte length.
- *
- * Linux `execve()` caps `ARG_MAX` at ~128 KiB on most kernels; macOS sits at
- * 256 KiB. Windows `CreateProcess` caps the full command line at 32,767
- * UTF-16 code units (~65 KiB in the worst ASCII case, tighter for non-ASCII),
- * so we pick a conservative 28 KiB limit there to leave headroom for the
- * argv prefix and environment overhead that Node splices in.
- */
-declare const DEFAULT_MAX_ARG_LENGTH: number;
-/**
- * Splits `files` into chunks whose combined byte length (plus a shared
- * fixed-prefix length) does not exceed `maxArgLength`. Guarantees at
- * least one file per chunk so extremely long individual paths still
- * make it through.
- */
-export declare const chunkFiles: (files: ReadonlyArray<string>, fixedPrefixLength: number, maxArgLength: number) => string[][];
-export interface ExecCommandOptions {
-    readonly cwd: string;
-    readonly env?: Record<string, string>;
-    /**
-     * Signal delivered to the child process when `signal` fires. Defaults to `SIGTERM`
-     * (graceful). Use `SIGKILL` for fast-fail runs where graceful shutdown is not
-     * worth the wait.
-     */
-    readonly killSignal?: NodeJS.Signals;
-    readonly maxArgLength?: number;
-    /** Aborted when the caller cancels the run (e.g. another task failed without `continueOnError`). */
-    readonly signal?: AbortSignal;
-}
-export interface ExecCommandResult {
-    readonly durationMs: number;
-    readonly output: string;
-}
-/**
- * Runs a command once per file-chunk, concatenating stdout/stderr for
- * renderer consumption. Throws `TaskError` on the first failing chunk
- * or when the caller's `AbortSignal` fires mid-invocation.
- */
-export declare const execCommand: (command: string, files: ReadonlyArray<string>, options: ExecCommandOptions) => Promise<ExecCommandResult>;
-export { DEFAULT_MAX_ARG_LENGTH };

package/dist/staged/tasks/run.d.ts

@@ -1,26 +0,0 @@
-import type { PatternDescriptor, Renderer } from "../types.d.ts";
-export interface RunTasksOptions {
-    readonly concurrent: boolean | number;
-    readonly continueOnError: boolean;
-    readonly cwd: string;
-    /** External cancellation (e.g. SIGINT handler). When fired, cancels like a task failure. */
-    readonly externalSignal?: AbortSignal;
-    /** Signal delivered to in-flight child processes when the run cancels. Defaults to `SIGTERM`. */
-    readonly killSignal?: NodeJS.Signals;
-    readonly maxArgLength?: number;
-    readonly verbose?: boolean;
-}
-export interface RunTasksResult {
-    readonly failedCommands: string[];
-    readonly success: boolean;
-}
-/**
- * Runs pattern tasks with pattern-level concurrency and command-level
- * serial execution. Emits lifecycle events through the renderer.
- *
- * When a command fails and `continueOnError` is off, the shared
- * `AbortController` is aborted so any execa children currently running
- * in other workers exit promptly rather than running to completion on
- * a doomed run.
- */
-export declare const runTasks: (patterns: ReadonlyArray<PatternDescriptor>, renderer: Renderer, options: RunTasksOptions) => Promise<RunTasksResult>;

package/dist/staged/types.d.ts

@@ -1,173 +0,0 @@
-/**
- * Public types for the in-house staged-files workflow that replaces
- * the `lint-staged` peer dependency. The surface mirrors lint-staged's
- * so existing configs and the `vis staged` command contract survive.
- */
-/** Status of a single task or pattern in the runner lifecycle. */
-export type TaskStatus = "failed" | "pending" | "running" | "skipped" | "success";
-/**
- * Custom task form — `{ title, task }` — analogous to lint-staged's
- * listr-style task objects. `task` receives the matched absolute paths
- * and returns a promise that resolves on success or rejects on failure.
- */
-export interface CustomTask {
-    readonly task: (files: string[]) => Promise<unknown> | unknown;
-    readonly title: string;
-}
-/**
- * A task value as authored by the user. Command strings are split into
- * argv and invoked with the matched file paths appended. Arrays run
- * serially. Functions receive the matched paths and return further
- * task values (possibly async). `{ title, task }` objects run `task`
- * directly with no argv construction.
- */
-export type StagedTask = CustomTask | StagedTaskFunction | ReadonlyArray<CustomTask | StagedTaskFunction | string> | string | ReadonlyArray<string>;
-export type StagedTaskFunction = (files: string[]) => Promise<StagedTaskResult> | StagedTaskResult;
-export type StagedTaskResult = CustomTask | ReadonlyArray<CustomTask | string> | string | ReadonlyArray<string>;
-/**
- * Config object mapping glob patterns (basename or path-style) to tasks.
- * A top-level function form lets the user generate the entire config
- * from the staged file list.
- */
-export type StagedConfig = Readonly<Record<string, StagedTask>> | StagedConfigFunction;
-export type StagedConfigFunction = (files: string[]) => Promise<Record<string, StagedTask>> | Record<string, StagedTask>;
-/** Options accepted by `runStaged`. Mirrors the lint-staged CLI surface. */
-export interface RunOptions {
-    /** Allow empty commits when tasks revert every staged change. */
-    readonly allowEmpty?: boolean;
-    /**
-     * When a task writes *new* files that sit outside the originally-staged
-     * set, automatically stage them too. Defaults to `false` — only tasks
-     * explicitly called out to produce new artefacts should set this (e.g.
-     * codegen, lockfile regeneration). Closes nano-staged #43.
-     */
-    readonly autoStage?: boolean;
-    /** Concurrency: `true` (unbounded), `false` (serial), or a positive integer. */
-    readonly concurrent?: boolean | number;
-    /** Inline staged config — the single source of truth at runtime. Supplied by `vis staged` from `vis.config.ts`. */
-    readonly config?: StagedConfig;
-    /** Run all tasks to completion even if one fails. */
-    readonly continueOnError?: boolean;
-    /** Working directory used for git and task execution. */
-    readonly cwd?: string;
-    /** Enable debug logging and force the plain renderer. */
-    readonly debug?: boolean;
-    /** Override the default `--staged` diff scope with an arbitrary git range. Implies `--no-stash`. */
-    readonly diff?: string;
-    /** Override the default `--diff-filter=ACMR`. */
-    readonly diffFilter?: string;
-    /** Exit with a non-zero status if tasks modified tracked files. Implies `--no-revert`. */
-    readonly failOnChanges?: boolean;
-    /**
-     * Hide every unstaged change *and* every untracked file before running
-     * tasks. Useful for tools like Knip that inspect the whole worktree.
-     * Backed by a `git stash --include-untracked` so restore is automatic.
-     */
-    readonly hideAll?: boolean;
-    /** Hide unstaged edits on partially-staged files (default: `true`). Set `false` to disable. */
-    readonly hidePartiallyStaged?: boolean;
-    /** Hide unstaged changes on every tracked file, not only partially-staged ones. */
-    readonly hideUnstaged?: boolean;
-    /**
-     * Glob patterns for files to exclude from every task. Applied to the
-     * staged file list before pattern matching, so an `ignore` hit drops
-     * a file from *all* tasks regardless of which globs would otherwise
-     * have picked it up. Closes lint-staged issue #1722.
-     */
-    readonly ignore?: ReadonlyArray<string>;
-    /**
-     * Signal used to kill in-flight task subprocesses when the run is
-     * cancelled (another task failed without `continueOnError`, or the
-     * user hit Ctrl+C). Defaults to `SIGTERM`, which lets well-behaved
-     * tools flush before exiting. Use `SIGKILL` for fast-fail runs
-     * where graceful shutdown is not worth the wait.
-     * @default "SIGTERM"
-     */
-    readonly killSignal?: NodeJS.Signals;
-    /** Cap on combined argv byte length per command invocation. Defaults to a conservative OS limit. */
-    readonly maxArgLength?: number;
-    /** Suppress progress output entirely. */
-    readonly quiet?: boolean;
-    /** Pass matched paths to tasks relative to `cwd` instead of absolute. */
-    readonly relative?: boolean;
-    /** Revert the working tree from the backup stash when a task fails. */
-    readonly revert?: boolean;
-    /** Take a backup stash before running tasks (default: `true`). Set `false` to disable. */
-    readonly stash?: boolean;
-    /** Show task stdout/stderr on success, not only on failure. */
-    readonly verbose?: boolean;
-}
-/** A runtime descriptor for a single command belonging to a pattern. */
-export interface CommandDescriptor {
-    /** Resolved command template; absent for custom tasks. */
-    readonly command?: string;
-    /** Matched files (absolute or relative, per `relative` option). */
-    readonly files: ReadonlyArray<string>;
-    /** A stable id for renderer lookups. */
-    readonly id: string;
-    /** Custom task callback; only set when `source === "custom"`. */
-    readonly run?: (files: string[]) => Promise<unknown> | unknown;
-    readonly source: "custom" | "function" | "string";
-    readonly title: string;
-}
-/** A runtime descriptor for a glob pattern and its resolved commands. */
-export interface PatternDescriptor {
-    readonly commands: ReadonlyArray<CommandDescriptor>;
-    readonly files: ReadonlyArray<string>;
-    readonly id: string;
-    readonly pattern: string;
-    readonly title: string;
-}
-/** Events emitted by the runner and consumed by a renderer. */
-export interface RunnerEvents {
-    commandEnd: {
-        readonly commandId: string;
-        readonly durationMs: number;
-        readonly error?: Error;
-        readonly output?: string;
-        readonly patternId: string;
-        readonly status: TaskStatus;
-    };
-    commandStart: {
-        readonly commandId: string;
-        readonly patternId: string;
-    };
-    error: {
-        readonly error?: Error;
-        readonly message: string;
-    };
-    info: {
-        readonly message: string;
-    };
-    patternEnd: {
-        readonly patternId: string;
-        readonly status: TaskStatus;
-    };
-    patternStart: {
-        readonly patternId: string;
-    };
-    start: {
-        readonly patterns: ReadonlyArray<PatternDescriptor>;
-    };
-    warn: {
-        readonly message: string;
-    };
-}
-/** Abstract renderer contract — plain and Ink implementations conform. */
-export interface Renderer {
-    commandEnd: (payload: RunnerEvents["commandEnd"]) => void;
-    commandStart: (payload: RunnerEvents["commandStart"]) => void;
-    error: (payload: RunnerEvents["error"]) => void;
-    info: (payload: RunnerEvents["info"]) => void;
-    patternEnd: (payload: RunnerEvents["patternEnd"]) => void;
-    patternStart: (payload: RunnerEvents["patternStart"]) => void;
-    start: (payload: RunnerEvents["start"]) => void;
-    stop: () => Promise<void> | void;
-    warn: (payload: RunnerEvents["warn"]) => void;
-}
-/** Outcome of a `runStaged` invocation. */
-export interface RunResult {
-    readonly failedCommands: ReadonlyArray<string>;
-    readonly ranTasks: boolean;
-    readonly success: boolean;
-}

package/dist/target-discovery.d.ts

@@ -1,59 +0,0 @@
-import type { WorkspaceConfiguration } from "@visulima/task-runner";
-import type { ProjectOptionsIndex } from "./workspace.d.ts";
-/**
- * Collects every unique target name across all projects in the workspace.
- * @param workspace The discovered workspace configuration.
- * @returns Sorted array of unique target names.
- */
-export declare const collectAvailableTargets: (workspace: WorkspaceConfiguration) => string[];
-/**
- * Builds a `{alias → canonicalTargetName}` lookup from declared
- * `aliases` on any `VisTargetConfiguration` in the workspace. Aliases
- * are treated as workspace-global — the first declaration wins and
- * later ones are silently ignored (prefer explicit canonical names
- * when aliases collide).
- *
- * Canonical target names themselves are not added to the map — only
- * declared aliases — so `resolveTargetAlias` leaves non-alias input
- * unchanged.
- */
-export declare const buildAliasMap: (projectOptions: ProjectOptionsIndex) => Map<string, string>;
-/**
- * Resolves a user-typed target name to its canonical form, or returns
- * the input unchanged when no alias matches.
- */
-export declare const resolveTargetAlias: (name: string, aliases: Map<string, string>) => string;
-/**
- * Suggests the closest matching target name for a typo.
- * @param input The unknown target name the user typed.
- * @param available Known target names.
- * @param maxDistance Maximum edit distance to consider (default 3).
- * @returns The best match, or `undefined` if nothing is close enough.
- */
-export declare const suggestTarget: (input: string, available: string[], maxDistance?: number) => string | undefined;
-/**
- * Returns up to `limit` closest-matching target names within
- * `maxDistance` edit distance, sorted by ascending distance.
- *
- * Used by the missing-target error output to offer several candidates
- * — one suggestion often reads as authoritative, three reads as
- * "pick whichever you meant", which is friendlier at scale.
- */
-export declare const suggestTargets: (input: string, available: string[], limit?: number, maxDistance?: number) => string[];
-/**
- * Formats the available targets list for display.
- * @param targets Sorted target names.
- * @returns Formatted string for CLI output.
- */
-export declare const formatTargetList: (targets: string[]) => string;
-/**
- * Prompts the user to pick a target from `targets` via an interactive
- * numbered readline prompt. Accepts either the index (1-based) or the
- * target name; empty input or Ctrl-C aborts with `undefined`.
- *
- * Uses Node's built-in readline rather than a TUI dependency — this
- * keeps the bare `vis run` flow lightweight and works in any TTY.
- * Mirrors vite-task's `vp run` (no args) interactive selector.
- * @returns The chosen target name, or `undefined` if the user aborts.
- */
-export declare const promptTargetInteractively: (targets: string[]) => Promise<string | undefined>;

package/dist/target-options.d.ts

@@ -1,261 +0,0 @@
-import type { TargetConfiguration } from "@visulima/task-runner";
-/**
- * Semantic classification for a target.
- * - `build`: Generates one or more artifacts; cached by default.
- * - `test`: Validation task (lint, typecheck, unit test). Default type.
- * - `run`: One-off or long-running process. Not cached by default.
- */
-export type TargetType = "build" | "run" | "test";
-/**
- * Preset bundles of target options.
- * - `server`: Long-running local dev server — caching off, not in CI,
- *   interactive, persistent.
- * - `utility`: Short-lived helper — caching off, not in CI.
- */
-export type TargetPreset = "server" | "utility";
-/**
- * Controls whether a target runs in CI.
- * - `true` (default): Always run.
- * - `false`: Never run in CI (local-only).
- * - `"affected"`: Only when the project is affected by the current change set.
- * - `"always"`: Always run, even if unaffected.
- */
-export type RunInCI = "affected" | "always" | boolean;
-/**
- * Controls how affected files are forwarded to a task.
- * - `false` (default): Do not forward.
- * - `"args"`: Append affected paths as additional command arguments.
- * - `"env"`: Expose them via `VIS_AFFECTED_FILES` environment variable.
- * - `"both"`: Both of the above.
- */
-export type AffectedFilesMode = "args" | "both" | "env" | false;
-/** Supported OS filters for target execution. */
-export type TargetOsType = "linux" | "macos" | "windows";
-/**
- * Vis-specific target options that extend the task-runner's
- * base `TargetConfiguration`. These live under `target.options` and are
- * interpreted by vis before handing the task off to task-runner.
- */
-/**
- * Object form of the `when` gate. Matches against process.env or
- * process.platform — deliberately small surface area so conditions
- * stay auditable and declarative.
- */
-export interface TargetConditionObject {
-    /** Env var name to compare against `equals` or `in`. */
-    env?: string;
-    /** Value that `env` must match exactly. */
-    equals?: string;
-    /** Any value in this list matches. Ignored when `equals` is set. */
-    in?: string[];
-    /** Run only on this platform (or one of these). */
-    platform?: NodeJS.Platform | NodeJS.Platform[];
-}
-/**
- * Evaluates a `when` condition against the current process state.
- * Returns `true` when the task should run, `false` when it should be
- * skipped. Unknown shapes default to `true` — we'd rather over-run
- * than silently hide tasks on malformed config.
- */
-export declare const evaluateWhen: (when: TargetConditionObject | string | undefined, environment?: Record<string, string | undefined>, platform?: NodeJS.Platform) => boolean;
-export interface VisTargetOptions {
-    /**
-     * How to forward affected files to the task process.
-     * Only used when invoked via `vis affected &lt;target>`.
-     * @default false
-     */
-    affectedFiles?: AffectedFilesMode;
-    /**
-     * Load environment variables from dotenv file(s) before running.
-     * - `string`: a single file path (relative to project root).
-     * - `string[]`: multiple files — later entries override earlier ones,
-     *   so put more-specific files last (e.g. `[".env", ".env.local"]`).
-     * - `true`: auto-cascade in the Next/Vite order:
-     *   `.env` → `.env.{NODE_ENV}` → `.env.local` → `.env.{NODE_ENV}.local`.
-     *   Skips `.env.local` when NODE_ENV is `test`, matching Next.js.
-     */
-    envFile?: boolean | string | string[];
-    /**
-     * When true, the task is serialized with respect to parallel execution
-     * and must be run on the main process (claims stdin). Used for commands
-     * that read from the terminal.
-     * @default false
-     */
-    interactive?: boolean;
-    /**
-     * When true, the task is hidden from CLI listings and can only be invoked
-     * as a dependency of another task.
-     * @default false
-     */
-    internal?: boolean;
-    /**
-     * Serializes all tasks that share the same mutex name. Useful for tasks
-     * that contend on a shared resource (e.g., a database migration).
-     */
-    mutex?: string;
-    /**
-     * Restricts execution to specific operating systems. Tasks run on
-     * unmatched platforms are skipped with a warning.
-     */
-    osType?: TargetOsType | TargetOsType[];
-    /**
-     * When true, the task is a long-running / never-ending process.
-     * Persistent tasks are scheduled last, execute after all cacheable
-     * tasks complete, and are never cached.
-     * @default false
-     */
-    persistent?: boolean;
-    /**
-     * A preset that pre-fills a common bundle of options.
-     * User-provided fields always take precedence over the preset.
-     */
-    preset?: TargetPreset;
-    /**
-     * Run the task through a pseudo-terminal so color-aware tools
-     * (vitest, eslint, biome, …) render as if attached to a real TTY
-     * instead of a pipe. Output is captured via task-runner's
-     * `TerminalBuffer` so ANSI escapes are normalized into the final
-     * rendered state before reaching the reporter.
-     *
-     * Forces cache to off — PTY output can include timing-dependent
-     * frames (spinners) that aren't safe to replay from a cache.
-     * @default false
-     */
-    pty?: boolean;
-    /**
-     * Number of times to retry the task on failure. Uses an exponential
-     * backoff by default (1s, 2s, 4s, ...).
-     * @default 0
-     */
-    retryCount?: number;
-    /**
-     * Delay between retry attempts in milliseconds, or `"exponential"`
-     * for 2^attempt * 1000 ms.
-     * @default "exponential"
-     */
-    retryDelay?: number | "exponential";
-    /**
-     * When true, the command executes with the workspace root as CWD
-     * instead of the project root.
-     * @default false
-     */
-    runFromWorkspaceRoot?: boolean;
-    /**
-     * Controls whether the task runs in CI environments.
-     * @default true
-     */
-    runInCI?: RunInCI;
-    /**
-     * Per-target shell override. When set, the command runs through this
-     * shell instead of the platform default.
-     */
-    shell?: string;
-    /**
-     * Maximum wall-clock milliseconds a single task run is allowed to
-     * take before being killed. `0` / `undefined` means no timeout.
-     *
-     * When the timeout fires the task is sent SIGTERM then SIGKILL
-     * (via the concurrent runner's `killSignal`/`killTimeout`
-     * semantics) and the task exits with a failure status carrying the
-     * `[timeout]` marker in `terminalOutput`. Retries count against
-     * this per-attempt, not cumulatively.
-     *
-     * Use this to prevent runaway tasks from eating CI wall-clock time
-     * up to the job-level cutoff.
-     */
-    timeout?: number;
-    /**
-     * Per-target unix shell override, used on Linux and macOS.
-     * Takes precedence over `shell` on unix-like systems.
-     */
-    unixShell?: string;
-    /**
-     * Conditional gate: the task is scheduled only when `when` evaluates
-     * truthy. Shapes:
-     * - `"$VAR"` — run only if the env var is non-empty
-     * - `"!VAR"` — run only if the env var is empty/unset
-     * - `{ env: "NAME", equals: "value" }` — run only if env equals
-     * - `{ env: "NAME", in: ["a", "b"] }` — run only if env is in set
-     * - `{ platform: "darwin" | "linux" | "win32" }` — OS gate
-     *
-     * Kept declarative on purpose — no dynamic code execution. For
-     * richer logic, use osType/runInCI or a pre-hook script.
-     */
-    when?: TargetConditionObject | string;
-    /**
-     * Per-target windows shell override, used on Windows.
-     * Takes precedence over `shell` on Windows.
-     */
-    windowsShell?: string;
-}
-/**
- * An extended target configuration that adds the vis-specific options
- * on top of task-runner's `TargetConfiguration`.
- */
-export interface VisTargetConfiguration extends Omit<TargetConfiguration, "options"> {
-    /**
-     * Alternate names that resolve to this target on the CLI. Useful
-     * for shortening long canonical names (`test` ↔ `t`) or for
-     * offering migration-friendly aliases when renaming targets.
-     * Aliases must be globally unique within the workspace.
-     */
-    aliases?: string[];
-    /**
-     * One-line description surfaced by `vis list` and (in future)
-     * per-task `--help`. Kept short — longer docs belong in project
-     * READMEs or vis.config.ts comments.
-     */
-    description?: string;
-    /** Vis-specific target options. */
-    options?: VisTargetOptions;
-    /** Preset applied before user-specified options. */
-    preset?: TargetPreset;
-    /**
-     * Semantic task type. Affects caching defaults and CI filtering.
-     * @default "test"
-     */
-    type?: TargetType;
-}
-/**
- * Apply preset defaults to a target configuration. Returns a new
- * object — never mutates its input.
- */
-export declare const applyPreset: (target: VisTargetConfiguration) => VisTargetConfiguration;
-/** Detects the current operating system as a {@link TargetOsType}. */
-export declare const detectCurrentOs: () => TargetOsType;
-/**
- * Returns `true` if the given OS matches the target's `osType` filter.
- * Tasks without an `osType` option always match.
- */
-export declare const matchesOs: (options: VisTargetOptions | undefined, currentOs?: TargetOsType) => boolean;
-/**
- * Returns `true` if the task should run in the current environment based
- * on its `runInCI` option. `affectedInCi` should indicate whether the
- * project is in the current affected set (only relevant for `"affected"`).
- */
-export declare const shouldRunInCI: (options: VisTargetOptions | undefined, isCi: boolean, affectedInCi?: boolean) => boolean;
-/**
- * Resolves the `envFile` target option into a merged env map.
- *
- * - `string` → load that single file
- * - `string[]` → load each in order; later entries win on key collision
- * - `true` → load the Next/Vite cascade:
- *   `.env` → `.env.{NODE_ENV}` → `.env.local` → `.env.{NODE_ENV}.local`
- *   (`.env.local` skipped for NODE_ENV=test, matching Next.js)
- *
- * Silently skips files that don't exist. Returns `{}` when no file in
- * the cascade is present — safe to merge directly into the child env.
- */
-export declare const loadEnvFile: (projectRoot: string, envFile: boolean | string | string[]) => Record<string, string>;
-/**
- * Pick the effective shell for a target on the current platform.
- * Returns `undefined` if no per-target shell is configured.
- */
-export declare const resolveTargetShell: (options: VisTargetOptions | undefined, currentOs?: TargetOsType) => string | undefined;
-/**
- * Returns the default `cache` value implied by the target type.
- * - `build`: cached by default.
- * - `run`: never cached.
- * - `test`: cached by default.
- */
-export declare const defaultCacheForType: (type: TargetType | undefined) => boolean | undefined;

package/dist/tips.d.ts

@@ -1,41 +0,0 @@
-/**
- * CLI tips system - displays contextual hints after command execution.
- *
- * Features (per vite-plus RFC):
- * - Probabilistic frequency control with per-tip cooldowns
- * - Contextual matching based on command, args, and success state
- * - Rate-limited globally (max 1 tip per 5 minutes)
- * - Per-tip cooldown tracking (each tip has its own cooldown)
- * - Suppressed in CI/test environments
- * - Dimmed styling to avoid being intrusive
- */
-interface TipContext {
-    args: string[];
-    command: string;
-    hasVisConfig?: boolean;
-    success: boolean;
-}
-interface Tip {
-    /** Per-tip cooldown in milliseconds. Default: GLOBAL_COOLDOWN_MS */
-    cooldownMs?: number;
-    /** Unique identifier for per-tip cooldown tracking */
-    id: string;
-    matches: (context: TipContext) => boolean;
-    message: (context: TipContext) => string;
-    /** Probability of showing when matched (0.0 - 1.0). Default: 1.0 */
-    probability?: number;
-}
-declare const tips: Tip[];
-/**
- * Show a contextual tip if rate-limits allow and a tip matches.
- *
- * Flow:
- * 1. Check environment (skip in CI/test)
- * 2. Check global cooldown (max 1 tip per 5 minutes)
- * 3. Find matching tips, filter by per-tip cooldowns
- * 4. Apply probability filter
- * 5. Show the first surviving tip, update state
- */
-declare const showTip: (context: TipContext) => void;
-export type { Tip, TipContext };
-export { showTip, tips };

package/dist/tui/components/CheckProgressApp.d.ts

@@ -1,6 +0,0 @@
-import React from "react";
-export interface CheckProgressProps {
-    readonly current: number;
-    readonly total: number;
-}
-export default function CheckProgressApp({ current, total }: CheckProgressProps): React.ReactElement;

package/dist/tui/components/CommandSummary.d.ts

@@ -1,17 +0,0 @@
-import type { Task } from "@visulima/task-runner";
-interface CommandSummaryProps {
-    cached: number;
-    failed: number;
-    failedIds: string[];
-    projectNames: string[];
-    skippedIds?: string[];
-    succeeded: number;
-    targets: string[];
-    tasks: Task[];
-    took: string;
-}
-/**
- * Final summary block rendered after all tasks complete.
- */
-declare const CommandSummary: ({ cached, failed, failedIds, projectNames, skippedIds, succeeded, targets, tasks, took }: CommandSummaryProps) => React.JSX.Element;
-export default CommandSummary;

package/dist/tui/components/Header.d.ts

@@ -1,13 +0,0 @@
-import type { ReactNode } from "react";
-interface HeaderProps {
-    children?: ReactNode;
-    title: string;
-    variant: "error" | "info" | "success";
-}
-/**
- * Renders the VIS badge + status dot + title header line.
- *
- *   ` VIS `  ●  Running targets build for 3 projects
- */
-declare const Header: ({ children, title, variant }: HeaderProps) => React.JSX.Element;
-export default Header;

package/dist/tui/components/OutputPanel.d.ts

@@ -1,17 +0,0 @@
-import type { ScrollViewRef } from "@visulima/tui";
-import type { TaskRowData } from "./TaskRow.d.ts";
-interface OutputPanelProps {
-    /** Duration in ms (for top-right border display). */
-    duration?: number;
-    focused: boolean;
-    /** Whether interactive input mode is active (keystrokes forwarded to PTY). */
-    interactiveMode?: boolean;
-    output: string;
-    scrollRef?: React.RefObject<ScrollViewRef | null>;
-    /** Whether to show "&lt;enter> full screen" hint in bottom border. */
-    showFullscreenHint?: boolean;
-    status: TaskRowData["status"] | undefined;
-    taskId: string | null;
-}
-declare const OutputPanel: ({ duration, focused, interactiveMode, output, scrollRef, showFullscreenHint, status, taskId }: OutputPanelProps) => React.JSX.Element;
-export default OutputPanel;