@k8slens/ai-tools-contracts 1.0.0

package/dist/src/get-ai-tool-injectable-bunch.d.ts

@@ -0,0 +1,534 @@
+import { type DropDownMenuItem } from "@k8slens/drop-down-menu-contracts";
+import React from "react";
+import type { SvgProps } from "@k8slens/element-components";
+import type { AiToolKind, GetCliCommand, GetAiToolIsInstalledCliCommand, GetOpenToolInExternalTerminalCliCommand } from "./ai-tool";
+import { type MaybeOperatingSystemAndShellSpecific } from "./os-and-shell-specific";
+import { type AiToolDescriptionProps } from "./ai-tool-description";
+export interface AiToolBunchParams {
+    readonly kind: AiToolKind;
+    /** Lower comes first; the lowest-numbered installed tool is the default. */
+    readonly orderNumber: number;
+    /**
+     * Builds the in-app launch command (knows how to pass `{prompt}`). A single
+     * OS-agnostic builder, or one per operating system.
+     */
+    readonly getCliCommand: MaybeOperatingSystemAndShellSpecific<GetCliCommand>;
+    /**
+     * Builds the command that *resumes* the tool when its tab's session is
+     * re-established (e.g. after an app restart) rather than first opened — e.g.
+     * `claude --continue || claude`, which continues the prior session and falls
+     * back to a fresh launch when there is none. A tool with no dedicated resume
+     * invocation passes its launch command. Usually ignores `prompt`. OS-agnostic,
+     * or one builder per operating system.
+     */
+    readonly getResumeCliCommand: MaybeOperatingSystemAndShellSpecific<GetCliCommand>;
+    /**
+     * Builds the command that checks whether the tool is installed (e.g.
+     * `command -v claude` / `where claude`), run on the host with exit code 0
+     * meaning installed. OS-agnostic, or one builder per operating system. Omit for
+     * an always-available tool (e.g. the free-text Custom command), which is then
+     * reported as installed.
+     */
+    readonly getAiToolIsInstalledCliCommand?: MaybeOperatingSystemAndShellSpecific<GetAiToolIsInstalledCliCommand>;
+    /**
+     * Builds the command that opens the tool in a fresh external terminal window —
+     * typically wrapping the tool's invocation with a `build{Mac,Windows,Linux}ExternalTerminalCommand`
+     * helper. OS-agnostic, or one builder per operating system.
+     */
+    readonly getOpenToolInExternalTerminalCliCommand: MaybeOperatingSystemAndShellSpecific<GetOpenToolInExternalTerminalCliCommand>;
+    /** Canonical plain-text display name, e.g. `"Claude Code"`. Drives string-only slots and the default name component. Defaults to `kind`. */
+    readonly name?: string;
+    /** Optional rich display-name component; defaults to a fragment of the display name. */
+    readonly Name?: React.ComponentType;
+    /** Short blurb introducing the tool (e.g. `"The coding assistant by Anthropic"`), shown as the selector's secondary line. Receives the tool's `isInstalled` state so it may opt to show a "Not found in PATH" message instead. A component so it may include markup/links. Defaults to nothing. */
+    readonly Description?: React.ComponentType<AiToolDescriptionProps>;
+    /** Icon component (defaults to a generic terminal glyph). Accepts `SvgProps` so call sites can size it. */
+    readonly Icon?: React.ComponentType<SvgProps>;
+    /** Settings component shown below the selector when this kind is selected (e.g. the custom command input). */
+    readonly Settings?: React.ComponentType;
+    /** Instructions shown below the selector when this kind is not installed, so it appears disabled with guidance instead of hidden. May contain links. */
+    readonly InstallationInstructions?: React.ComponentType;
+    /** Filename the tool auto-discovers in its working directory (e.g. `"CLAUDE.md"`). Omit when the tool reads no such file; the launcher always writes the canonical `AGENTS.md`. */
+    readonly instructionsFilename?: string;
+}
+/**
+ * Register a typical LLM CLI tool: its kind, order, the commands (launch, resume,
+ * install-check, open-externally), display name, and icon. Each command may be a
+ * single agnostic builder, or vary per operating system and/or shell — registered
+ * via `getOsAndShellAwareInjectable`: the OS is filtered at registration (host-only
+ * `*-only` tags) and the shell is selected at runtime (`resolveForShell`), since
+ * the configured shell is async. The detected tools list runs the install-check
+ * command via
+ * `aiToolInstalledViaCliCommandInjectionToken` (omit the command for an
+ * always-available tool). Bundle several with
+ * `getInjectableBunch([ getAiToolInjectableBunch(...), ... ])`.
+ */
+export declare const getAiToolInjectableBunch: (params: AiToolBunchParams) => {
+    aiTool: import("@k8slens/injectable").Injectable2<() => AiToolKind>;
+    orderNumber: import("@k8slens/injectable").Injectable2<() => number>;
+    getCliCommand: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+    } | {
+        macos: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+        windows: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+        linux: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+        unitTesting: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+    };
+    getResumeCliCommand: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetCliCommand;
+        }>;
+    } | {
+        macos: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+        windows: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+        linux: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+        unitTesting: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetCliCommand;
+            }>;
+        };
+    };
+    getOpenToolInExternalTerminalCliCommand: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetOpenToolInExternalTerminalCliCommand;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetOpenToolInExternalTerminalCliCommand;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetOpenToolInExternalTerminalCliCommand;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetOpenToolInExternalTerminalCliCommand;
+        }>;
+    } | {
+        macos: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+        };
+        windows: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+        };
+        linux: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+        };
+        unitTesting: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetOpenToolInExternalTerminalCliCommand;
+            }>;
+        };
+    };
+    name: import("@k8slens/injectable").Injectable2<() => React.ComponentType<{}>>;
+    displayName: import("@k8slens/injectable").Injectable2<() => string>;
+    description: import("@k8slens/injectable").Injectable2<() => React.ComponentType<AiToolDescriptionProps>>;
+    icon: import("@k8slens/injectable").Injectable2<() => React.ComponentType<{
+        $className?: import("@k8slens/public-utilities").IClassName;
+        className?: string;
+        $block?: boolean | "inline";
+        $cursor?: import("@k8slens/element-components").$CursorProps;
+        readonly $color?: import("@k8slens/element-components").TextColor | import("@k8slens/element-components").$ColorProps;
+        $backgroundColor?: import("@k8slens/element-components").BackgroundColor | import("@k8slens/element-components").$BackgroundColorProps;
+        $border?: import("@k8slens/element-components").$BorderProps;
+        $padding?: boolean | import("@k8slens/element-components").DirectionalPadding | import("@k8slens/element-components").TShirtSize;
+        $margin?: boolean | import("@k8slens/element-components").DirectionalMargin | import("@k8slens/element-components").TShirtSize | "auto";
+        $overflow?: import("@k8slens/element-components").Overflow | {
+            x?: import("@k8slens/element-components").Overflow;
+            y?: import("@k8slens/element-components").Overflow;
+            hideScrollbar?: boolean;
+        };
+        readonly $anchor?: boolean;
+        readonly $anchoredAt?: import("@k8slens/element-components").AnchoredAt;
+        readonly children?: React.ReactNode;
+        readonly $onOutsideClick?: (event: PointerEvent) => void;
+        $textAlign?: "left" | "center" | "right";
+        $ref?: import("@k8slens/element-components").$RefProp<HTMLElement>;
+        ref?: import("@k8slens/element-components").RefLike<HTMLElement>;
+        $focusable?: {
+            context: import("@k8slens/element-components").AnyFocusableContext<any>;
+            item: any;
+            orderNumber?: number;
+        } | undefined;
+        onFocus?: React.FocusEventHandler<HTMLElement> | undefined;
+        onBlur?: React.FocusEventHandler<HTMLElement> | undefined;
+        onKeyDown?: React.KeyboardEventHandler<HTMLElement> | undefined;
+        tabIndex?: HTMLElement["tabIndex"];
+        $grayscale?: boolean;
+        $style?: React.CSSProperties;
+        style?: React.CSSProperties;
+        $tint?: string;
+        $faded?: boolean;
+        $outline?: {
+            focusVisible?: import("@k8slens/element-components").$OutlineProps;
+        };
+        readonly $floating?: import("@k8slens/element-components").$FloatingProps;
+        $boxShadow?: boolean | "elevated" | "subtle";
+        readonly $hoverable?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableProps>;
+        onMouseEnter?: React.MouseEventHandler<HTMLElement> | undefined;
+        onMouseLeave?: React.MouseEventHandler<HTMLElement> | undefined;
+        $hoverableByDragging?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableByDraggingProps<any>> | undefined;
+        $absolute?: import("@k8slens/element-components").AbsolutePosition | boolean;
+        $hidden?: boolean;
+        $noPointerEvents?: boolean;
+        $offset?: {
+            direction: import("@k8slens/element-components").Direction;
+            size: import("@k8slens/element-components").TShirtSize;
+        };
+        $offsetChildren?: {
+            direction: import("@k8slens/element-components").Direction;
+            size: import("@k8slens/element-components").TShirtSize;
+        };
+        $relative?: boolean;
+        $fixed?: boolean;
+        $transition?: boolean;
+        $visuallyHidden?: boolean;
+        $displayContents?: boolean;
+        $draggable?: {
+            context: import("@k8slens/element-components").DraggableContext<any>;
+            item: any;
+        } | undefined;
+        $droppable?: {
+            context: import("@k8slens/element-components").DraggableContext<any>;
+            onDrop: (item: any) => void;
+        } | undefined;
+        $font?: boolean | {
+            size?: import("@k8slens/element-components").FontSize;
+            italic?: boolean;
+            bold?: boolean | "600";
+            lineHeight?: import("@k8slens/element-components").FontLineHeight;
+            forceWrap?: boolean;
+            noWrap?: boolean;
+            uppercase?: boolean;
+            underline?: boolean;
+            textOverflow?: "clip" | "ellipsis" | "default";
+        };
+        $tooltip?: string | import("@k8slens/element-components").$TooltipProps<any> | null;
+        $width?: import("@k8slens/element-components").TShirtSize | "full" | "stretch" | import("@k8slens/element-components").$WidthProps;
+        $height?: import("@k8slens/element-components").TShirtSize | "full" | "auto" | "stretch" | import("@k8slens/element-components").$HeightProps;
+        $size?: import("@k8slens/element-components").TShirtSize | "full" | import("@k8slens/element-components").$SizeProps;
+        $grid?: import("@k8slens/element-components").GridProps;
+        $flex?: import("@k8slens/element-components").SimpleFlexProp | import("@k8slens/element-components").MaximalFlexProps;
+        $gradient?: boolean;
+        $flexChild?: boolean | number | "shrinkable" | "fixed";
+        $area?: boolean;
+        $areaContent?: boolean;
+        $invisibleBackdrop?: boolean;
+    } & React.SVGProps<SVGSVGElement>>>;
+    settings: import("@k8slens/injectable").Injectable2<() => React.ComponentType>;
+    installationInstructions: import("@k8slens/injectable").Injectable2<() => React.ComponentType>;
+    instructionsFilename: import("@k8slens/injectable").Injectable2<() => string | undefined>;
+    installedSelectionRow: import("@k8slens/injectable").Injectable2<() => DropDownMenuItem<void>>;
+    notInstalledSelectionRow: import("@k8slens/injectable").Injectable2<() => DropDownMenuItem<void>>;
+    aiToolIsInstalledCliCommand?: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetAiToolIsInstalledCliCommand;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetAiToolIsInstalledCliCommand;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetAiToolIsInstalledCliCommand;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: GetAiToolIsInstalledCliCommand;
+        }>;
+    } | {
+        macos: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+        };
+        windows: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+        };
+        linux: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+        };
+        unitTesting: {
+            posix: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            fish: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            cmd: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+            powershell: import("@k8slens/injectable").Injectable2<() => {
+                shellFamily: import("@k8slens/public-utilities").ShellFamily;
+                value: GetAiToolIsInstalledCliCommand;
+            }>;
+        };
+    } | undefined;
+};
+//# sourceMappingURL=get-ai-tool-injectable-bunch.d.ts.map

