@visulima/vis 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/native-binding.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Native bindings for vis PM operations.
+ *
+ * The native addon (Rust via napi-rs) provides:
+ * - Fast package manager detection (lockfile scanning)
+ * - Zero-overhead command resolution across pnpm/npm/yarn/bun
+ * - Native process execution via Rust std::process::Command
+ * - Binary lookup via `which`
+ *
+ * Falls back to pure TypeScript implementations when the native
+ * addon is not available (not compiled, wrong platform, etc.).
+ *
+ * Build with: napi build --platform --release --manifest-path native/Cargo.toml --output-dir .
+ */
+interface DetectedPackageManager {
+    isWorkspace: boolean;
+    name: string;
+    /** Version from packageManager field, or undefined if unknown */
+    version?: string;
+}
+interface ResolvedCommand {
+    args: string[];
+    bin: string;
+    warnings: string[];
+}
+interface ExecResult {
+    code: number;
+    stderr: string;
+    stdout: string;
+}
+interface InstallOptions {
+    dev: boolean;
+    filter: string[];
+    force: boolean;
+    frozenLockfile: boolean;
+    ignoreScripts: boolean;
+    lockfileOnly: boolean;
+    noOptional: boolean;
+    offline: boolean;
+    prod: boolean;
+    recursive: boolean;
+    silent: boolean;
+    workspaceRoot: boolean;
+}
+interface AddOptions {
+    exact: boolean;
+    filter: string[];
+    global: boolean;
+    optional: boolean;
+    packages: string[];
+    peer: boolean;
+    saveDev: boolean;
+    workspace: boolean;
+    workspaceRoot: boolean;
+}
+interface RemoveOptions {
+    filter: string[];
+    global: boolean;
+    packages: string[];
+    recursive: boolean;
+    saveDev: boolean;
+    workspaceRoot: boolean;
+}
+interface WhyOptions {
+    /** Uses Option<i32> in Rust - pass undefined for no depth limit (not null!) */
+    depth?: number;
+    dev: boolean;
+    filter: string[];
+    global: boolean;
+    json: boolean;
+    long: boolean;
+    noOptional: boolean;
+    packages: string[];
+    parseable: boolean;
+    prod: boolean;
+    recursive: boolean;
+}
+interface OutdatedOptions {
+    compatible: boolean;
+    dev: boolean;
+    filter: string[];
+    format: string;
+    global: boolean;
+    long: boolean;
+    noOptional: boolean;
+    packages: string[];
+    prod: boolean;
+    recursive: boolean;
+    workspaceRoot: boolean;
+}
+interface DlxOptions {
+    additionalPackages: string[];
+    args: string[];
+    package: string;
+    shellMode: boolean;
+    silent: boolean;
+}
+interface ExecOptions {
+    args: string[];
+    command: string;
+    filter: string[];
+    parallel: boolean;
+    recursive: boolean;
+    reverse: boolean;
+    shellMode: boolean;
+    workspaceRoot: boolean;
+}
+interface CleanResult {
+    errors: string[];
+    lockfilesRemoved: string[];
+    removed: string[];
+}
+interface SortPackageJsonOptions {
+    /** Enable formatted output with newlines (default: true) */
+    pretty?: boolean;
+    /** Alphabetize script commands (default: false) */
+    sort_scripts?: boolean;
+}
+interface NativeBindings {
+    cleanWorkspace: (root: string, removeLockfile: boolean) => CleanResult;
+    detectPackageManager: (cwd: string) => DetectedPackageManager;
+    execPmCommand: (bin: string, args: string[], cwd: string) => ExecResult;
+    execPmCommandInteractive: (bin: string, args: string[], cwd: string) => number;
+    resolveAdd: (pm: string, version: string, options: AddOptions) => ResolvedCommand;
+    resolveDedupe: (pm: string, version: string, check: boolean) => ResolvedCommand;
+    resolveDlx: (pm: string, version: string, options: DlxOptions) => ResolvedCommand;
+    resolveExec: (pm: string, version: string, options: ExecOptions) => ResolvedCommand;
+    resolveInstall: (pm: string, version: string, options: InstallOptions) => ResolvedCommand;
+    resolveLink: (pm: string, target: string | null) => ResolvedCommand;
+    resolveOutdated: (pm: string, version: string, options: OutdatedOptions) => ResolvedCommand;
+    resolvePmCommand: (pm: string, version: string, subcommand: string, extraArgs: string[]) => ResolvedCommand;
+    resolveRemove: (pm: string, version: string, options: RemoveOptions) => ResolvedCommand;
+    resolveUnlink: (pm: string, version: string, packages: string[], recursive: boolean) => ResolvedCommand;
+    resolveWhy: (pm: string, version: string, options: WhyOptions) => ResolvedCommand;
+    sortPackageJsonString: (contents: string) => string;
+    sortPackageJsonStringWithOptions: (contents: string, options: SortPackageJsonOptions) => string;
+    whichBin: (name: string) => string | null;
+}
+/**
+ * Attempts to load the native addon. Returns undefined if unavailable.
+ * The result is cached after the first attempt.
+ *
+ * Uses createRequire because the napi-generated index.js is CJS.
+ */
+declare const loadNativeBindings: () => NativeBindings | undefined;
+/**
+ * Returns true if the native addon is loaded and available.
+ */
+declare const isNativeAvailable: () => boolean;
+export type { AddOptions, CleanResult, DetectedPackageManager, DlxOptions, ExecOptions, ExecResult, InstallOptions, NativeBindings, OutdatedOptions, RemoveOptions, ResolvedCommand, SortPackageJsonOptions, WhyOptions, };
+export { isNativeAvailable, loadNativeBindings };

