@k8slens/ai-tools-contracts 1.0.0

package/dist/src/ai-tool-instructions-filename.d.ts

@@ -0,0 +1,20 @@
+import type { AiToolKind } from "./ai-tool";
+/** Resolves the instructions filename a given AI tool kind reads from its working directory. */
+export type AiToolInstructionsFilename = () => string | undefined;
+/**
+ * Per-kind instructions filename — the file the tool auto-discovers in its
+ * working directory (e.g. `"CLAUDE.md"` for Claude Code, `"GEMINI.md"` for
+ * Gemini CLI). The launcher always writes the canonical
+ * {@link agentsInstructionsFilename}; when a kind declares a different filename
+ * the launcher additionally writes that file as an indirection importing the
+ * canonical one. `undefined` for kinds that read no such file.
+ */
+export declare const aiToolInstructionsFilenameInjectionToken: import("@k8slens/injectable").InjectionToken2Base<AiToolInstructionsFilename, () => (string | undefined)[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<string | undefined>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<string | undefined>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<AiToolInstructionsFilename, () => (string | undefined)[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<string | undefined>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<string | undefined>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=ai-tool-instructions-filename.d.ts.map

package/dist/src/ai-tool-instructions-filename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-instructions-filename.d.ts","sourceRoot":"","sources":["../../src/ai-tool-instructions-filename.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,gGAAgG;AAChG,MAAM,MAAM,0BAA0B,GAAG,MAAM,MAAM,GAAG,SAAS,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,wCAAwC;;gBAK3C,UAAU;;;;;CAMnB,CAAC"}

package/dist/src/ai-tool-instructions-filenames.d.ts

@@ -0,0 +1,13 @@
+/** Resolves the indirection instructions filenames to write across all registered AI tools. */
+export type AiToolInstructionsIndirectionFilenames = () => readonly string[];
+/**
+ * The distinct tool-specific instructions filenames across **all** registered AI
+ * tool kinds — regardless of installation state — excluding the canonical
+ * {@link agentsInstructionsFilename}. A launcher writes the canonical
+ * `AGENTS.md` plus each of these as an indirection importing it, so whichever
+ * tool the user later picks finds its instructions in the working directory.
+ */
+export declare const aiToolInstructionsIndirectionFilenamesInjectionToken: import("@k8slens/injectable").InjectionToken2Base<AiToolInstructionsIndirectionFilenames, () => (readonly string[])[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<readonly string[]>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<readonly string[]>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=ai-tool-instructions-filenames.d.ts.map

package/dist/src/ai-tool-instructions-filenames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-instructions-filenames.d.ts","sourceRoot":"","sources":["../../src/ai-tool-instructions-filenames.ts"],"names":[],"mappings":"AAEA,+FAA+F;AAC/F,MAAM,MAAM,sCAAsC,GAAG,MAAM,SAAS,MAAM,EAAE,CAAC;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,oDAAoD;;CAK7D,CAAC"}

package/dist/src/ai-tool-is-configured.d.ts

@@ -0,0 +1,17 @@
+import type { IComputedValue } from "mobx";
+/**
+ * Whether a real AI tool is configured — i.e. the effective AI tool kind is a real
+ * tool (or Custom), not {@link noAiToolKind}. Derived purely from the user's
+ * selection, NOT from install detection: observing the configured state must not
+ * depend on the async PATH scan having run first.
+ *
+ * A promise that resolves once the persisted selection has loaded (then a reactive
+ * boolean), so consumers reflect a genuine *pending* state while it loads instead
+ * of guessing `false`. React surfaces read it via `useInject(...)` under
+ * `<Suspense>` (or bridge it with `asReactive`); the launch handlers `await` it.
+ * The Ask-AI launch surfaces gate their visibility on it.
+ */
+export declare const aiToolIsConfiguredInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => Promise<IComputedValue<boolean>>, () => Promise<IComputedValue<boolean>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<boolean>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<boolean>>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=ai-tool-is-configured.d.ts.map

package/dist/src/ai-tool-is-configured.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-is-configured.d.ts","sourceRoot":"","sources":["../../src/ai-tool-is-configured.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,0DACtB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;;CAInD,CAAC"}

package/dist/src/ai-tool-name.d.ts

@@ -0,0 +1,17 @@
+import type React from "react";
+import type { AiToolKind } from "./ai-tool";
+/** Resolves the display-name component for a given AI tool kind. */
+export type AiToolName = () => React.ComponentType;
+/**
+ * Per-kind display name for an AI tool — a React component (not a string), so
+ * a tool can render branding/markup. Contribute one per tool kind.
+ */
+export declare const aiToolNameInjectionToken: import("@k8slens/injectable").InjectionToken2Base<AiToolName, () => React.ComponentType<{}>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<AiToolName, () => React.ComponentType<{}>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=ai-tool-name.d.ts.map

package/dist/src/ai-tool-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-name.d.ts","sourceRoot":"","sources":["../../src/ai-tool-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,oEAAoE;AACpE,MAAM,MAAM,UAAU,GAAG,MAAM,KAAK,CAAC,aAAa,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;gBAG3B,UAAU;;;;;CAMnB,CAAC"}

package/dist/src/ai-tool-order-number.d.ts

@@ -0,0 +1,16 @@
+import type { AiToolKind } from "./ai-tool";
+/** Resolves the order/priority number for a given AI tool kind. */
+export type AiToolOrderNumber = () => number;
+/**
+ * Per-kind ordering/priority for an AI tool. Lower comes first in the selector;
+ * the lowest-numbered *installed* tool is the default selection.
+ */
+export declare const aiToolOrderNumberInjectionToken: import("@k8slens/injectable").InjectionToken2Base<AiToolOrderNumber, () => number[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<number>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<number>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<AiToolOrderNumber, () => number[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<number>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<number>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=ai-tool-order-number.d.ts.map

package/dist/src/ai-tool-order-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-order-number.d.ts","sourceRoot":"","sources":["../../src/ai-tool-order-number.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,MAAM,MAAM,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,+BAA+B;;gBAGlC,UAAU;;;;;CAMnB,CAAC"}

package/dist/src/ai-tool-selection-row.d.ts

@@ -0,0 +1,18 @@
+import type React from "react";
+import type { AiToolKind } from "./ai-tool";
+export interface AiToolSelectionRowProps {
+    /** The tool the row represents. */
+    readonly kind: AiToolKind;
+}
+/**
+ * One AI tool's row in the top bar menu's selection section: how the row looks and what
+ * clicking it does (selecting an installed tool, guiding the installation of a missing
+ * one). Registered against the menu automatically, per tool, by
+ * {@link getAiToolInjectableBunch}; the feature owning the AI tool button provides the
+ * implementation, so this generic package stays free of its telemetry and entitlement
+ * concerns.
+ */
+export declare const AiToolSelectionRow: React.FunctionComponent<AiToolSelectionRowProps> & import("@k8slens/injectable").InjectionToken2Base<() => React.FunctionComponent<AiToolSelectionRowProps>, () => React.FunctionComponent<AiToolSelectionRowProps>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.FunctionComponent<AiToolSelectionRowProps>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.FunctionComponent<AiToolSelectionRowProps>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=ai-tool-selection-row.d.ts.map

package/dist/src/ai-tool-selection-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-selection-row.d.ts","sourceRoot":"","sources":["../../src/ai-tool-selection-row.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,WAAW,uBAAuB;IACtC,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;CAE3B,CAAC"}

package/dist/src/ai-tool-settings.d.ts

@@ -0,0 +1,18 @@
+import type React from "react";
+import type { AiToolKind } from "./ai-tool";
+/** Resolves a kind's settings component, shown below the selector when that kind is selected. */
+export type AiToolSettings = () => React.ComponentType;
+/**
+ * Per-kind settings UI, rendered beneath the AI-tool selector when that kind is
+ * the active selection. Optional — most tools need none; e.g. the "custom" kind
+ * contributes a command input + a run-externally toggle. A React component.
+ */
+export declare const aiToolSettingsInjectionToken: import("@k8slens/injectable").InjectionToken2Base<AiToolSettings, () => React.ComponentType<{}>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>[]> & {
+    readonly __abstract: true;
+    for: (kind: AiToolKind) => import("@k8slens/injectable").InjectionToken2Base<AiToolSettings, () => React.ComponentType<{}>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<{}>>[]> & {
+        readonly __abstract?: never;
+    } & {
+        speciality: any;
+    };
+};
+//# sourceMappingURL=ai-tool-settings.d.ts.map

package/dist/src/ai-tool-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-settings.d.ts","sourceRoot":"","sources":["../../src/ai-tool-settings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,iGAAiG;AACjG,MAAM,MAAM,cAAc,GAAG,MAAM,KAAK,CAAC,aAAa,CAAC;AAEvD;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;gBAG/B,UAAU;;;;;CAMnB,CAAC"}

package/dist/src/ai-tool-top-bar-menu.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The drop-down menu of the top bar's AI tool button. The AI tool selection rows are
+ * contributed automatically, one per registered tool, by `getAiToolInjectableBunch` of
+ * `@k8slens/ai-tools-contracts`; anyone else contributes their own items with
+ * `getDropDownMenuItemInjectableBunch` of `@k8slens/drop-down-menu-contracts` against
+ * this kind, placed with {@link aiToolTopBarMenuOrderNumbers}.
+ *
+ * @example
+ * ```tsx
+ * export default getDropDownMenuItemInjectableBunch({
+ *   id: "my-ai-menu-item",
+ *   kind: aiToolTopBarMenuKind,
+ *   orderNumber: aiToolTopBarMenuOrderNumbers.sectionEnd + 100,
+ *   Component: MyMenuItem,
+ * });
+ * ```
+ */
+export declare const aiToolTopBarMenuKind: import("@k8slens/injectable").TypedSpecifier<"ai-tool-top-bar-menu", {
+    dropDownMenuData: void;
+}>;
+/**
+ * Where the AI tool selection section's own items sit in the button's menu, as the
+ * boundaries they are laid out against. The selection rows occupy two bands, each
+ * `bandWidth` wide, so that every installed tool comes before every not-yet-installed
+ * one while each band stays sorted by the tools' own order numbers.
+ *
+ * A contributor places itself relative to these rather than against a guessed number.
+ * The section ends at {@link sectionEnd}: items contributed after it pick their order
+ * numbers from there up, framing their own sections with separators they contribute
+ * themselves.
+ */
+export declare const aiToolTopBarMenuOrderNumbers: {
+    /** The heading above the selection rows. */
+    readonly aiToolsHeader: 100;
+    /** The scanning indicator shown while the first detection has not settled. */
+    readonly detectionPending: 200;
+    /** The first order number of the band holding the rows of installed tools. */
+    readonly installedAiToolBand: 300;
+    /** The first order number of the band holding the rows of not-installed tools. */
+    readonly notInstalledAiToolBand: 400;
+    /** How wide each selection band is, and so how far a tool's own number may reach. */
+    readonly bandWidth: 100;
+    /** The first order number past the whole selection section. */
+    readonly sectionEnd: 500;
+};
+//# sourceMappingURL=ai-tool-top-bar-menu.d.ts.map

package/dist/src/ai-tool-top-bar-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool-top-bar-menu.d.ts","sourceRoot":"","sources":["../../src/ai-tool-top-bar-menu.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB;;EAAgD,CAAC;AAElF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B;IACvC,4CAA4C;aAC5C,aAAa,EAAE,GAAG;IAClB,8EAA8E;aAC9E,gBAAgB,EAAE,GAAG;IACrB,8EAA8E;aAC9E,mBAAmB,EAAE,GAAG;IACxB,kFAAkF;aAClF,sBAAsB,EAAE,GAAG;IAC3B,qFAAqF;aACrF,SAAS,EAAE,GAAG;IACd,+DAA+D;aAC/D,UAAU,EAAE,GAAG;CACP,CAAC"}

package/dist/src/ai-tool.d.ts

@@ -0,0 +1,64 @@
+import type { ConsumptionDi, DiContainerForInjection } from "@k8slens/injectable";
+/** Identifier for a kind of AI CLI tool, e.g. `"claude"`. */
+export type AiToolKind = string;
+/** The pseudo-kind for the user's free-text "Custom" command. */
+export declare const customAiToolKind: AiToolKind;
+/**
+ * The pseudo-kind for "No AI tool" — the explicit opt-out, and the default/fallback
+ * effective kind. It is not a registered tool: when it is the effective selection,
+ * Lens launches nothing and the AI surfaces hide (the top-bar button becomes
+ * "Configure AI"). The effective kind resolves to this whenever the selection is
+ * unset, set to this sentinel, or set to a tool that is not installed.
+ */
+export declare const noAiToolKind: AiToolKind;
+/**
+ * The canonical agent-instructions filename, written into every AI tool tab's
+ * working directory. Tools that read a differently-named file (see
+ * {@link AiToolInstructionsFilename}) get that file too, as an indirection
+ * importing this one.
+ */
+export declare const agentsInstructionsFilename = "AGENTS.md";
+/**
+ * The contents of a tool-specific instructions file (e.g. `CLAUDE.md`): a single
+ * line importing the canonical {@link agentsInstructionsFilename}, so a tool that
+ * reads its own filename still picks up the instructions written there.
+ */
+export declare const agentsInstructionsIndirectionContents = "@AGENTS.md\n";
+/**
+ * Builds the shell command that launches an AI CLI tool in a terminal. An async
+ * callback receiving the DI container, so a tool can inject (and await) whatever
+ * it needs while assembling its command. `dir` is the working directory the
+ * command runs in; the launcher has already written the cluster context there as
+ * `AGENTS.md` (plus per-tool indirection files), so tools discover it from cwd.
+ */
+export type GetCliCommand = (di: DiContainerForInjection, args: {
+    prompt?: string;
+    dir: string;
+}) => Promise<string>;
+/**
+ * Builds the host command that checks whether an AI tool is installed (e.g.
+ * `command -v claude` / `where claude`). The command is run on the host and an
+ * exit code of `0` means installed. Given the DI container, returns the command
+ * string. Omit (on `AiToolBunchParams`) for an always-available tool.
+ */
+export type GetAiToolIsInstalledCliCommand = (di: ConsumptionDi) => string;
+/**
+ * Builds the full host command that opens an AI tool in a fresh external terminal
+ * window — typically by wrapping the tool's own invocation with one of the
+ * `build{Mac,Windows,Linux}ExternalTerminalCommand` helpers. Mirrors
+ * {@link GetCliCommand}'s args (so it can reuse the tool's launch command),
+ * plus `env` (e.g. `{ KUBECONFIG }`) which is baked into the command because the
+ * freshly-opened terminal does not inherit the launcher's environment. Returns
+ * `""` when the tool has no command to run (e.g. an empty Custom template).
+ */
+export type GetOpenToolInExternalTerminalCliCommand = (di: DiContainerForInjection, args: {
+    prompt?: string;
+    dir: string;
+    env?: Record<string, string>;
+}) => Promise<string>;
+/** An AI tool kind together with its detected installation state. */
+export interface AiToolListEntry {
+    readonly kind: AiToolKind;
+    readonly isInstalled: boolean;
+}
+//# sourceMappingURL=ai-tool.d.ts.map

package/dist/src/ai-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tool.d.ts","sourceRoot":"","sources":["../../src/ai-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAElF,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,iEAAiE;AACjE,eAAO,MAAM,gBAAgB,EAAE,UAAqB,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,UAAmB,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,cAAc,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,iBAAqC,CAAC;AAExF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,EAAE,EAAE,uBAAuB,EAAE,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAErH;;;;;GAKG;AAIH,MAAM,MAAM,8BAA8B,GAAG,CAAC,EAAE,EAAE,aAAa,KAAK,MAAM,CAAC;AAE3E;;;;;;;;GAQG;AACH,MAAM,MAAM,uCAAuC,GAAG,CACpD,EAAE,EAAE,uBAAuB,EAC3B,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,KACjE,OAAO,CAAC,MAAM,CAAC,CAAC;AAErB,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B"}

package/dist/src/ai-tools-injection-token.d.ts

@@ -0,0 +1,12 @@
+import type { IComputedValue } from "mobx";
+import type { AiToolListEntry } from "./ai-tool";
+/** Resolves the reactive list of all contributed AI tools with install state. */
+export type AiTools = () => Promise<IComputedValue<AiToolListEntry[]>>;
+/**
+ * All contributed AI tool kinds together with their detected installation
+ * state, sorted by order number. Consumed by the preferences selector.
+ */
+export declare const aiToolsInjectionToken: import("@k8slens/injectable").InjectionToken2Base<AiTools, () => Promise<IComputedValue<AiToolListEntry[]>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<AiToolListEntry[]>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<AiToolListEntry[]>>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=ai-tools-injection-token.d.ts.map

package/dist/src/ai-tools-injection-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tools-injection-token.d.ts","sourceRoot":"","sources":["../../src/ai-tools-injection-token.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,iFAAiF;AACjF,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;CAG9B,CAAC"}

package/dist/src/ai-tools-open-externally.d.ts

@@ -0,0 +1,17 @@
+import type { IObservableValue } from "mobx";
+/**
+ * The global "open AI tools in an external terminal" toggle. When `true`, the
+ * selected AI tool launches in a fresh external terminal window — built by the
+ * host operating system's external-terminal command builder (resolved via
+ * `selectedAiToolExternalTerminalCommandInjectionToken`) and spawned detached on
+ * the host — instead of a Lens terminal tab. Applies to every tool (Custom
+ * included), replacing the former per-tool runs-externally callbacks.
+ *
+ * Persisted; the box loads asynchronously, so the token resolves to a promise
+ * of the observable. Supported on macOS (Terminal), Windows (Windows Terminal), and
+ * Linux (the first available terminal emulator).
+ */
+export declare const aiToolsOpenExternallyInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => Promise<IObservableValue<boolean>>, () => Promise<IObservableValue<boolean>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IObservableValue<boolean>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IObservableValue<boolean>>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=ai-tools-open-externally.d.ts.map

package/dist/src/ai-tools-open-externally.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tools-open-externally.d.ts","sourceRoot":"","sources":["../../src/ai-tools-open-externally.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mCAAmC,0DACzB,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;;CAIrD,CAAC"}

package/dist/src/build-external-terminal-command.d.ts

@@ -0,0 +1,33 @@
+export interface ExternalTerminalCommandOptions {
+    /**
+     * The resolved inner command to run, inserted **raw** (it is a full command
+     * line, not an argument).
+     */
+    readonly command: string;
+    /** The working directory the command runs in. Builders quote it, so a path with spaces is safe. */
+    readonly dir: string;
+    /**
+     * Per-launch environment to apply. A freshly-opened external terminal runs its
+     * own shell that does not inherit the launcher's env, so a builder has to carry
+     * these into the launched command itself rather than relying on the ambient
+     * environment. Realistically small (e.g. just `KUBECONFIG`).
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * The user-configured shell (the same "Shell Path" the in-app terminal uses), so
+     * the external terminal runs the command in — and drops the user into — that
+     * shell rather than the OS/terminal default.
+     */
+    readonly shell: string;
+}
+/** Builds the full host command that opens `command` in a fresh external terminal window for one OS. */
+export type ExternalTerminalCommandBuilder = (options: ExternalTerminalCommandOptions) => string;
+/**
+ * The host OS's {@link ExternalTerminalCommandBuilder}. Registered per-OS via
+ * `getInjectableForOperatingSystems` (host-only `*-only` tags), so injecting the
+ * token yields the builder for the current OS — no runtime platform switch.
+ */
+export declare const externalTerminalCommandBuilderInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => ExternalTerminalCommandBuilder, () => ExternalTerminalCommandBuilder[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<ExternalTerminalCommandBuilder>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<ExternalTerminalCommandBuilder>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=build-external-terminal-command.d.ts.map

package/dist/src/build-external-terminal-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-external-terminal-command.d.ts","sourceRoot":"","sources":["../../src/build-external-terminal-command.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mGAAmG;IACnG,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,wGAAwG;AACxG,MAAM,MAAM,8BAA8B,GAAG,CAAC,OAAO,EAAE,8BAA8B,KAAK,MAAM,CAAC;AAEjG;;;;GAIG;AACH,eAAO,MAAM,4CAA4C,0DAClC,8BAA8B;;CAIjD,CAAC"}

package/dist/src/current-shell-family.d.ts

@@ -0,0 +1,13 @@
+import type { IComputedValue } from "mobx";
+import type { ShellFamily } from "@k8slens/public-utilities";
+/**
+ * Reactive lookup of the active shell *family* (`posix`/`fish`/`cmd`/`powershell`),
+ * derived from the user-configured shell. Consumers of the per-kind AI command
+ * tokens (which register one {@link import("@k8slens/public-utilities").ShellScoped} cell
+ * per family) use this to pick the active shell's command at runtime via
+ * `resolveForShell(injectMany(token.for(kind))(), currentShellFamily.get())`.
+ */
+export declare const currentShellFamilyInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => IComputedValue<ShellFamily>, () => IComputedValue<ShellFamily>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<ShellFamily>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<ShellFamily>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=current-shell-family.d.ts.map

package/dist/src/current-shell-family.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-shell-family.d.ts","sourceRoot":"","sources":["../../src/current-shell-family.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,0DACtB,cAAc,CAAC,WAAW,CAAC;;CAI9C,CAAC"}

package/dist/src/default-ai-tool-icon.d.ts

@@ -0,0 +1,8 @@
+import { type SvgProps } from "@k8slens/element-components";
+/**
+ * Generic fallback icon for an AI tool that contributes no `Icon` of its own (a
+ * terminal glyph). The bunch factory falls back to this so the effective-icon
+ * token never resolves to `undefined`.
+ */
+export declare const DefaultAiToolIcon: (props: SvgProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=default-ai-tool-icon.d.ts.map

package/dist/src/default-ai-tool-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-ai-tool-icon.d.ts","sourceRoot":"","sources":["../../src/default-ai-tool-icon.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAO,MAAM,6BAA6B,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,UAAW,QAAQ,4CAIhD,CAAC"}

package/dist/src/detected-ai-tools.d.ts

@@ -0,0 +1,15 @@
+import type { IComputedValue } from "mobx";
+import type { AiToolListEntry } from "./ai-tool";
+/** Resolves the synchronously readable detected-tools list. */
+export type DetectedAiTools = () => IComputedValue<AiToolListEntry[]>;
+/**
+ * The AI tools with their detected install state, as a synchronously readable reactive
+ * list — the same state `aiToolsInjectionToken` exposes behind a promise, for consumers
+ * that need sync reactivity (e.g. the `isVisible` computeds of menu items). Empty until
+ * the first explicit scan (`refreshAiToolDetectionInjectionToken`) has run; a kind
+ * missing from the list has not been scanned yet.
+ */
+export declare const detectedAiToolsInjectionToken: import("@k8slens/injectable").InjectionToken2Base<DetectedAiTools, () => IComputedValue<AiToolListEntry[]>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<AiToolListEntry[]>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<AiToolListEntry[]>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=detected-ai-tools.d.ts.map

package/dist/src/detected-ai-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detected-ai-tools.d.ts","sourceRoot":"","sources":["../../src/detected-ai-tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,+DAA+D;AAC/D,MAAM,MAAM,eAAe,GAAG,MAAM,cAAc,CAAC,eAAe,EAAE,CAAC,CAAC;AAEtE;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;CAGtC,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { ShellScoped } from "@k8slens/platform-specific-injectables";
+import type { AiToolKind, GetCliCommand } from "./ai-tool";
+/**
+ * Per-kind builder for the command that launches an AI tool in a terminal.
+ * Contribute one per tool kind via `.for(kind)`. Registered (by the bunch factory)
+ * as one {@link ShellScoped} cell per shell family; consumers pick the active
+ * shell's at runtime with `resolveForShell(injectMany(token.for(kind))(), family)`.
+ */
+export declare const getAiCommandForTerminalInjectionToken: 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-ai-command-for-terminal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-ai-command-for-terminal.d.ts","sourceRoot":"","sources":["../../src/get-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;;;;;GAKG;AACH,eAAO,MAAM,qCAAqC,0DAC3B,WAAW,CAAC,aAAa,CAAC;;gBAIvC,UAAU,6DAEK,WAAW,CAAC,aAAa,CAAC;;;;;CAOlD,CAAC"}