package/dist/src/get-ai-tool-injectable-bunch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-ai-tool-injectable-bunch.d.ts","sourceRoot":"","sources":["../../src/get-ai-tool-injectable-bunch.ts"],"names":[],"mappings":"AACA,OAAO,EAAkC,KAAK,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAE1G,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EACV,UAAU,EAEV,aAAa,EACb,8BAA8B,EAC9B,uCAAuC,EACxC,MAAM,WAAW,CAAC;AACnB,OAAO,EAAgC,KAAK,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAQlH,OAAO,EAAmC,KAAK,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAWrG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,oCAAoC,CAAC,aAAa,CAAC,CAAC;IAC5E;;;;;;;OAOG;IACH,QAAQ,CAAC,mBAAmB,EAAE,oCAAoC,CAAC,aAAa,CAAC,CAAC;IAClF;;;;;;OAMG;IACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,oCAAoC,CAAC,8BAA8B,CAAC,CAAC;IAC/G;;;;OAIG;IACH,QAAQ,CAAC,uCAAuC,EAAE,oCAAoC,CAAC,uCAAuC,CAAC,CAAC;IAChI,4IAA4I;IAC5I,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,wFAAwF;IACxF,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IACpC,mSAAmS;IACnS,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC;IACnE,2GAA2G;IAC3G,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC9C,8GAA8G;IAC9G,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IACxC,wJAAwJ;IACxJ,QAAQ,CAAC,wBAAwB,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IACxD,mLAAmL;IACnL,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACxC;AAcD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,WAAY,iBAAiB;4DAgBrC,UAAU;iEAMV,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAgDN,KAAK,CAAC,aAAa;8EAMnB,KAAK,CAAC,aAAa;0EAMnB,MAAM,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8D9C,CAAC"}