package/dist/output.d.ts

@@ -0,0 +1,40 @@
+declare const bold: (s: string) => string;
+declare const dim: (s: string) => string;
+declare const red: (s: string) => string;
+declare const green: (s: string) => string;
+declare const yellow: (s: string) => string;
+declare const cyan: (s: string) => string;
+declare const SYMBOLS: {
+    readonly arrow: string;
+    readonly dash: string;
+    readonly failure: string;
+    readonly success: string;
+    readonly warning: string;
+};
+/** Informational message with blue bold `info:` prefix */
+declare const info: (message: string) => void;
+/** Warning with yellow bold `warn:` prefix */
+declare const warn: (message: string) => void;
+/** Error with red bold `error:` prefix */
+declare const error: (message: string) => void;
+/** Supplementary information with gray bold `note:` prefix */
+declare const note: (message: string) => void;
+/** Success line with green checkmark */
+declare const success: (message: string) => void;
+/** Failure line with red X */
+declare const failure: (message: string) => void;
+/**
+ * Creates a clickable terminal hyperlink using `@visulima/ansi` OSC 8
+ * implementation. Falls back to "text (url)" when not in a TTY.
+ */
+declare const link: (text: string, url: string) => string;
+/**
+ * Sets the VIS_VERSION environment variable for child processes.
+ */
+declare const injectVersion: () => void;
+/**
+ * Set the terminal window title using OSC 0 escape sequence.
+ * No-op when stdout is not a TTY, running in CI, or TERM=dumb.
+ */
+declare const setTerminalTitle: (title: string) => void;
+export { bold, cyan, dim, error, failure, green, info, injectVersion, link, note, red, setTerminalTitle, success, SYMBOLS, warn, yellow };

