jupyterlab_ai_code_assistants_extension 1.2.27 → 1.2.30

package/README.md

@@ -34,6 +34,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **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
 - **Branch session** - fork the current conversation into a new named session via the right-click menu; each assistant forks its own way (Claude's native `--fork-session`, Codex's `codex fork`, server-side copies for Kimi, Gemini and DeepSeek) behind the same menu item
+- **Rename session** - name a conversation from the right-click menu, and the name is written where the assistant itself reads it back: Claude gets the record its own `/rename` writes, Kimi a custom title, Gemini the chat's summary, DeepSeek its title event. The panel shows the name the assistant actually kept. Codex keeps its names in a database this extension only reads, and its CLI has no rename verb, so the item is absent there rather than failing
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo`, Gemini's YOLO; unsafe variants carry a shield glyph in the launch menus
 - **Coloured terminal tabs** - each session's colour tints its terminal tab via the companion `jupyterlab_colourful_tab_extension` (installed automatically). Claude's own `/color` supplies its default, Kimi derives a stable colour from the conversation id; Codex, Gemini and DeepSeek have no colour of their own until you set one, and a branched session inherits its parent's colour, which it keeps even if the parent's colour later changes or is reset. Tinting needs the companion release that reports the colours you pick and lets another extension own a tab - against an older one this extension tints no tabs at all and says so once, and the companion's own right-click colours keep working as they always did
 - **Your own tab colour wins** - set a colour on a terminal tab and the extension remembers it for that conversation, overriding whatever the assistant chose. `Reset Tab Colour (n)` in the session's right-click menu hands back every colour you set by hand on that project's conversations, and appears once there is one to hand back. Clearing the colour on the tab itself releases it too, for the conversation that terminal is running; `Reset Tab Colour` is the way back for a conversation with no tab open. A Codex or Kimi conversation that has never been resumed cannot be tracked yet, so a colour set on its tab is not kept

package/lib/core/panel.d.ts

@@ -181,6 +181,21 @@ export declare class AssistantSessionsPanel extends Widget {
      * alone would not - the actively written parent overtakes it) and inherits
      * the parent's tint. */
     private _watchForNewBranch;
+    /** Name the row's current conversation, in the assistant's own store.
+     *
+     * Only ever offered where the descriptor says the assistant keeps a name
+     * this extension can write - see `canRename`. The field is seeded from the
+     * conversation's OWN name and left empty otherwise: the row falls back to
+     * the project folder when a conversation is unnamed, and seeding that would
+     * have the user accept a dialog that silently names the conversation after
+     * its directory.
+     */
+    private _renameSession;
+    /** What to tell the user about a refused rename. `rename_failed` is the one
+     * refusal a correct request can still earn - an assistant that keeps names
+     * per conversation may have none to rewrite yet - so it gets words rather
+     * than the raw code. */
+    private _renameError;
     /** Make another conversation the row's current one. */
     private _switchBranch;
     /** Delete conversations of the active row's project. Resolves with the

package/lib/core/panel.js

@@ -1,5 +1,5 @@
 import { Clipboard, Dialog, InputDialog, Notification, showDialog } from '@jupyterlab/apputils';
-import { MenuSvg, closeIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
+import { MenuSvg, closeIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { nullTranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
 import { UUID } from '@lumino/coreutils';
@@ -1199,6 +1199,73 @@ export class AssistantSessionsPanel extends Widget {
         };
         window.setTimeout(() => void tick(), BRANCH_WATCH_INTERVAL_MS);
     }
+    /** Name the row's current conversation, in the assistant's own store.
+     *
+     * Only ever offered where the descriptor says the assistant keeps a name
+     * this extension can write - see `canRename`. The field is seeded from the
+     * conversation's OWN name and left empty otherwise: the row falls back to
+     * the project folder when a conversation is unnamed, and seeding that would
+     * have the user accept a dialog that silently names the conversation after
+     * its directory.
+     */
+    async _renameSession(session) {
+        var _a;
+        const named = await InputDialog.getText({
+            title: 'Rename Session',
+            label: `Name for this ${this._descriptor.label} conversation`,
+            text: session.name_source === 'session' ? session.name : '',
+            placeholder: this._lookupName(session)
+        });
+        if (!named.button.accept) {
+            return;
+        }
+        const name = ((_a = named.value) !== null && _a !== void 0 ? _a : '').trim();
+        if (!name) {
+            // Refused the way Branch Session refuses an empty name (DEF-43): the
+            // placeholder shows the current name, which reads as "press Ok for the
+            // default", so an empty Ok has to say that nothing happened.
+            Notification.warning('Enter a name - nothing was renamed.', {
+                autoClose: 4000
+            });
+            return;
+        }
+        try {
+            const result = await requestProvider(this._descriptor.id, 'rename', this._serverSettings, {
+                method: 'POST',
+                body: JSON.stringify({
+                    encoded_path: session.encoded_path,
+                    session_id: session.session_id,
+                    name
+                })
+            });
+            // The stored name, never the typed one - a store may normalise what it
+            // writes, and echoing the request would report a name that is not on
+            // disk.
+            Notification.success(`Renamed to ${result.name}`, { autoClose: 3000 });
+        }
+        catch (err) {
+            Notification.error(this._renameError(err), { autoClose: 4000 });
+        }
+        finally {
+            // The switcher submenu labels branches from this cache, so a stale one
+            // would keep showing the old name next to the new row title.
+            this._branchCache = null;
+            await this._fetch().catch(() => undefined);
+        }
+    }
+    /** What to tell the user about a refused rename. `rename_failed` is the one
+     * refusal a correct request can still earn - an assistant that keeps names
+     * per conversation may have none to rewrite yet - so it gets words rather
+     * than the raw code. */
+    _renameError(err) {
+        if (isResponseStatus(err, 404)) {
+            return 'That conversation no longer exists - the list has been refreshed.';
+        }
+        if ((err === null || err === void 0 ? void 0 : err.message) === 'rename_failed') {
+            return `${this._descriptor.label} would not store a name for this conversation.`;
+        }
+        return `Rename failed: ${err}`;
+    }
     /** Make another conversation the row's current one. */
     async _switchBranch(session, sessionId) {
         var _a;
@@ -2104,6 +2171,20 @@ export class AssistantSessionsPanel extends Widget {
             },
             execute: () => void this._branchSession()
         });
+        this._commands.addCommand(this._cmd('rename-session'), {
+            label: this._trans.__('Rename Session...'),
+            icon: editIcon,
+            // Absent, not disabled, for an assistant with no writable name: a
+            // greyed item invites the user to find out why, and the answer is that
+            // this assistant will never have one.
+            isVisible: () => this._descriptor.canRename,
+            execute: () => {
+                const s = active();
+                if (s) {
+                    void this._renameSession(s);
+                }
+            }
+        });
         this._commands.addCommand(this._cmd('remove'), {
             label: `Remove from ${this._descriptor.label}`,
             icon: removeIcon,
@@ -2197,6 +2278,7 @@ export class AssistantSessionsPanel extends Widget {
         add('open-terminal');
         add('show-in-filebrowser');
         add('toggle-favourite');
+        add('rename-session');
         add('copy-path');
         add('copy-session-id');
         add('reset-colour');

package/lib/core/types.d.ts

@@ -69,6 +69,11 @@ export interface IProviderDescriptor {
     /** Whether the branch flow asks the user to name the new conversation.
      * Where that name then GOES is `forkStrategy`'s job. */
     promptsForBranchName: boolean;
+    /** The assistant keeps a conversation name this extension can write where
+     * the assistant itself reads it back. False hides the rename action rather
+     * than offering one that cannot land - which is the honest answer for an
+     * assistant whose names live in a store this extension only reads. */
+    canRename: boolean;
     /** The CLI starts a brand-new conversation under an id we give it, so a
      * fresh session is identifiable from its argv on the first poll instead of
      * being an unknown terminal until it writes its store entry. Independent of
@@ -193,6 +198,12 @@ export interface ISwitchResponse {
 export interface IForkResponse {
     session_id: string;
 }
+export interface IRenameResponse {
+    session_id: string;
+    /** The name as STORED, which a provider may have normalised - never assume
+     * it is the string that was sent. */
+    name: string;
+}
 export interface ILaunchRequest {
     project_path: string;
     /** The project's store key. Carrying it arms the server's launch-time pin

package/lib/providers/claude.js

@@ -47,6 +47,9 @@ export const descriptor = {
     // every turn, which is the only way a fork's name survives - a title written
     // after the fact loses to the parent title the fork inherits.
     promptsForBranchName: true,
+    // `/rename` writes a `custom-title` record into the transcript, and the
+    // store writes the same record.
+    canRename: true,
     mintsNewSessionId: true,
     launchModes: [
         {

package/lib/providers/codex.js

@@ -42,6 +42,9 @@ export const descriptor = {
     // Forks are unnamed - Codex has no naming flag and no writable title field,
     // so the panel never asks for a name it could not stamp anywhere.
     promptsForBranchName: false,
+    // No writable name: a thread's name lives in the sqlite index the CLI
+    // owns, and Codex has no rename subcommand to shell to.
+    canRename: false,
     // A bare `codex` mints its own thread id; there is no `--session-id`.
     mintsNewSessionId: false,
     launchModes: [

package/lib/providers/deepseek.js

@@ -48,6 +48,8 @@ export const descriptor = {
     colourSource: 'none',
     terminalScope: 'project',
     promptsForBranchName: true,
+    // The name is the newest `session/title` event of the log.
+    canRename: true,
     mintsNewSessionId: false,
     sessionIdPrefix: 'session-',
     launchModes: [],

package/lib/providers/gemini.js

@@ -47,6 +47,8 @@ export const descriptor = {
     // The fork's name is written into the copy by the server; the CLI has no
     // naming flag to take it.
     promptsForBranchName: true,
+    // The name is `summary` in the chat file, which is what the CLI shows.
+    canRename: true,
     // `--session-id <uuid>` starts a conversation under an id we mint.
     mintsNewSessionId: true,
     launchModes: [

package/lib/providers/kimi.js

@@ -44,6 +44,8 @@ export const descriptor = {
     // The fork's name is written into the copy's `state.json` by the server; the
     // CLI has no naming flag to take it.
     promptsForBranchName: true,
+    // The name is `title` in the conversation's `state.json`.
+    canRename: true,
     // A bare `kimi` mints its own id and writes it on the first turn, and `-S`
     // only ever resumes - so a new conversation cannot be launched under an id
     // we chose, and is identified from the store on the next poll instead.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.27",
+    "version": "1.2.30",
     "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",