package/dist/src/get-ai-tool-is-installed-cli-command.d.ts

@@ -0,0 +1,20 @@
+import type { ShellScoped } from "@k8slens/platform-specific-injectables";
+import type { AiToolKind, GetAiToolIsInstalledCliCommand } from "./ai-tool";
+/**
+ * Per-kind builder for the command that detects whether an AI tool is installed
+ * (e.g. `command -v claude` / `where claude`). Contributed per tool by
+ * `getAiToolInjectableBunch` (the host OS's variant when the tool's
+ * `getAiToolIsInstalledCliCommand` is operating-system specific). The detected
+ * tools list runs it via `aiToolInstalledViaCliCommandInjectionToken` (exit code
+ * 0 ⇒ installed). Not contributed for always-available tools (e.g. Custom),
+ * which are then reported as installed.
+ */
+export declare const getAiToolIsInstalledCliCommandInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => ShellScoped<GetAiToolIsInstalledCliCommand>, () => ShellScoped<GetAiToolIsInstalledCliCommand>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetAiToolIsInstalledCliCommand>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetAiToolIsInstalledCliCommand>>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<() => ShellScoped<GetAiToolIsInstalledCliCommand>, () => ShellScoped<GetAiToolIsInstalledCliCommand>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetAiToolIsInstalledCliCommand>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetAiToolIsInstalledCliCommand>>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=get-ai-tool-is-installed-cli-command.d.ts.map

