jupyterlab_ai_code_assistants_extension 0.6.15

package/lib/core/panel.d.ts

@@ -0,0 +1,233 @@
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
+import { ITerminalTracker } from '@jupyterlab/terminal';
+import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
+import { Message } from '@lumino/messaging';
+import { Widget } from '@lumino/widgets';
+import { IProviderDescriptor, IProviderHooks } from './types';
+export type PresentationMode = 'name' | 'path';
+/** Widget id for one provider's panel - what the layout restorer keys on. */
+export declare function panelWidgetId(providerId: string): string;
+/** Command id for one provider's action. Namespaced per provider, so two
+ * panels never collide in a shared registry. */
+export declare function commandId(providerId: string, action: string): string;
+/**
+ * One assistant's sessions panel.
+ *
+ * Layout, filtering, polling, menus, the popup and the launch flow are shared
+ * by every provider. Everything that differs enters through the descriptor's
+ * capability flags or through the provider's hooks - this class never asks
+ * which assistant it is rendering.
+ */
+export declare class AssistantSessionsPanel extends Widget {
+    constructor(options: AssistantSessionsPanel.IOptions);
+    get descriptor(): IProviderDescriptor;
+    dispose(): void;
+    refresh(): void;
+    /** Label rows by name (the session name the assistant records) or by path. */
+    setPresentationMode(mode: PresentationMode): void;
+    /** How many rows the Recent section displays. */
+    setRecentLimit(n: number): void;
+    /** Current values of this provider's launch modes, read from settings. Each
+     * key is an `ILaunchMode.id` in the assistant's own terminology. */
+    setModes(modes: Record<string, boolean | string>): void;
+    setColouredTabs(on: boolean): void;
+    protected onAfterShow(_msg: Message): void;
+    protected onBeforeHide(_msg: Message): void;
+    protected onCloseRequest(msg: Message): void;
+    private _buildShell;
+    /** Show / hide the filter input. Hiding also clears the active filter, so
+     * the user never returns to an "invisible" filter narrowing the rows. */
+    private _toggleFilterBar;
+    /** Show the clear button only while the field has text - an "x" over an
+     * empty box is noise, and there is nothing to clear. */
+    private _syncSearchClear;
+    /** Normalise for filter comparison: NFD-decompose, strip combining marks,
+     * lowercase, and collapse separators entirely - so "foo-bar", "foo_bar",
+     * "foo bar" and "Foo Bar" all compare equal as "foobar". */
+    private _normalize;
+    /** Fuzzy match at a 95% threshold: substring on normalised strings, with up
+     * to 5% Levenshtein tolerance. For short queries the budget rounds to zero,
+     * so behaviour is substring-only there; the relaxation only reaches a full
+     * edit at 10+ characters. */
+    private _fuzzyMatch;
+    private _levenshtein;
+    private _matchesFilter;
+    /** Raise or clear the full-panel refresh veil. Only the explicit refresh
+     * path calls this; the background poll fetches silently so the panel never
+     * flashes a spinner on its own. */
+    private _setLoading;
+    /** Inline, per-panel error. One provider's unreachable server must leave the
+     * other panels alone, so nothing here is modal. */
+    private _setInlineError;
+    private _showError;
+    /** A one-shot action failed. Nothing retries it, so the copy names what did
+     * not happen instead of promising a retry the poll loop alone performs. */
+    private _showActionError;
+    private _logError;
+    private _fetch;
+    private _toggleFavourite;
+    private get _disposalVerb();
+    private _removeProject;
+    private _cleanupParallel;
+    /** This provider's launch-mode token for one action - see
+     * `resolveLaunchMode` for the precedence rule. */
+    private _launchMode;
+    private _openSession;
+    /** Absolute path of the file browser's current folder; the server root when
+     * no file browser is available. */
+    private _currentFolder;
+    /** Start a brand-new conversation in the file browser's current folder. */
+    private _newSession;
+    /**
+     * Branch the active row's current conversation, by the descriptor's
+     * `forkStrategy`.
+     *
+     * The three strategies differ only in who mints the new id and when it
+     * becomes knowable - so the shared part (ask for a name, launch a terminal
+     * on the fork, inherit the parent's tint, surface the branch) lives here
+     * once, and the strategy decides the payload and the discovery.
+     */
+    private _branchSession;
+    /** The CLI forks from a flag pair and takes the new id from us, so the fork
+     * is known before it exists. Its store entry is written lazily, on the first
+     * turn, so the branch is watched for rather than expected at once. */
+    private _branchByNativeFlag;
+    /** The CLI owns both the fork verb and the id, so the id has to be
+     * discovered: snapshot the branch ids first, then diff after launch. */
+    private _branchByNativeCommand;
+    /** The assistant has no fork at all: the server copies the store entry and
+     * answers with the new id, so the branch exists before the terminal opens
+     * and one refresh surfaces it - no watcher needed. */
+    private _branchByServerCopy;
+    /** Copy the parent's tint onto a fresh branch, unless the assistant owns
+     * conversation colours itself: that store refuses every write (the server
+     * answers 400), so the call would be one guaranteed-failing request per fork
+     * plus a tint that shows until the next reconcile drops it again. */
+    private _inheritColour;
+    /** Poll fast for a fork whose id we already know, then refresh once. The
+     * panel is never updated before the branch genuinely exists - it cannot list
+     * a store entry that has not been written. */
+    private _watchForBranch;
+    /** Poll fast for a fork whose id the CLI minted: whichever conversation the
+     * snapshot did not hold is the fork. It is then pinned as current (recency
+     * alone would not - the actively written parent overtakes it) and inherits
+     * the parent's tint. */
+    private _watchForNewBranch;
+    /** Make another conversation the row's current one. */
+    private _switchBranch;
+    /** Delete conversations of the active row's project. Resolves with the
+     * removed count, or null on a failure already reported to the user. */
+    private _deleteBranches;
+    private _fetchBranches;
+    /** Apply the presentation-mode setting. Basename collisions in name mode are
+     * resolved separately in `_disambiguate`. */
+    private _displayName;
+    private _basename;
+    /** Walk path tails until every name in a colliding group is unique. Name-mode
+     * labels are folder basenames, so two different projects can carry the same
+     * label; each colliding label is extended with as much of its parent path as
+     * it takes to tell them apart. */
+    private _disambiguate;
+    private _render;
+    private _renderSection;
+    private _renderRow;
+    /** Leading status dot, or a placeholder that reserves its column. Which
+     * states exist is a descriptor question, never an assistant question. */
+    private _renderIndicator;
+    private _lookupName;
+    private _buildRowTooltip;
+    private _displayPath;
+    /** Path relative to the JupyterLab server root (`''` for the root itself),
+     * or null when the folder lies outside it - in which case the file browser
+     * has no way to address it. */
+    private _pathUnderRoot;
+    private _formatRelativeTime;
+    /** Local `YYYY-MM-DD HH:MM` - the absolute reference the relative label
+     * cannot give. */
+    private _formatAbsoluteTime;
+    /** Branch entry display: conversation name plus short session id. Branches
+     * share a project path, so the name and id are all that tell them apart. The
+     * suffix is dropped when the label already IS the short id. */
+    private _branchDisplayName;
+    /** Menu-item label for a branch: display name, relative time, and a trailing
+     * marker when a live worker owns the conversation. The marker lives in the
+     * label rather than the icon, because both branch submenus need their icon
+     * slot for their own intent, and words are what assistive tech reads. */
+    private _branchMenuLabel;
+    private _setRefreshSpinning;
+    private _setActiveRow;
+    private _cmd;
+    /** Boolean launch modes that produce a menu variant - the assistant's own
+     * skip-approval switch, under the assistant's own name. */
+    private get _variantModes();
+    private _setupCommands;
+    private _buildMenus;
+    private _menu;
+    /** Rebuild the context menu's items. Lumino submenu items have no
+     * `isVisible` hook, so the menu is rebuilt per open and a branch submenu is
+     * inserted only when the row actually has branches - a capability the
+     * provider lacks is absent, not shown and disabled. */
+    private _rebuildContextMenu;
+    /** Open the row context menu, populating the branch submenus first when the
+     * project holds more than one conversation. A fetch failure opens the menu
+     * without them rather than not at all. */
+    private _openContextMenu;
+    private _openManagePopup;
+    /** The live-worker chip for a branch row, when the provider has workers at
+     * all. Returning null lets the popup fall back to its fork marker. */
+    private _bgBadgeFor;
+    private _startPolling;
+    private _stopPolling;
+    private readonly _app;
+    private readonly _descriptor;
+    private readonly _hooks;
+    private readonly _serverSettings;
+    private readonly _rootDir;
+    private readonly _deleteToTrash;
+    private readonly _fileBrowser;
+    private readonly _colours;
+    private readonly _terminals;
+    private readonly _expandedKey;
+    private readonly _removingPaths;
+    private _bodyEl;
+    private _loadingEl;
+    private _errorEl;
+    private _refreshBtn;
+    private _filterBtn;
+    private _searchEl;
+    private _searchWrapEl;
+    private _searchClearEl;
+    private _sessions;
+    private _expanded;
+    private _commands;
+    private _contextMenu;
+    private _switchSubmenu;
+    private _openBranchSubmenu;
+    private _branchSessionMenu;
+    private _newSessionMenu;
+    private _lastBranches;
+    private _lastBranchesCurrent;
+    private _activeSession;
+    private _activeRowEl;
+    private _pollHandle;
+    private _presentationMode;
+    private _recentLimit;
+    private _modes;
+    private _displayNames;
+    private _filter;
+}
+export declare namespace AssistantSessionsPanel {
+    interface IOptions {
+        app: JupyterFrontEnd;
+        descriptor: IProviderDescriptor;
+        hooks?: IProviderHooks;
+        /** JupyterLab's server root, for path display and file-browser hand-offs. */
+        rootDir: string;
+        /** JupyterLab's move-to-trash setting, so dialogs name the right outcome. */
+        deleteToTrash?: boolean;
+        terminalTracker?: ITerminalTracker | null;
+        fileBrowser?: IDefaultFileBrowser | null;
+        colourfulTabs?: IColourfulTabs | null;
+    }
+}