package/dist/overrides.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Package manager override and resolution management.
+ *
+ * Handles the correct override location for each package manager:
+ * - **pnpm v10+**: top-level `overrides` in `pnpm-workspace.yaml`
+ * - **pnpm v9-**: `pnpm.overrides` in `package.json`
+ * - **npm**: `overrides` in `package.json` (uses `$<name>` references
+ *   for direct dependencies to avoid EOVERRIDE errors)
+ * - **yarn / bun**: `resolutions` in `package.json`
+ *
+ * All overrides are root-level — no PM supports per-workspace overrides.
+ * @see https://pnpm.io/settings — pnpm v10+ workspace settings
+ * @see https://docs.npmjs.com/cli/v10/configuring-npm/package-json#overrides
+ * @see https://yarnpkg.com/configuration/manifest#resolutions
+ * @see https://bun.sh/docs/pm/overrides
+ */
+/** Supported package manager names. */
+type PackageManagerName = "bun" | "npm" | "pnpm" | "yarn";
+/** Package manager identity with version for PM-specific behavior. */
+interface PmInfo {
+    name: PackageManagerName;
+    version: string;
+}
+/** A single override entry mapping an original package to its replacement spec. */
+interface OverrideEntry {
+    /** The original package name being overridden (e.g., `"is-regex"`). */
+    original: string;
+    /** The npm alias spec (e.g., `"npm:@socketregistry/is-regex@^1"`). */
+    spec: string;
+}
+/** Result of reading existing overrides from the project. */
+interface OverridesResult {
+    /** Current overrides — values may be strings or nested objects (npm supports nested overrides). */
+    overrides: Record<string, string | Record<string, string>>;
+    /** The file where overrides are stored. */
+    source: "package.json" | "pnpm-workspace.yaml";
+}
+/** Result of applying override entries. */
+interface ApplyOverridesResult {
+    /** Package names that were newly added. */
+    added: string[];
+    /** Package names whose specs were changed. */
+    updated: string[];
+}
+/**
+ * Reads existing overrides for the detected package manager, choosing
+ * `pnpm-workspace.yaml` for pnpm v10+ and `package.json` for everything else.
+ */
+declare const readOverrides: (workspaceRoot: string, pkgJson: Record<string, unknown>, pm: PmInfo) => OverridesResult;
+/**
+ * Applies override entries to the correct config file for the package manager.
+ *
+ * For npm, direct dependencies use `$&lt;name>` reference syntax to avoid
+ * npm's EOVERRIDE error when an override conflicts with a direct dep range.
+ * @param workspaceRoot Absolute path to the workspace root directory.
+ * @param pkgJsonPath Absolute path to the root `package.json`.
+ * @param entries Override entries to apply.
+ * @param pm Package manager name and version.
+ * @returns Lists of added and updated package names.
+ */
+declare const applyOverrides: (workspaceRoot: string, pkgJsonPath: string, entries: OverrideEntry[], pm: PmInfo) => ApplyOverridesResult;
+/**
+ * Reads the lockfile text for a workspace root.
+ *
+ * Returns the raw text content for regex-based package name scanning.
+ * Falls back to an empty string if the lockfile is missing or unreadable.
+ * @param workspaceRoot Absolute path to the workspace root.
+ * @param pm Package manager name (determines lockfile name).
+ */
+declare const readLockfileText: (workspaceRoot: string, pm: PackageManagerName) => string;
+/**
+ * Checks if a package name appears in the lockfile text using PM-specific string patterns.
+ *
+ * This avoids parsing the entire lockfile — a single `string.includes()` is
+ * sufficient for presence checks.
+ * @param lockText Raw lockfile content.
+ * @param packageName Package name to search for.
+ * @param pm Package manager name (determines the search pattern).
+ */
+declare const lockfileContainsPackage: (lockText: string, packageName: string, pm: PackageManagerName) => boolean;
+export type { ApplyOverridesResult, OverrideEntry, OverridesResult, PackageManagerName, PmInfo };
+export { applyOverrides, lockfileContainsPackage, readLockfileText, readOverrides };

package/dist/plugins/config-loader.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@visulima/cerebro";
+declare const configLoaderPlugin: Plugin;
+export default configLoaderPlugin;

package/dist/plugins/post-command.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@visulima/cerebro";
+declare const postCommandPlugin: (upgradeCheckCallback?: () => void) => Plugin;
+export default postCommandPlugin;

package/dist/plugins/security-enforcement.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@visulima/cerebro";
+declare const securityEnforcementPlugin: Plugin;
+export default securityEnforcementPlugin;