package/dist/src/get-ai-tool-is-installed-cli-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-ai-tool-is-installed-cli-command.d.ts","sourceRoot":"","sources":["../../src/get-ai-tool-is-installed-cli-command.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,8BAA8B,EAAE,MAAM,WAAW,CAAC;AAE5E;;;;;;;;GAQG;AACH,eAAO,MAAM,4CAA4C,0DAClC,WAAW,CAAC,8BAA8B,CAAC;;gBAIxD,UAAU,6DAEK,WAAW,CAAC,8BAA8B,CAAC;;;;;CAOnE,CAAC"}

package/dist/src/get-open-tool-in-external-terminal-for-tool.d.ts

@@ -0,0 +1,17 @@
+import type { ShellScoped } from "@k8slens/platform-specific-injectables";
+import type { AiToolKind, GetOpenToolInExternalTerminalCliCommand } from "./ai-tool";
+/**
+ * Per-kind builder for the host command that opens an AI tool in a fresh external
+ * terminal window. Contributed per tool by `getAiToolInjectableBunch` (resolved
+ * to the host OS's variant from the tool's `getOpenToolInExternalTerminalCliCommand`
+ * param). Consumed via the derived `selectedAiToolOpenInExternalTerminalCommandInjectionToken`.
+ */
+export declare const getOpenToolInExternalTerminalForToolInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => ShellScoped<GetOpenToolInExternalTerminalCliCommand>, () => ShellScoped<GetOpenToolInExternalTerminalCliCommand>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetOpenToolInExternalTerminalCliCommand>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetOpenToolInExternalTerminalCliCommand>>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<() => ShellScoped<GetOpenToolInExternalTerminalCliCommand>, () => ShellScoped<GetOpenToolInExternalTerminalCliCommand>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetOpenToolInExternalTerminalCliCommand>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetOpenToolInExternalTerminalCliCommand>>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=get-open-tool-in-external-terminal-for-tool.d.ts.map

