@visulima/vis 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/tui/components/optimize/OptimizeStore.d.ts

@@ -0,0 +1,50 @@
+/** An optimization entry that can be either an e18e module replacement or a Socket.dev override. */
+interface OptimizeEntry {
+    /** Category for filtering and display. */
+    category: "micro-utility" | "native" | "preferred" | "socket";
+    /** Whether a codemod is available for this entry (e18e only). */
+    hasCodemod: boolean;
+    /** The override spec for socket entries (e.g., "npm:@socketregistry/is-regex@^1"). */
+    overrideSpec?: string;
+    /** The original package name. */
+    packageName: string;
+    /** Human-readable replacement target description. */
+    replacement: string;
+}
+type FilterType = "all" | "micro-utility" | "native" | "preferred" | "socket";
+interface OptimizeState {
+    applyProgress: {
+        current: number;
+        total: number;
+    } | null;
+    checkedEntries: Set<string>;
+    entries: OptimizeEntry[];
+    error: string | null;
+    filterActive: boolean;
+    filterText: string;
+    filterType: FilterType;
+    focusedPanel: "detail" | "list";
+    phase: "applying" | "browsing" | "done" | "error";
+    selectedIndex: number;
+}
+type Listener = () => void;
+declare class OptimizeStore {
+    #private;
+    constructor(entries: OptimizeEntry[]);
+    getSnapshot: () => OptimizeState;
+    subscribe: (listener: Listener) => () => void;
+    getFilteredEntries: () => OptimizeEntry[];
+    select(index: number): void;
+    toggleCheck(packageName: string): void;
+    toggleAll(): void;
+    setFilter(type: FilterType): void;
+    setFilterText(text: string): void;
+    setFilterActive(active: boolean): void;
+    setFocusedPanel(panel: "detail" | "list"): void;
+    setPhase(phase: OptimizeState["phase"]): void;
+    setProgress(current: number, total: number): void;
+    setError(error: string): void;
+    getCheckedEntries(): OptimizeEntry[];
+}
+export type { FilterType, OptimizeEntry, OptimizeState };
+export { OptimizeStore };

package/dist/tui/components/optimize/VisOptimizeApp.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { OptimizeStore } from "./OptimizeStore.d.ts";
+interface VisOptimizeAppProps {
+    isDryRun: boolean;
+    store: OptimizeStore;
+}
+declare const VisOptimizeApp: ({ isDryRun, store }: VisOptimizeAppProps) => React.JSX.Element;
+export default VisOptimizeApp;

package/dist/tui/components/optimize/constants.d.ts

@@ -0,0 +1,7 @@
+/** Category colors for the optimize TUI — shared between list and detail panels. */
+declare const CATEGORY_COLORS: Record<string, string>;
+/** Short labels for category badges in the list panel. */
+declare const CATEGORY_LABELS: Record<string, string>;
+/** Human-readable descriptions for each optimization category. */
+declare const CATEGORY_DESCRIPTIONS: Record<string, string>;
+export { CATEGORY_COLORS, CATEGORY_DESCRIPTIONS, CATEGORY_LABELS };

package/dist/tui/components/update/PackageDetailPanel.d.ts

@@ -0,0 +1,12 @@
+import type { ScrollViewRef } from "@visulima/tui";
+import type { AiRecommendation } from "../../../ai-analysis.d.ts";
+import type { OutdatedEntry } from "../../../catalog.d.ts";
+interface PackageDetailPanelProps {
+    changelogUrl?: string;
+    entry: OutdatedEntry | null;
+    focused: boolean;
+    recommendation?: AiRecommendation;
+    scrollRef?: React.RefObject<ScrollViewRef>;
+}
+declare const PackageDetailPanel: ({ changelogUrl, entry, focused, recommendation, scrollRef }: PackageDetailPanelProps) => React.JSX.Element;
+export default PackageDetailPanel;

package/dist/tui/components/update/PackageListPanel.d.ts

@@ -0,0 +1,21 @@
+import type { OutdatedEntry } from "../../../catalog.d.ts";
+import type { FilterType } from "./UpdateStore.d.ts";
+interface PackageListPanelProps {
+    checkedEntries: Set<string>;
+    entries: OutdatedEntry[];
+    filterActive: boolean;
+    filterText: string;
+    filterType: FilterType;
+    filteredOutCount: number;
+    focused: boolean;
+    groupedByCatalog: Map<string, OutdatedEntry[]>;
+    isDryRun: boolean;
+    scrollOffset: number;
+    selectedIndex: number;
+    totalCatalogEntries: number;
+    totalChecked: number;
+    totalEntries: number;
+    viewportHeight: number;
+}
+declare const PackageListPanel: ({ checkedEntries, entries, filterActive, filterText, filterType, filteredOutCount, focused, groupedByCatalog, isDryRun, scrollOffset, selectedIndex, totalCatalogEntries, totalChecked, totalEntries, viewportHeight, }: PackageListPanelProps) => React.JSX.Element;
+export default PackageListPanel;