package/dist/pm-runner.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared helper for executing package manager commands via native Rust bindings.
+ * Falls back to JS-based detection when native bindings are unavailable.
+ */
+import type { AddOptions, DlxOptions, ExecOptions, InstallOptions, OutdatedOptions, RemoveOptions, WhyOptions } from "./native-binding.d.ts";
+interface PmInfo {
+    name: "bun" | "npm" | "pnpm" | "yarn";
+    version: string;
+}
+declare const detectPm: (cwd: string) => PmInfo;
+declare const runInstall: (pm: PmInfo, options: InstallOptions, cwd: string, logger: Console) => number;
+declare const runAdd: (pm: PmInfo, options: AddOptions, cwd: string, logger: Console) => number;
+declare const runRemove: (pm: PmInfo, options: RemoveOptions, cwd: string, logger: Console) => number;
+declare const runDedupe: (pm: PmInfo, check: boolean, cwd: string, logger: Console) => number;
+declare const runWhy: (pm: PmInfo, options: WhyOptions, cwd: string, logger: Console) => number;
+declare const runOutdated: (pm: PmInfo, options: OutdatedOptions, cwd: string, logger: Console) => number;
+declare const runLink: (pm: PmInfo, target: string | null, cwd: string, logger: Console) => number;
+declare const runUnlink: (pm: PmInfo, packages: string[], recursive: boolean, cwd: string, logger: Console) => number;
+declare const runDlx: (pm: PmInfo, options: DlxOptions, cwd: string, logger: Console) => number;
+declare const runExec: (pm: PmInfo, options: ExecOptions, cwd: string, logger: Console) => number;
+declare const runPmSubcommand: (pm: PmInfo, subcommand: string, args: string[], cwd: string, logger: Console) => number;
+export type { PmInfo };
+export { detectPm, runAdd, runDedupe, runDlx, runExec, runInstall, runLink, runOutdated, runPmSubcommand, runRemove, runUnlink, runWhy };