package/dist/src/get-open-tool-in-external-terminal-for-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-open-tool-in-external-terminal-for-tool.d.ts","sourceRoot":"","sources":["../../src/get-open-tool-in-external-terminal-for-tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,uCAAuC,EAAE,MAAM,WAAW,CAAC;AAErF;;;;;GAKG;AACH,eAAO,MAAM,kDAAkD,0DACxC,WAAW,CAAC,uCAAuC,CAAC;;gBAIjE,UAAU,6DAEK,WAAW,CAAC,uCAAuC,CAAC;;;;;CAO5E,CAAC"}

package/dist/src/get-resume-ai-command-for-terminal.d.ts

@@ -0,0 +1,23 @@
+import type { ShellScoped } from "@k8slens/platform-specific-injectables";
+import type { AiToolKind, GetCliCommand } from "./ai-tool";
+/**
+ * Per-kind builder for the command that *resumes* an AI tool in a terminal —
+ * run instead of {@link getAiCommandForTerminalInjectionToken} when the tab's
+ * session is re-established (e.g. after an app restart) rather than first
+ * opened, so the tool continues its previous session (e.g. `claude --continue
+ * || claude`, which falls back to a fresh launch when there is no session).
+ *
+ * Resolves to a {@link GetCliCommand} (the launch-command signature); resume
+ * builders typically ignore `prompt` (they continue the prior session rather
+ * than starting a new one). Every tool contributes one via `.for(kind)` — a tool
+ * with no dedicated resume invocation passes its launch command.
+ */
+export declare const getResumeAiCommandForTerminalInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => ShellScoped<GetCliCommand>, () => ShellScoped<GetCliCommand>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetCliCommand>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetCliCommand>>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<() => ShellScoped<GetCliCommand>, () => ShellScoped<GetCliCommand>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetCliCommand>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ShellScoped<GetCliCommand>>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=get-resume-ai-command-for-terminal.d.ts.map

package/dist/src/get-resume-ai-command-for-terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-resume-ai-command-for-terminal.d.ts","sourceRoot":"","sources":["../../src/get-resume-ai-command-for-terminal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2CAA2C,0DACjC,WAAW,CAAC,aAAa,CAAC;;gBAIvC,UAAU,6DAEK,WAAW,CAAC,aAAa,CAAC;;;;;CAOlD,CAAC"}

package/dist/src/operating-system-specific.d.ts

@@ -0,0 +1,16 @@
+/** A value provided separately for each supported operating system. */
+export interface OperatingSystemSpecific<T> {
+    readonly macos: T;
+    readonly windows: T;
+    readonly linux: T;
+}
+/**
+ * A value that is either OS-agnostic (the value itself) or operating-system
+ * specific (an {@link OperatingSystemSpecific} object). Used for the AI-tool CLI
+ * commands on `AiToolBunchParams`, each of which may differ per OS or not.
+ *
+ * `T` is expected to be a function, so that the agnostic form is the function
+ * itself and a consumer can discriminate the two via `typeof`.
+ */
+export type MaybeOperatingSystemSpecific<T> = T | OperatingSystemSpecific<T>;
+//# sourceMappingURL=operating-system-specific.d.ts.map

package/dist/src/operating-system-specific.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operating-system-specific.d.ts","sourceRoot":"","sources":["../../src/operating-system-specific.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,CAAC,CAAC,IAAI,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,CAAC"}