package/dist/tui/components/update/UpdateStore.d.ts

@@ -0,0 +1,62 @@
+import type { AiAnalysisResult, AiRecommendation } from "../../../ai-analysis.d.ts";
+import type { OutdatedEntry } from "../../../catalog.d.ts";
+export type FilterType = "all" | "major" | "minor" | "patch" | "security";
+export type UpdatePhase = "applying" | "browsing" | "done" | "error";
+export interface UpdateState {
+    /** AI analysis result (null if not requested). */
+    aiResult: AiAnalysisResult | null;
+    /** Whether all visible entries are checked. */
+    allChecked: boolean;
+    /** Progress during apply phase. */
+    applyProgress: {
+        current: number;
+        total: number;
+    } | null;
+    /** Set of checked package names for selective apply. */
+    checkedEntries: Set<string>;
+    /** All outdated entries. */
+    entries: OutdatedEntry[];
+    /** Error message if apply failed. */
+    error: string | null;
+    /** Whether the text filter input is active. */
+    filterActive: boolean;
+    /** Current filter text (empty = no filter). */
+    filterText: string;
+    /** Filter by update type. */
+    filterType: FilterType;
+    /** Which panel has keyboard focus. */
+    focusedPanel: "detail" | "list";
+    /** Entries grouped by catalog name. */
+    groupedByCatalog: Map<string, OutdatedEntry[]>;
+    /** Current lifecycle phase. */
+    phase: UpdatePhase;
+    /** Currently highlighted entry index in the filtered list. */
+    selectedIndex: number;
+}
+type Listener = () => void;
+export declare class UpdateStore {
+    #private;
+    constructor(entries: OutdatedEntry[], aiResult?: AiAnalysisResult | null);
+    getSnapshot: () => UpdateState;
+    subscribe: (listener: Listener) => () => void;
+    /** Get the currently filtered + visible entries. */
+    getFilteredEntries(): OutdatedEntry[];
+    /** Get AI recommendation for a specific package. */
+    getRecommendation(packageName: string): AiRecommendation | undefined;
+    /** Get the list of checked entries (for apply). */
+    getCheckedEntries(): OutdatedEntry[];
+    setSelectedIndex(index: number): void;
+    setFocusedPanel(panel: "detail" | "list"): void;
+    setFilterType(type: FilterType): void;
+    setFilter(text: string): void;
+    setFilterActive(active: boolean): void;
+    toggleCheck(packageName: string): void;
+    checkAll(): void;
+    uncheckAll(): void;
+    toggleAll(): void;
+    startApply(): void;
+    updateApplyProgress(current: number): void;
+    markDone(): void;
+    setError(error: string): void;
+}
+export {};

package/dist/tui/components/update/VisUpdateApp.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import type { OutdatedEntry } from "../../../catalog.d.ts";
+import type { UpdateStore } from "./UpdateStore.d.ts";
+interface VisUpdateAppProps {
+    /** 0 = no auto-exit (default), >0 = countdown seconds */
+    autoExitSeconds?: number;
+    changelogUrls?: Map<string, string>;
+    /** Total unique packages checked by the registry. */
+    checkedCount?: number;
+    /** Total catalog entries (before deduplication). */
+    totalCatalogEntries?: number;
+    /** Packages that have newer versions but were filtered out by the target constraint. */
+    filteredOutEntries?: OutdatedEntry[];
+    isDryRun: boolean;
+    store: UpdateStore;
+}
+declare const VisUpdateApp: ({ autoExitSeconds, changelogUrls, checkedCount, filteredOutEntries, isDryRun, store, totalCatalogEntries }: VisUpdateAppProps) => React.JSX.Element;
+export default VisUpdateApp;

package/dist/tui/dynamic-life-cycle.d.ts