package/dist/security.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Supply chain security for package management commands.
+ *
+ * Ports pnpm's security features (minimumReleaseAge, trustPolicy,
+ * allowBuilds, blockExoticSubdeps, strictDepBuilds) to work universally
+ * across all package managers.
+ *
+ * Support matrix for build script enforcement:
+ * - pnpm v10+: Native `allowBuilds` in pnpm-workspace.yaml (vis validates config)
+ * - bun: Native `trustedDependencies` in package.json (vis validates config)
+ * - npm: NO native allowlist. vis adds --ignore-scripts and runs approved scripts manually
+ * - yarn: NO native allowlist. vis checks enableScripts in .yarnrc.yml
+ */
+import type { VisConfig } from "./workspace.d.ts";
+type PackageManagerName = "bun" | "npm" | "pnpm" | "yarn";
+interface SecurityCheckResult {
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Checks the vis config for recommended security settings.
+ *
+ * When `defineConfig()` or `loadVisConfig()` is used, secure defaults are already
+ * merged. This function validates the *final* config (defaults + user overrides)
+ * and flags remaining gaps — primarily `allowBuilds`, which must be user-supplied.
+ */
+declare const checkSecurityConfig: (config: VisConfig, packageManager: string) => SecurityCheckResult;
+/**
+ * Emits a single-line security summary warning before PM commands.
+ * Skipped in CI unless VIS_SECURITY_WARNINGS=1.
+ */
+declare const emitSecurityWarnings: (config: VisConfig, packageManager: string) => void;
+/**
+ * Prints the full security audit report, including active settings and warnings.
+ */
+declare const printSecurityReport: (config: VisConfig, packageManager: string) => void;
+/**
+ * Reports which vis security settings would map to pnpm-workspace.yaml.
+ */
+declare const previewPnpmSync: (config: VisConfig) => string[];
+/**
+ * Scans node_modules for packages with install scripts that aren't approved.
+ */
+declare const scanUnapprovedBuildScripts: (cwd: string, allowBuilds: Record<string, boolean>) => string[];
+interface EnforcementResult {
+    extraArgs: string[];
+    postInstallPackages: string[];
+    scriptsBlockedByDefault: boolean;
+    warnings: string[];
+}
+/**
+ * Determines enforcement actions needed before install/add/update.
+ */
+declare const enforceScriptSecurity: (pm: PackageManagerName, workspaceRoot: string, config: VisConfig) => EnforcementResult;
+/**
+ * Syncs vis security.allowBuilds to native PM config format.
+ */
+declare const syncAllowBuildsToNativeConfig: (pm: PackageManagerName, workspaceRoot: string, allowBuilds: Record<string, boolean>) => string[];
+/**
+ * Runs postinstall scripts for approved packages after --ignore-scripts install.
+ */
+declare const runApprovedScripts: (workspaceRoot: string, patterns: string[]) => void;
+export type { EnforcementResult, PackageManagerName, SecurityCheckResult };
+export { checkSecurityConfig, emitSecurityWarnings, enforceScriptSecurity, previewPnpmSync, printSecurityReport, runApprovedScripts, scanUnapprovedBuildScripts, syncAllowBuildsToNativeConfig, };

package/dist/socket-security.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Socket.dev security helpers for package security intelligence.
+ *
+ * Ported from @vltpkg/security-archive and adapted to use the Socket.dev
+ * public API for fetching package security scores, alerts, and report data.
+ * Uses a file-based cache (following the ai-cache.ts pattern) with a 1-hour TTL.
+ * @see https://socket.dev
+ * @see https://github.com/vltpkg/vltpkg/tree/main/src/security-archive
+ */
+declare const DEFAULT_LOW_SCORE_THRESHOLD = 0.4;
+/** Extra properties attached to a package alert. */
+interface PackageAlertProps {
+    cveId?: `CVE-${string}`;
+    cwes?: {
+        id: `CWE-${string}`;
+    }[];
+    lastPublish: string;
+}
+/** A known security alert for a given package. */
+interface PackageAlert {
+    category: string;
+    key: string;
+    props?: PackageAlertProps;
+    severity: "critical" | "high" | "low" | "medium";
+    type: string;
+}
+/** Security scores for a given package (each 0–1). */
+interface PackageScore {
+    /** Score factors relating to package licensing. */
+    license: number;
+    /** Score factors relating to package maintenance. */
+    maintenance: number;
+    /** Average of all score factors. */
+    overall: number;
+    /** Score factors relating to code quality. */
+    quality: number;
+    /** Score factors relating to supply chain security. */
+    supplyChain: number;
+    /** Score factors relating to package vulnerabilities. */
+    vulnerability: number;
+}
+/** Full report data for a single package from Socket.dev. */
+interface PackageReportData {
+    alerts: PackageAlert[];
+    author: string[];
+    id: string;
+    license: string;
+    name: string;
+    namespace?: `@${string}`;
+    score: PackageScore;
+    size: number;
+    type: "npm";
+    version: string;
+}
+/** Configuration options for the Socket.dev security client. */
+interface SocketSecurityOptions {
+    /** Custom API token. Required — set via VIS_SOCKET_TOKEN env var or config. */
+    apiToken?: string;
+    /** Cache TTL in milliseconds. Defaults to 1 hour. */
+    cacheTtlMs?: number;
+    /** Minimum overall score (0–1) below which packages are flagged. Defaults to 0.4. */
+    minimumScore?: number;
+    /** Request timeout in milliseconds. Defaults to 15 seconds. */
+    timeoutMs?: number;
+}
+declare const isPackageReportData: (o: unknown) => o is PackageReportData;
+declare const calculateOverallScore: (score: Omit<PackageScore, "overall">) => number;
+/**
+ * Fetches security report data from the Socket.dev API for the given packages.
+ * Batches requests to stay within API limits.
+ * @param packages Array of { name, version } to look up.
+ * @param options Optional configuration.
+ * @returns Map of "name@version" to PackageReportData.
+ */
+declare const fetchSocketReports: (packages: {
+    name: string;
+    version: string;
+}[], options?: SocketSecurityOptions) => Promise<Map<string, PackageReportData>>;
+/** Returns the full package name including namespace scope if present. */
+declare const getFullPackageName: (report: Pick<PackageReportData, "name" | "namespace">) => string;
+/** Maps a 0–1 score to a human-readable label. */
+declare const scoreLabel: (score: number) => string;
+/** Maps a 0–1 score to a color name for terminal output. */
+declare const scoreColor: (score: number) => "green" | "red" | "yellow";
+/** Formats a PackageReportData into a compact one-line summary string. */
+declare const formatReportSummary: (report: PackageReportData) => string;
+/** Formats a detailed multi-line report for a single package. */
+declare const formatReportDetailed: (report: PackageReportData) => string;
+/**
+ * Formats a security summary for a list of packages.
+ * Suitable for displaying after install/update commands.
+ */
+declare const formatSecurityOverview: (reports: Map<string, PackageReportData>) => string;
+declare const clearSocketCache: () => number;
+/** Socket.dev config shape as it appears in VisConfig.security.socket. */
+interface SocketConfigLike {
+    apiToken?: string;
+    cacheTtlMs?: number;
+    enabled?: boolean;
+    minimumScore?: number;
+    timeoutMs?: number;
+}
+/**
+ * Builds SocketSecurityOptions from the VisConfig socket config section.
+ * Returns undefined if Socket.dev is not enabled or no API token is available.
+ */
+declare const buildSocketOptions: (socketConfig: SocketConfigLike | undefined) => SocketSecurityOptions | undefined;
+/** A persisted "accepted risk" entry from the vis config. */
+interface AcceptedRisk {
+    /** ISO 8601 timestamp when the risk was accepted. */
+    acceptedAt: string;
+    /** The overall Socket.dev score at the time of acceptance. */
+    acceptedScore: number;
+    /** User-provided reason for accepting the risk. */
+    reason: string;
+}
+/**
+ * Checks if a package has an accepted risk entry.
+ * Matches by exact name@version, unversioned name, or trailing glob patterns.
+ * Returns the matching AcceptedRisk if found, undefined otherwise.
+ */
+declare const findAcceptedRisk: (packageName: string, version: string, acceptedRisks: Record<string, AcceptedRisk> | undefined) => AcceptedRisk | undefined;
+/**
+ * Formats a config snippet for the user to paste into vis.config.ts
+ * to persist an accepted risk decision.
+ */
+declare const formatAcceptedRiskSnippet: (packageName: string, _version: string, score: number, reason: string) => string;
+export type { AcceptedRisk, PackageAlert, PackageAlertProps, PackageReportData, PackageScore, SocketSecurityOptions };
+export { buildSocketOptions, calculateOverallScore, clearSocketCache, DEFAULT_LOW_SCORE_THRESHOLD, fetchSocketReports, findAcceptedRisk, formatAcceptedRiskSnippet, formatReportDetailed, formatReportSummary, formatSecurityOverview, getFullPackageName, isPackageReportData, scoreColor, scoreLabel, };

package/dist/tips.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,16 @@
+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<import("@visulima/tui").ScrollViewRef>;
+    /** 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;

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

@@ -0,0 +1,15 @@
+interface QuitDialogProps {
+    /** Countdown seconds. 0 = no auto-exit. */
+    readonly autoExitSeconds: number;
+    /** Called when the user cancels (any key except q). */
+    readonly onCancel: () => void;
+    /** Whether the dialog is visible. */
+    readonly visible: boolean;
+}
+/**
+ * Reusable quit confirmation dialog with countdown timer.
+ * Shows a countdown, then auto-exits. Any key cancels the countdown.
+ * Press q to exit immediately.
+ */
+declare const QuitDialog: ({ autoExitSeconds, onCancel, visible }: QuitDialogProps) => React.JSX.Element | null;
+export default QuitDialog;

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

