jupyterlab_ai_code_assistants_extension 1.2.56 → 1.2.71

package/README.md

@@ -30,6 +30,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload, and a change reaches the other JupyterLab windows of the same browser
 - **Three-section side panel** - Favorites, Recent, and All projects, each scrolling independently
 - **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated. Exception: a Codex or Kimi conversation started with `+`, and a Codex fork, run without an id until the CLI writes one, so a click on that row meanwhile opens a second terminal
+- **File browser follows the opened session** - opening a session moves the JupyterLab file browser to that session's project folder (a setting, on by default); a right-click on a panel header toggles this and moves the panels between the left and right sidebars
 - **Launcher tiles** - every enabled assistant has a tile in an "AI Assistants" section of the JupyterLab Launcher (after Other, under the extension's own robot-head icon); a click opens the assistant in the file browser's current folder, resuming the folder's conversation when one exists and starting a new one otherwise, through the companion `jupyterlab_basic_terminal_extension` (installed automatically). Disable an assistant and its tile goes; disable them all and the section goes with them
 - **Your terminal's `claude -c` follows the panel** (Claude) - switching to a conversation makes plain `claude -c` in that project resume that same conversation, including one that has been compacted, which Claude Code otherwise refuses to continue. Launching repairs a compacted conversation the same way, but only switching moves what `claude -c` picks
 - **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id with last-activity time; "Manage Sessions..." opens a searchable popup over the full list with multi-select delete and per-row open and copy-id buttons

package/lib/core/panel.d.ts

@@ -13,6 +13,11 @@ 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;
+/** Command ids of the two items in a panel header's context menu. The plugin
+ * registers them once, on the application registry, because the settings they
+ * write are shared by every panel. */
+export declare const SYNC_FILE_BROWSER_COMMAND = "ai-code-assistants:toggle-file-browser-sync";
+export declare const MOVE_PANELS_COMMAND = "ai-code-assistants:move-panels";
 /**
  * One assistant's sessions panel.
  *
@@ -34,6 +39,8 @@ export declare class AssistantSessionsPanel extends Widget {
      * key is an `ILaunchMode.id` in the assistant's own terminology. */
     setModes(modes: Record<string, boolean | string>): void;
     setColouredTabs(on: boolean): void;
+    /** Whether opening a session moves the file browser to its project folder. */
+    setSyncFileBrowser(on: boolean): void;
     protected onAfterShow(_msg: Message): void;
     protected onBeforeHide(_msg: Message): void;
     protected onCloseRequest(msg: Message): void;
@@ -90,6 +97,16 @@ export declare class AssistantSessionsPanel extends Widget {
      * `resolveLaunchMode` for the precedence rule. */
     private _launchMode;
     private _openSession;
+    /** Move the file browser to an opened session's project folder, when the
+     * setting is on and the folder is under the server root. A folder the file
+     * browser cannot address is left alone without a notification.
+     *
+     * `dontShowBrowser` stops JupyterLab activating the file browser tab, which
+     * would hide an assistant panel docked in the same sidebar. A failed move
+     * is one console line and never a failed open: JupyterLab's command logs a
+     * folder it cannot reach, and the catch below logs a command that is
+     * missing or rejects. */
+    private _moveFileBrowserTo;
     /** The server root every path is shown and resolved against, plus
      * JupyterLab's move-to-trash setting. Settable because a panel docked before
      * the server has answered its first status probe is built without either
@@ -269,6 +286,12 @@ export declare class AssistantSessionsPanel extends Widget {
     private _visibleVariantCount;
     private _buildMenus;
     private _menu;
+    /** Open the header's context menu at the pointer. Its two commands are on
+     * the application registry, where the plugin registers them once for every
+     * panel. The menu is built on its first open and not with the menus above:
+     * Lumino draws the items of a menu once they are added, and these two are
+     * drawn from that registry. */
+    private _openHeaderMenu;
     /** 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
@@ -330,11 +353,13 @@ export declare class AssistantSessionsPanel extends Widget {
     private _openBranchSubmenu;
     private _branchSessionMenu;
     private _newSessionMenu;
+    private _headerMenu;
     /** Re-writes the `+` button's title. Set once the shell exists. */
     private _renameNewButton;
     private _lastBranches;
     private _lastBranchesCurrent;
     private _colouredTabs;
+    private _syncFileBrowser;
     private _resettableColours;
     /** Bumped per context-menu open, so a slow one that has been superseded
      * knows to touch nothing. */

package/lib/core/panel.js

@@ -63,6 +63,17 @@ export function panelWidgetId(providerId) {
 export function commandId(providerId, action) {
     return `ai-code-assistants:${providerId}:${action}`;
 }
+/** Command ids of the two items in a panel header's context menu. The plugin
+ * registers them once, on the application registry, because the settings they
+ * write are shared by every panel. */
+export const SYNC_FILE_BROWSER_COMMAND = 'ai-code-assistants:toggle-file-browser-sync';
+export const MOVE_PANELS_COMMAND = 'ai-code-assistants:move-panels';
+/** The file browser moves of every panel, one after another in the order
+ * their opens finished. JupyterLab's command asks the server about a folder
+ * before it changes to it, so two moves that overlapped were applied in the
+ * order the answers arrived, and the file browser could end on the session
+ * opened first. */
+let fileBrowserMoves = Promise.resolve();
 function loadExpanded(storageKey) {
     try {
         const raw = window.localStorage.getItem(storageKey);
@@ -114,11 +125,13 @@ export class AssistantSessionsPanel extends Widget {
         this._sessions = null;
         /** Which row carries each section's single tab stop, by encoded path. */
         this._roving = {};
+        this._headerMenu = null;
         /** Re-writes the `+` button's title. Set once the shell exists. */
         this._renameNewButton = null;
         this._lastBranches = [];
         this._lastBranchesCurrent = '';
         this._colouredTabs = true;
+        this._syncFileBrowser = true;
         this._resettableColours = [];
         /** Bumped per context-menu open, so a slow one that has been superseded
          * knows to touch nothing. */
@@ -235,6 +248,10 @@ export class AssistantSessionsPanel extends Widget {
         this._colouredTabs = on;
         this._terminals.setColouredTabs(on);
     }
+    /** Whether opening a session moves the file browser to its project folder. */
+    setSyncFileBrowser(on) {
+        this._syncFileBrowser = on;
+    }
     onAfterShow(_msg) {
         this.refresh();
         this._startPolling();
@@ -256,6 +273,12 @@ export class AssistantSessionsPanel extends Widget {
         title.className = 'jp-AiAssistantsPanel-title';
         title.textContent = this._descriptor.panelTitle;
         header.appendChild(title);
+        // The header has a context menu of its own, for the settings every panel
+        // shares. It replaces the browser's menu here.
+        header.addEventListener('contextmenu', e => {
+            e.preventDefault();
+            this._openHeaderMenu(e.clientX, e.clientY);
+        });
         const newBtn = document.createElement('button');
         newBtn.className = 'jp-AiAssistantsPanel-iconButton';
         // The title is a static string - the folder is deliberately NOT named
@@ -729,6 +752,8 @@ export class AssistantSessionsPanel extends Widget {
     async _openSession(session, force, sessionId) {
         try {
             await this._terminals.openSession(session, this._launchMode(force), sessionId);
+            // Not awaited: the open has succeeded, and the sync is not part of it.
+            fileBrowserMoves = fileBrowserMoves.then(() => this._moveFileBrowserTo(session));
         }
         catch (err) {
             if (isResponseStatus(err, 404)) {
@@ -744,6 +769,33 @@ export class AssistantSessionsPanel extends Widget {
             void this._fetch().catch(() => undefined);
         }
     }
+    /** Move the file browser to an opened session's project folder, when the
+     * setting is on and the folder is under the server root. A folder the file
+     * browser cannot address is left alone without a notification.
+     *
+     * `dontShowBrowser` stops JupyterLab activating the file browser tab, which
+     * would hide an assistant panel docked in the same sidebar. A failed move
+     * is one console line and never a failed open: JupyterLab's command logs a
+     * folder it cannot reach, and the catch below logs a command that is
+     * missing or rejects. */
+    async _moveFileBrowserTo(session) {
+        if (!this._syncFileBrowser) {
+            return;
+        }
+        const rel = this._pathUnderRoot(session.project_path);
+        if (rel === null) {
+            return;
+        }
+        try {
+            await this._app.commands.execute('filebrowser:go-to-path', {
+                path: rel,
+                dontShowBrowser: true
+            });
+        }
+        catch (err) {
+            this._logError(`The file browser did not move to the project folder: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /** The server root every path is shown and resolved against, plus
      * JupyterLab's move-to-trash setting. Settable because a panel docked before
      * the server has answered its first status probe is built without either
@@ -2219,7 +2271,7 @@ export class AssistantSessionsPanel extends Widget {
             this._setActiveRow(null);
         });
     }
-    _menu() {
+    _menu(commands = this._commands) {
         // MenuSvg, not a plain Lumino Menu. Lumino's default renderer emits
         // `div.lm-Menu-itemSubmenuIcon` EMPTY, so every submenu here drew no caret
         // and `Branch Session`, which opens on hover, read exactly like the items
@@ -2227,10 +2279,30 @@ export class AssistantSessionsPanel extends Widget {
         // own menus use: it fills that div with the caret glyph, and otherwise
         // differs only in adding the stock menu-item icon sizing our items already
         // get from `base.css`.
-        const menu = new MenuSvg({ commands: this._commands });
+        const menu = new MenuSvg({ commands });
         menu.addClass('jp-AiAssistantsContextMenu');
         return menu;
     }
+    /** Open the header's context menu at the pointer. Its two commands are on
+     * the application registry, where the plugin registers them once for every
+     * panel. The menu is built on its first open and not with the menus above:
+     * Lumino draws the items of a menu once they are added, and these two are
+     * drawn from that registry. */
+    _openHeaderMenu(x, y) {
+        // A row menu that is still loading stands down, as it does for a newer
+        // row menu, and its row loses the highlight.
+        this._menuGeneration += 1;
+        this._setActiveRow(null);
+        if (!this._headerMenu) {
+            this._headerMenu = this._menu(this._app.commands);
+            this._headerMenu.addItem({ command: SYNC_FILE_BROWSER_COMMAND });
+            this._headerMenu.addItem({
+                command: MOVE_PANELS_COMMAND,
+                args: { panel: this.id }
+            });
+        }
+        this._headerMenu.open(x, y);
+    }
     /** 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

package/lib/core/request.d.ts

@@ -4,21 +4,21 @@ export declare const API_NAMESPACE = "jupyterlab-ai-code-assistants-extension";
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *
- * The number is not free to pick. `providers/codex.py` caps ONE `codex
- * archive` / `codex delete` invocation at `_CLI_TIMEOUT_S = 30`, so a Codex
- * disposal or fork can legitimately hold the server for thirty seconds. A
- * client ceiling at or below that would cut Codex silently on exactly the slow
- * path the server number was tuned for, so this sits a full CLI timeout above
- * it. Do not tune it down to the fast path.
+ * The number is not free to pick. The provider module that defines
+ * `_CLI_TIMEOUT_S = 30` caps ONE archive or delete CLI invocation at it, so a
+ * disposal or fork of that provider can legitimately hold the server for
+ * thirty seconds. A client ceiling at or below that would cut that provider
+ * silently on exactly the slow path the server number was tuned for, so this
+ * sits a full CLI timeout above it. Do not tune it down to the fast path.
  *
  * It bounds SINGLE-shot routes. Two server paths scale with N and can exceed
  * it honestly: a project DELETE runs one CLI invocation per conversation
- * (`CodexStore._dispose`, ~0.7s each measured, 30s each worst case), and a
- * sessions listing runs one `git` per project root capped at
+ * (that provider's `_dispose`, ~0.7s each measured, 30s each worst case), and
+ * a sessions listing runs one `git` per project root capped at
  * `GIT_BRANCH_TIMEOUT_S = 2`. The `signal` hatch waives the ceiling for such a
  * caller, but no caller in `src/` passes one today - only `request.spec.ts`
  * exercises it. Measured, a project DELETE has to hold 86 conversations in one
- * project to breach at ~0.7s per Codex CLI invocation, or 858 at ~70ms, and a
+ * project to breach at ~0.7s per CLI invocation, or 858 at ~70ms, and a
  * breach costs a spurious toast rather than data: the server thread runs to
  * completion and the retry is idempotent.
  */

package/lib/core/request.js

@@ -6,21 +6,21 @@ export const API_NAMESPACE = 'jupyterlab-ai-code-assistants-extension';
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *
- * The number is not free to pick. `providers/codex.py` caps ONE `codex
- * archive` / `codex delete` invocation at `_CLI_TIMEOUT_S = 30`, so a Codex
- * disposal or fork can legitimately hold the server for thirty seconds. A
- * client ceiling at or below that would cut Codex silently on exactly the slow
- * path the server number was tuned for, so this sits a full CLI timeout above
- * it. Do not tune it down to the fast path.
+ * The number is not free to pick. The provider module that defines
+ * `_CLI_TIMEOUT_S = 30` caps ONE archive or delete CLI invocation at it, so a
+ * disposal or fork of that provider can legitimately hold the server for
+ * thirty seconds. A client ceiling at or below that would cut that provider
+ * silently on exactly the slow path the server number was tuned for, so this
+ * sits a full CLI timeout above it. Do not tune it down to the fast path.
  *
  * It bounds SINGLE-shot routes. Two server paths scale with N and can exceed
  * it honestly: a project DELETE runs one CLI invocation per conversation
- * (`CodexStore._dispose`, ~0.7s each measured, 30s each worst case), and a
- * sessions listing runs one `git` per project root capped at
+ * (that provider's `_dispose`, ~0.7s each measured, 30s each worst case), and
+ * a sessions listing runs one `git` per project root capped at
  * `GIT_BRANCH_TIMEOUT_S = 2`. The `signal` hatch waives the ceiling for such a
  * caller, but no caller in `src/` passes one today - only `request.spec.ts`
  * exercises it. Measured, a project DELETE has to hold 86 conversations in one
- * project to breach at ~0.7s per Codex CLI invocation, or 858 at ~70ms, and a
+ * project to breach at ~0.7s per CLI invocation, or 858 at ~70ms, and a
  * breach costs a spurious toast rather than data: the server thread runs to
  * completion and the retry is idempotent.
  */

package/lib/index.js

@@ -9,13 +9,16 @@ import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 import { addCallbackCommand } from './core/callback';
 import { launcherTileIcon, providerIcon } from './core/icons';
 import { DEFAULT_RECENT_LIMIT } from './core/limits';
-import { AssistantSessionsPanel, DEFAULT_PRESENTATION_MODE, commandId, panelWidgetId } from './core/panel';
+import { AssistantSessionsPanel, DEFAULT_PRESENTATION_MODE, MOVE_PANELS_COMMAND, SYNC_FILE_BROWSER_COMMAND, commandId, panelWidgetId } from './core/panel';
 import { LOG_PREFIX, ProviderRegistry } from './core/registry';
 import { requestAPI } from './core/request';
 import { PROVIDERS } from './providers';
 /** Which sidebar the panels dock into unless the user says otherwise. */
 const DEFAULT_SIDEBAR = 'right';
 const PLUGIN_ID = 'jupyterlab_ai_code_assistants_extension:plugin';
+/** JupyterLab's own plugin, whose `layout` setting stores the sidebar a user
+ * chose for a widget with "Switch Sidebar Side". */
+const SHELL_PLUGIN_ID = '@jupyterlab/application-extension:shell';
 /** Sidebar rank, shared by every panel so they dock together. */
 const PANEL_RANK = 600;
 /** How often the server is re-asked which assistants are available, so a CLI
@@ -84,6 +87,9 @@ const plugin = {
         let status = null;
         let settings = null;
         let sidebar = DEFAULT_SIDEBAR;
+        /** The id of the panel whose header menu last asked for a move, until a
+         * move is applied. */
+        let moveAskedBy = null;
         /** Ask the server which providers exist and which of their binaries are on
          * PATH.
          *
@@ -147,6 +153,8 @@ const plugin = {
             }
             // Defaults ON, so only an explicit `false` turns it off.
             panel.setColouredTabs(setting('colouredTabs', true) !== false);
+            // Defaults ON as well: an absent key reads as on.
+            panel.setSyncFileBrowser(setting('syncFileBrowser', true) !== false);
             panel.setModes(modesFor(panel.descriptor.id));
         };
         const dock = (panel) => {
@@ -358,10 +366,43 @@ const plugin = {
             }
         };
         const applySidebar = () => {
+            var _a;
             const next = setting('sidebar', DEFAULT_SIDEBAR);
             if ((next === 'left' || next === 'right') && next !== sidebar) {
                 sidebar = next;
+                // Re-docking hides a panel, so a panel on screen before the move is
+                // activated again after it. Two can be on screen, one in each
+                // sidebar: the one whose header menu asked for the move is the one
+                // activated, else the first of them in `live`.
+                const onScreen = Array.from(live.values()).filter(entry => entry.panel.isVisible);
+                const shown = (_a = onScreen.find(entry => entry.panel.id === moveAskedBy)) !== null && _a !== void 0 ? _a : onScreen[0];
+                moveAskedBy = null;
                 live.forEach(entry => dock(entry.panel));
+                // A panel the user placed with JupyterLab's own "Switch Sidebar Side"
+                // carries a placement that `add` obeys, so it is still in the other
+                // sidebar. This change is the newer decision: it replaces that
+                // placement, the way JupyterLab's own command does, and JupyterLab's
+                // layout setting is saved so that the new side holds after a reload.
+                const elsewhere = new Set(labShell.widgets(sidebar === 'left' ? 'right' : 'left'));
+                let layout = null;
+                for (const entry of live.values()) {
+                    if (elsewhere.has(entry.panel)) {
+                        layout = labShell.move(entry.panel, sidebar);
+                    }
+                }
+                if (layout && settingRegistry) {
+                    settingRegistry
+                        .set(SHELL_PLUGIN_ID, 'layout', JSON.parse(JSON.stringify({
+                        single: layout['single-document'],
+                        multiple: layout['multiple-document']
+                    })))
+                        .catch(err => {
+                        console.warn(`${LOG_PREFIX} could not save the panel placement.`, err);
+                    });
+                }
+                if (shown) {
+                    labShell.activateById(shown.panel.id);
+                }
             }
         };
         await probeStatus();
@@ -383,6 +424,57 @@ const plugin = {
                 settings = null;
             }
         }
+        /** Save one shared setting from a panel header's context menu. The
+         * `changed` handler above applies a saved value. A failed save does not
+         * change the composite value the menu reads, so the menu keeps showing
+         * the previous state. */
+        const saveSetting = async (key, value) => {
+            try {
+                await (settings === null || settings === void 0 ? void 0 : settings.set(key, value));
+            }
+            catch (err) {
+                console.warn(`${LOG_PREFIX} could not save setting "${key}".`, err);
+                Notification.error(trans.__('The setting was not saved. Try again.'), {
+                    autoClose: 4000
+                });
+            }
+        };
+        // The two items of every panel header's context menu. Registered once,
+        // here, because the settings they write are shared by every panel, and
+        // before the first panel exists.
+        app.commands.addCommand(SYNC_FILE_BROWSER_COMMAND, {
+            label: trans.__('Sync File Browser'),
+            // Takes no arguments, which is what `null` says here.
+            describedBy: { args: null },
+            isEnabled: () => settings !== null,
+            isToggled: () => setting('syncFileBrowser', true) !== false,
+            execute: () => saveSetting('syncFileBrowser', setting('syncFileBrowser', true) === false)
+        });
+        app.commands.addCommand(MOVE_PANELS_COMMAND, {
+            // Names the sidebar the panels are not in.
+            label: () => sidebar === 'right'
+                ? trans.__('Move Panel Left')
+                : trans.__('Move Panel Right'),
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {
+                        panel: {
+                            type: 'string',
+                            description: 'Id of the panel whose header menu ran the command.'
+                        }
+                    }
+                }
+            },
+            isEnabled: () => settings !== null,
+            execute: args => {
+                // `applySidebar` reads this when the change arrives. After a save
+                // that fails it stays set: the sidebar can then only change to the
+                // side this menu asked for.
+                moveAskedBy = typeof args.panel === 'string' ? args.panel : null;
+                return saveSetting('sidebar', sidebar === 'right' ? 'left' : 'right');
+            }
+        });
         await migrate();
         reconcile();
         // Re-probe on a slow cadence so a binary installed (or removed) while

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.56",
+    "version": "1.2.71",
     "description": "A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting.",
     "keywords": [
         "jupyter",

package/schema/plugin.json

@@ -33,6 +33,12 @@
       "enum": ["left", "right"],
       "default": "right"
     },
+    "syncFileBrowser": {
+      "type": "boolean",
+      "title": "Sync file browser with opened session",
+      "description": "When enabled (default), opening a session moves the JupyterLab file browser to that session's project folder. A project folder outside the JupyterLab root leaves the file browser where it is. The context menu of each panel header also toggles this.",
+      "default": true
+    },
     "providers.claude.enabled": {
       "type": "boolean",
       "title": "Claude Code: enabled",