@@ -0,0 +1,21 @@
+import type { LifeCycleInterface, Task } from "@visulima/task-runner";
+import { TaskStore } from "./components/TaskStore.d.ts";
+interface DynamicOutputOptions {
+    args: {
+        parallel?: boolean | number;
+        targets: string[];
+    };
+    /** Auto-exit config: false = stay open, true = 3s countdown, number = custom seconds */
+    autoExit?: boolean | number;
+    projectNames: string[];
+    /** Registry of writable stdin entries keyed by task ID, for interactive input. */
+    stdinRegistry?: Map<string, import("./types").StdinEntry>;
+    tasks: Task[];
+}
+interface DynamicOutputResult {
+    lifeCycle: LifeCycleInterface;
+    renderIsDone: Promise<void>;
+    store: TaskStore;
+}
+export declare const createDynamicOutputRenderer: (options: DynamicOutputOptions) => DynamicOutputResult;
+export {};

package/dist/tui/formatting-utils.d.ts

@@ -0,0 +1,17 @@
+import type { Task } from "@visulima/task-runner";
+/**
+ * Formats a CLI flag for display output.
+ * @param leftPad Padding string
+ * @param flag The flag name
+ * @param value The flag value
+ */
+export declare const formatFlags: (leftPad: string, flag: string, value: unknown) => string;
+/**
+ * Generates a human-readable description of the targets and projects being executed.
+ *
+ * Examples:
+ * - "target build for project my-app"
+ * - "targets build, test for 5 projects"
+ * - "target build for 3 projects and 2 tasks they depend on"
+ */
+export declare const formatTargetsAndProjects: (projectNames: string[], targets: string[], tasks: Task[]) => string;

package/dist/tui/pretty-time.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Formats a process.hrtime() tuple into a compact string like "1s 234ms".
+ */
+export declare const formatHrtime: (hrtime: [number, number]) => string;
+/**
+ * Formats milliseconds into a compact string like "1s 300ms", "340ms", "1m 5s".
+ */
+export declare const formatMs: (ms: number) => string;

package/dist/tui/static-life-cycle.d.ts

@@ -0,0 +1,22 @@
+import type { LifeCycleInterface, Task, TaskResult, TaskStatus } from "@visulima/task-runner";
+interface StaticOutputOptions {
+    args: {
+        targets: string[];
+    };
+    projectNames: string[];
+    tasks: Task[];
+}
+/**
+ * A lifecycle handler for CI environments that produces static, append-only output.
+ * No cursor manipulation — just linear log lines.
+ */
+export declare class StaticOutputLifeCycle implements LifeCycleInterface {
+    #private;
+    constructor(options: StaticOutputOptions);
+    startCommand(): void;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): void;
+    printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
+    endCommand(): void;
+}
+export {};

package/dist/tui/status-utils.d.ts

@@ -0,0 +1,20 @@
+import type { TaskStatus } from "@visulima/task-runner";
+export declare const isCacheStatus: (status: string) => boolean;
+export interface StatusInfo {
+    color: string;
+    icon: string;
+}
+export declare const getStatusInfo: (status: TaskStatus) => StatusInfo;
+/**
+ * Returns the colored status icon as an ANSI string (for raw stdout writes).
+ */
+export declare const getStatusIcon: (status: TaskStatus) => string;
+/**
+ * Returns a colored prefix string for a status (for raw stdout writes).
+ */
+export declare const getStatusPrefix: (status: TaskStatus) => string;
+/**
+ * Logs task terminal output with formatting.
+ * Uses GitHub Actions grouping when available.
+ */
+export declare const logCommandOutputCI: (taskId: string, status: TaskStatus, output: string) => void;

package/dist/tui/symbols.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unicode symbols for TUI output with ASCII fallbacks.
+ */
+export declare const TICK: string;
+export declare const CROSS: string;
+export declare const ELLIPSIS: string;
+export declare const DASH: string;

package/dist/tui/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents a writable stdin entry for interactive PTY input.
+ */
+export interface StdinEntry {
+    /** Kill the child process/PTY. */
+    kill?: (signal?: string) => void;
+    /** Resize the child's PTY (only available for PTY-backed processes). */
+    resize?: (cols: number, rows: number) => void;
+    /** Write data to the child's stdin or PTY. */
+    write: (data: string) => void;
+}