@@ -0,0 +1,19 @@
+import type { ScrollViewRef } from "@visulima/tui";
+import type { TaskRowData } from "./TaskRow.d.ts";
+interface TaskListPanelProps {
+    /** Hide Cache + Duration columns (used in split view where output panel shows them). */
+    compact?: boolean;
+    filterActive: boolean;
+    filterText: string;
+    focused: boolean;
+    headerStatus: "error" | "running" | "success";
+    /** Number of parallel task slots to display at the bottom. */
+    parallelSlots?: number;
+    pinnedTaskIds: [string | null, string | null];
+    rows: TaskRowData[];
+    scrollRef: React.RefObject<ScrollViewRef>;
+    selectedIndex: number;
+    title: string;
+}
+declare const TaskListPanel: ({ compact, filterActive, filterText, focused, headerStatus, parallelSlots, pinnedTaskIds, rows, scrollRef, selectedIndex, title, }: TaskListPanelProps) => React.JSX.Element;
+export default TaskListPanel;

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

@@ -0,0 +1,12 @@
+import type { TaskStatus } from "@visulima/task-runner";
+export interface TaskRowData {
+    duration?: number;
+    elapsed?: number;
+    status: "pending" | "running" | TaskStatus;
+    taskId: string;
+}
+interface TaskRowProps {
+    row: TaskRowData;
+}
+declare const TaskRow: ({ row }: TaskRowProps) => React.JSX.Element;
+export default TaskRow;