package/dist/typosquats.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Typosquat detection for package names.
+ *
+ * Uses a curated blocklist of known typosquats (data/typosquats.json) and
+ * runtime heuristics (character substitution, transposition, omission) to
+ * warn users before they install a potentially malicious package.
+ */
+export type Blocklist = Record<string, string[]>;
+export interface TyposquatMatch {
+    /** The package name that was checked. */
+    input: string;
+    /** The legitimate package this appears to be a typosquat of. */
+    legitimate: string;
+    /** How the match was detected: "blocklist" (exact match in JSON) or "heuristic" (generated variant). */
+    method: "blocklist" | "heuristic";
+}
+export interface TyposquatCheckResult {
+    /** Whether the operation should proceed. */
+    ok: boolean;
+    /**
+     * The (possibly corrected) package names to use.
+     * When the user chooses "use suggested name", the typosquat names are
+     * replaced with their legitimate counterparts.
+     */
+    packages: string[];
+}
+/**
+ * Generates typosquat variants of a package name using common attack patterns:
+ * - Character omission (dropping one character)
+ * - Adjacent character transposition (swapping neighbors)
+ * - Character duplication (repeating one character)
+ * - Homoglyph / keyboard substitution
+ * - Separator manipulation (dash/dot/underscore swaps)
+ * - Common suffixes (-js, -node)
+ *
+ * Separators (`-`, `.`, `_`) are preserved during omission and duplication passes.
+ * Transposition is skipped when either character is a separator.
+ * Names shorter than 3 characters return an empty set.
+ * @param name The package name to generate variants for.
+ * @returns A set of unique variant strings (never includes the original name).
+ */
+export declare const generateVariants: (name: string) => Set<string>;
+/**
+ * Check a single package name against the typosquat blocklist.
+ * Returns a match if the name is a known typosquat, or `undefined` if safe.
+ */
+export declare const checkTyposquat: (packageName: string) => TyposquatMatch | undefined;
+/** Check multiple package names. Returns only the matches (empty if all safe). */
+export declare const checkTyposquats: (packageNames: string[], allowlist?: string[]) => TyposquatMatch[];
+/**
+ * Display typosquat warnings and prompt the user.
+ *
+ * Choices:
+ * - **S** (suggested): replace the typosquat names with the correct packages and continue
+ * - **y** (yes): continue with the original (potentially dangerous) names
+ * - **N** (no, default): abort the operation
+ *
+ * Non-interactive mode always aborts.
+ */
+export declare const runTyposquatCheck: (packageNames: string[], allowlist?: string[]) => Promise<TyposquatCheckResult>;
+/**
+ * Scan package.json dependencies for potential typosquats.
+ *
+ * Unlike `runTyposquatCheck` (used by `add`), this cannot replace names because
+ * they live in package.json. It warns the user and asks whether to proceed.
+ *
+ * In non-interactive mode, always aborts.
+ * @returns `true` to proceed, `false` to abort.
+ */
+export declare const scanDepsForTyposquats: (cwd: string, allowlist?: string[]) => Promise<boolean>;

package/dist/upgrade-check.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Background upgrade check - non-intrusive update notification.
+ *
+ * Per vite-plus upgrade-check RFC:
+ * - Spawns async registry check while command runs (no latency impact)
+ * - Shows single-line notice at most once per 24 hours
+ * - Cached at ~/.vis/.upgrade-check.json
+ * - Skipped in CI, test, quiet, non-TTY, and excluded commands
+ * - 500ms timeout prevents network from delaying exit
+ */
+/** Commands that should NOT trigger upgrade checks. */
+declare const EXCLUDED_COMMANDS: Set<string>;
+/**
+ * Compares two semver version strings.
+ * Returns true if `latest` is newer than `current`.
+ */
+declare const isNewerVersion: (current: string, latest: string) => boolean;
+/**
+ * Determines if the upgrade check should run for this invocation.
+ */
+declare const shouldCheck: (command: string) => boolean;
+/**
+ * Runs the background upgrade check. Non-blocking.
+ *
+ * 1. Check if we need to query the registry (24h cooldown)
+ * 2. If yes, fetch latest version asynchronously
+ * 3. Return a promise that resolves with the check function to call after command
+ */
+declare const startUpgradeCheck: (currentVersion: string, command: string) => (() => void) | undefined;
+export { EXCLUDED_COMMANDS, isNewerVersion, shouldCheck, startUpgradeCheck };

package/dist/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared utility for option parsing across command handlers.
+ */
+/**
+ * Converts a CLI option value (which may be undefined, a single string,
+ * or an array of strings) into a normalized string array.
+ */
+declare const toStringArray: (value: unknown) => string[];
+/**
+ * Safely extracts an error message from an unknown caught value.
+ * Handles Error instances, strings, and other types.
+ */
+declare const errorMessage: (error: unknown) => string;
+/**
+ * Extracts the package name and optional version specifier from a CLI argument
+ * like "react", "react@19", "@scope/pkg@^2".
+ */
+declare const parsePackageArgument: (argument: string) => {
+    name: string;
+    versionSpec: string | undefined;
+};
+export { errorMessage, parsePackageArgument, toStringArray };