xtralab 0.8.0 → 0.10.0

package/README.md

@@ -3,8 +3,8 @@
 An opinionated JupyterLab meta-package for use with coding agents.
 
 It bundles a curated set of JupyterLab extensions, a path-first file browser,
-git diffs rendered by xtralab, an agent launcher, and a quieter default
-workspace.
+rich git diffs for text, notebooks, and images, an agent launcher, and a
+quieter default workspace.
 
 ![xtralab screenshot](./screenshot.png)
 
@@ -34,6 +34,23 @@ from `main` are uploaded as workflow artifacts on the
 [CONTRIBUTING.md](./CONTRIBUTING.md) for the desktop app architecture and local
 build instructions.
 
+On macOS the build is not notarized yet (it has no Apple Developer ID), so
+Gatekeeper blocks it on first launch, and agent notifications fall back to
+`osascript`, appearing as "Script Editor". In the meantime you can self-sign it
+for free: this lets it launch and gives native notifications instead, branded as
+xtralab and clickable to jump to the terminal that fired them. Create a
+code-signing certificate once in Keychain Access (Certificate Assistant, Create
+a Certificate, with Identity Type "Self Signed Root" and Certificate Type "Code
+Signing") named `xtralab-selfsign`, then sign the app you copied out of the DMG:
+
+```bash
+codesign --force --deep --sign "xtralab-selfsign" --timestamp=none "/Applications/xtralab.app"
+xattr -dr com.apple.quarantine "/Applications/xtralab.app"
+```
+
+macOS prompts once to let `codesign` use the key; choose Always Allow. None of
+this will be needed once the app ships with a Developer ID signature.
+
 ## What's included
 
 xtralab builds on [`ajlab`](https://github.com/jtpio/ajlab), the agent-ready
@@ -46,10 +63,11 @@ themes (`jupyterlab-cursor-light`, `jupyterlab-cursor-dark`,
 
 The bundled xtralab labextension then adds:
 
-- A path-first file browser in the left sidebar.
-- Git diffs rendered by xtralab in the `jupyterlab-git` panel, using
-  `@pierre/diffs` for text and notebooks and a 2-up / swipe / onion-skin view
-  for images.
+- A path-first file browser in the left sidebar, with `@pierre/trees`
+  file-type icons that also carry over to document tabs and the `jupyterlab-git`
+  panel.
+- Rich git diffs in the `jupyterlab-git` panel, using `@pierre/diffs` for text
+  and notebooks and a 2-up / swipe / onion-skin view for images.
 - An agent launcher with a prompt box, buttons for the agents installed on your
   machine (Claude, Codex, Antigravity, Copilot, Goose, OpenCode, Kiro, Mistral
   Vibe), a collapsible list of changed files, and an Open row for a terminal,
@@ -59,6 +77,12 @@ The bundled xtralab labextension then adds:
   the same icon.
 - Sidebar toggle buttons in the top bar for the left and right areas.
 
+xtralab also ships a set of opinionated defaults: unused UI is hidden for a
+quieter workspace, the activity bar sits at the top, and autocompletion,
+continuous LSP hinting, code folding, and gitignore-aware quick open are on by
+default. See [the bundled labconfig overrides](./jupyter-config/labconfig) for
+the full set.
+
 ## Connecting agents to Jupyter (MCP)
 
 xtralab runs a [Model Context Protocol][mcp-spec] server inside JupyterLab,

package/lib/fileBrowser/commands.d.ts

@@ -1,4 +1,7 @@
 import { JupyterFrontEnd } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { ITranslator } from '@jupyterlab/translation';
 import { IXtralabFileBrowser } from './widget';
 /**
  * Command identifiers exposed by the xtralab browser. We deliberately namespace
@@ -20,6 +23,7 @@ export declare namespace CommandIDs {
     const createNewDirectory = "xtralab:create-new-directory";
     const newLauncher = "xtralab:new-launcher";
     const revealPath = "xtralab:reveal-path";
+    const revealInFileTree = "xtralab:reveal-in-file-tree";
 }
 /**
  * Submenu id used to host the dynamically populated "Open With" entries.
@@ -31,6 +35,9 @@ export declare const OPEN_WITH_SUBMENU_ID = "jp-contextmenu-xtralab-open-with";
 export interface IRegisterCommandsOptions {
     app: JupyterFrontEnd;
     browser: IXtralabFileBrowser;
+    docManager: IDocumentManager;
+    palette: ICommandPalette | null;
+    translator: ITranslator | null;
 }
 /**
  * Register every xtralab command on the application command registry, attach

package/lib/fileBrowser/commands.js

@@ -1,5 +1,6 @@
 import { Clipboard, Dialog, InputDialog, showDialog, showErrorMessage } from '@jupyterlab/apputils';
 import { PageConfig, PathExt } from '@jupyterlab/coreutils';
+import { nullTranslator } from '@jupyterlab/translation';
 import { addIcon, closeIcon, collapseAllIcon, CommandToolbarButton, copyIcon, downloadIcon, editIcon, fileIcon, newFolderIcon, refreshIcon } from '@jupyterlab/ui-components';
 import { toCanonicalPath, toServerPath } from './contents';
 import { FILE_BROWSER_ID } from './widget';
@@ -24,6 +25,7 @@ export var CommandIDs;
     CommandIDs.createNewDirectory = 'xtralab:create-new-directory';
     CommandIDs.newLauncher = 'xtralab:new-launcher';
     CommandIDs.revealPath = 'xtralab:reveal-path';
+    CommandIDs.revealInFileTree = 'xtralab:reveal-in-file-tree';
 })(CommandIDs || (CommandIDs = {}));
 /**
  * Submenu id used to host the dynamically populated "Open With" entries.
@@ -102,6 +104,44 @@ function getWorkingDirectory(browser) {
     }
     return PathExt.dirname(serverPath);
 }
+/**
+ * Resolve the main-area widget whose tab is the target of the current
+ * context-menu event, or `null` when that target is not a document tab. The
+ * shell stamps each tab's `data-id` with its widget id, so the right-clicked
+ * tab resolves even when it is not the current one.
+ *
+ * Valid only during a context-menu invocation: `contextMenuHitTest` reads the
+ * last context-menu event, which is not cleared when the menu closes, so
+ * {@link documentPathToReveal} gates this to avoid resolving a stale tab.
+ */
+function contextMenuTabWidget(app) {
+    const node = app.contextMenuHitTest(n => n.dataset !== undefined && n.dataset.type === 'document-title');
+    const id = node === null || node === void 0 ? void 0 : node.dataset.id;
+    if (id === undefined) {
+        return null;
+    }
+    for (const widget of app.shell.widgets('main')) {
+        if (widget.id === id) {
+            return widget;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve the document to reveal as a canonical `@pierre/trees` path: the
+ * right-clicked tab when `fromContextMenu` is true (the file-tab menu),
+ * otherwise the active main-area widget (the palette). A file's context
+ * `path` is already canonical. Returns `undefined` when nothing resolves.
+ */
+function documentPathToReveal(app, docManager, fromContextMenu) {
+    var _a, _b, _c;
+    const widget = (_a = (fromContextMenu ? contextMenuTabWidget(app) : null)) !== null && _a !== void 0 ? _a : app.shell.currentWidget;
+    if (widget === null) {
+        return undefined;
+    }
+    const path = (_c = (_b = docManager.contextForWidget(widget)) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : '';
+    return path.length > 0 ? path : undefined;
+}
 /**
  * Refresh the "Open With" submenu's items from the document factories that
  * can open the file under the right-click. Mirrors the
@@ -148,8 +188,10 @@ function makeOpenWithUpdater(app, browser) {
  *   the plugin.
  */
 export function registerCommands(opts) {
-    const { app, browser } = opts;
+    var _a;
+    const { app, browser, docManager, palette, translator } = opts;
     const { commands } = app;
+    const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
     commands.addCommand(CommandIDs.open, {
         label: args => { var _a, _b; return ((_b = (_a = args.label) !== null && _a !== void 0 ? _a : args.factory) !== null && _b !== void 0 ? _b : 'Open'); },
         icon: args => {
@@ -364,6 +406,21 @@ export function registerCommands(opts) {
             }
         }
     });
+    // Reveal the resolved document in the tree browser via the reveal-path
+    // command, which surfaces the sidebar and scrolls to the target.
+    commands.addCommand(CommandIDs.revealInFileTree, {
+        label: trans.__('Show in File Tree'),
+        caption: trans.__('Show this file in the xtralab file browser'),
+        isEnabled: args => documentPathToReveal(app, docManager, args.fromTab === true) !==
+            undefined,
+        execute: args => {
+            const path = documentPathToReveal(app, docManager, args.fromTab === true);
+            if (path === undefined) {
+                return undefined;
+            }
+            return commands.execute(CommandIDs.revealPath, { path });
+        }
+    });
     commands.addCommand(CommandIDs.createNewDirectory, {
         label: 'New Folder',
         caption: 'Create a new folder',
@@ -402,6 +459,19 @@ export function registerCommands(opts) {
             commands.notifyCommandChanged(id);
         }
     });
+    // This command's enabled state tracks the active widget, not the tree
+    // selection, so re-evaluate it on current-widget changes. `currentChanged`
+    // is optional on the shell interface.
+    const onCurrentChanged = () => {
+        commands.notifyCommandChanged(CommandIDs.revealInFileTree);
+    };
+    (_a = app.shell.currentChanged) === null || _a === void 0 ? void 0 : _a.connect(onCurrentChanged);
+    // Also surface it in the palette (acts on the active editor); the file-tab
+    // context-menu entry is declared in `schema/plugin.json`.
+    const paletteItem = palette === null || palette === void 0 ? void 0 : palette.addItem({
+        command: CommandIDs.revealInFileTree,
+        category: trans.__('File Browser')
+    });
     // The static items are declared in `schema/plugin.json` under
     // `jupyter.lab.menus.context` so users can override or disable them. The
     // schema also declares an empty submenu placeholder with id
@@ -410,7 +480,10 @@ export function registerCommands(opts) {
     const updateOpenWithMenu = makeOpenWithUpdater(app, browser);
     app.contextMenu.opened.connect(updateOpenWithMenu);
     return () => {
+        var _a;
         app.contextMenu.opened.disconnect(updateOpenWithMenu);
+        (_a = app.shell.currentChanged) === null || _a === void 0 ? void 0 : _a.disconnect(onCurrentChanged);
+        paletteItem === null || paletteItem === void 0 ? void 0 : paletteItem.dispose();
     };
 }
 /**

package/lib/fileBrowser/fileBrowser.js

@@ -562,7 +562,10 @@ export function FileBrowserComponent(props) {
                 previous === null || previous === void 0 ? void 0 : previous.deselect();
             }
             target.select();
-            model.focusPath(canonicalPath);
+            // `select` highlights the row; `scrollToPath` focuses it and scrolls it
+            // to the middle of the viewport, even when the row is virtualized out of
+            // the rendered window.
+            model.scrollToPath(canonicalPath, { focus: true, offset: 'center' });
         };
         /**
          * Insert a newly-created path (typically from "new folder" or

package/lib/fileBrowser/icons.d.ts

@@ -24,14 +24,10 @@ export declare const xtralabFileBrowserIcon: LabIcon;
  */
 export declare const FILE_BROWSER_ICONS: FileTreeIconConfig;
 /**
- * Return a JupyterLab `LabIcon` matching the icon the xtralab file tree would
- * render for the given file path. Used by other plugins (e.g. the git diff
- * viewer) that want their main-area widget tabs to display the same per-file
- * glyph the tree shows in the sidebar.
- *
- * Resolves the symbol via the same `@pierre/trees` resolver the tree itself
- * uses, then inlines the symbol's body into a self-contained SVG so the icon
- * works outside the tree's shadow DOM. Falls back to JupyterLab's default
- * `fileIcon` when the sprite cannot be located in either sheet.
+ * Return the icon the xtralab file tree would render for `filePath`.
  */
 export declare function getTreeIcon(filePath: string): LabIcon;
+/**
+ * Like {@link getTreeIcon}, but returns `null` for the generic file glyph.
+ */
+export declare function getSpecificTreeIcon(filePath: string): LabIcon | null;

package/lib/fileBrowser/icons.js

@@ -1,6 +1,6 @@
 var _a;
 import { LabIcon, fileIcon } from '@jupyterlab/ui-components';
-import { createFileTreeIconResolver, getBuiltInFileIconColor, getBuiltInSpriteSheet } from '@pierre/trees';
+import { createFileTreeIconResolver, getBuiltInSpriteSheet } from '@pierre/trees';
 /**
  * The glyph used as the xtralab file browser's sidebar tab icon. Defined as a
  * `LabIcon` (rather than the default `folderIcon` from
@@ -105,26 +105,96 @@ function extractSymbol(symbolId) {
     };
 }
 /**
- * Return a JupyterLab `LabIcon` matching the icon the xtralab file tree would
- * render for the given file path. Used by other plugins (e.g. the git diff
- * viewer) that want their main-area widget tabs to display the same per-file
- * glyph the tree shows in the sidebar.
+ * Fallback colors for the built-in file icons, keyed by the icon token
+ * `@pierre/trees` resolves for a path (e.g. `python`, `typescript`).
  *
- * Resolves the symbol via the same `@pierre/trees` resolver the tree itself
- * uses, then inlines the symbol's body into a self-contained SVG so the icon
- * works outside the tree's shadow DOM. Falls back to JupyterLab's default
- * `fileIcon` when the sprite cannot be located in either sheet.
+ * The tree only exposes these as `--trees-file-icon-color-<token>` CSS
+ * variables scoped to its shadow host, so they resolve to nothing for the
+ * standalone {@link LabIcon}s {@link getTreeIcon} builds for main-area tabs.
+ * Mirroring them here lets {@link getBuiltInFileIconColor} bottom out in a
+ * real color. Each is a `light-dark(…)` pair for dark themes.
  */
-export function getTreeIcon(filePath) {
+const BUILT_IN_FILE_ICON_COLOR_FALLBACKS = {
+    astro: 'light-dark(#a631be, #d568ea)',
+    babel: 'light-dark(#d5a910, #ffd452)',
+    bash: 'light-dark(#199f43, #5ecc71)',
+    biome: 'light-dark(#1a85d4, #69b1ff)',
+    bootstrap: 'light-dark(#693acf, #9d6afb)',
+    browserslist: 'light-dark(#d5a910, #ffd452)',
+    bun: 'light-dark(#594c5b, #79697b)',
+    c: 'light-dark(#1a85d4, #69b1ff)',
+    claude: 'light-dark(#d47628, #ffa359)',
+    cpp: 'light-dark(#1a85d4, #69b1ff)',
+    css: 'light-dark(#693acf, #9d6afb)',
+    database: 'light-dark(#a631be, #d568ea)',
+    default: 'light-dark(#84848a, #adadb1)',
+    docker: 'light-dark(#1a85d4, #69b1ff)',
+    eslint: 'light-dark(#693acf, #9d6afb)',
+    git: 'light-dark(#ff8c5b, #d5512f)',
+    go: 'light-dark(#1ca1c7, #68cdf2)',
+    graphql: 'light-dark(#d32a61, #ff678d)',
+    html: 'light-dark(#d47628, #ffa359)',
+    image: 'light-dark(#d32a61, #ff678d)',
+    javascript: 'light-dark(#d5a910, #ffd452)',
+    json: 'light-dark(#d47628, #ffa359)',
+    markdown: 'light-dark(#199f43, #5ecc71)',
+    mcp: 'light-dark(#17a5af, #64d1db)',
+    npm: 'light-dark(#d52c36, #ff6762)',
+    oxc: 'light-dark(#1ca1c7, #68cdf2)',
+    postcss: 'light-dark(#d52c36, #ff6762)',
+    prettier: 'light-dark(#17a5af, #64d1db)',
+    python: 'light-dark(#1a85d4, #69b1ff)',
+    react: 'light-dark(#1ca1c7, #68cdf2)',
+    ruby: 'light-dark(#d52c36, #ff6762)',
+    rust: 'light-dark(#d47628, #ffa359)',
+    sass: 'light-dark(#d32a61, #ff678d)',
+    svelte: 'light-dark(#d52c36, #ff6762)',
+    svg: 'light-dark(#d47628, #ffa359)',
+    svgo: 'light-dark(#199f43, #5ecc71)',
+    swift: 'light-dark(#d47628, #ffa359)',
+    table: 'light-dark(#17a5af, #64d1db)',
+    tailwind: 'light-dark(#1ca1c7, #68cdf2)',
+    terraform: 'light-dark(#693acf, #9d6afb)',
+    text: 'light-dark(#84848a, #adadb1)',
+    typescript: 'light-dark(#1a85d4, #69b1ff)',
+    vite: 'light-dark(#a631be, #d568ea)',
+    vscode: 'light-dark(#1a85d4, #69b1ff)',
+    vue: 'light-dark(#199f43, #5ecc71)',
+    wasm: 'light-dark(#693acf, #9d6afb)',
+    webpack: 'light-dark(#1a85d4, #69b1ff)',
+    yml: 'light-dark(#d52c36, #ff6762)',
+    zig: 'light-dark(#d47628, #ffa359)',
+    zip: 'light-dark(#d47628, #ffa359)'
+};
+/**
+ * Color the file tree would paint for the built-in icon `token`, as a
+ * self-contained CSS value usable outside the tree's shadow DOM: the tree's
+ * `--trees-file-icon-color-*` properties when in scope, else the literal from
+ * {@link BUILT_IN_FILE_ICON_COLOR_FALLBACKS}. Returns `undefined` for unknown
+ * tokens.
+ */
+function getBuiltInFileIconColor(token) {
+    const fallback = BUILT_IN_FILE_ICON_COLOR_FALLBACKS[token];
+    if (fallback === undefined) {
+        return undefined;
+    }
+    return `var(--trees-file-icon-color-${token}, var(--trees-file-icon-color, ${fallback}))`;
+}
+/**
+ * Resolve a tree glyph into a standalone `LabIcon`.
+ */
+function resolveTreeIcon(filePath) {
     var _a;
     const resolved = treeIconResolver.resolveIcon('file-tree-icon-file', filePath);
+    // Anything other than the catch-all glyph is specific to this file.
+    const specific = resolved.token !== 'default' && resolved.name !== 'file-tree-icon-file';
     const cached = TREE_ICON_CACHE.get(resolved.name);
     if (cached !== undefined) {
-        return cached;
+        return { icon: cached, specific };
     }
     const symbol = extractSymbol(resolved.name);
     if (symbol === null) {
-        return fileIcon;
+        return { icon: null, specific };
     }
     // Built-in language icons paint with `fill="currentColor"` so the colored
     // tier of the tree can recolor them by setting `color` on the host
@@ -149,5 +219,19 @@ export function getTreeIcon(filePath) {
         svgstr
     });
     TREE_ICON_CACHE.set(resolved.name, icon);
-    return icon;
+    return { icon, specific };
+}
+/**
+ * Return the icon the xtralab file tree would render for `filePath`.
+ */
+export function getTreeIcon(filePath) {
+    var _a;
+    return (_a = resolveTreeIcon(filePath).icon) !== null && _a !== void 0 ? _a : fileIcon;
+}
+/**
+ * Like {@link getTreeIcon}, but returns `null` for the generic file glyph.
+ */
+export function getSpecificTreeIcon(filePath) {
+    const { icon, specific } = resolveTreeIcon(filePath);
+    return specific ? icon : null;
 }

package/lib/fileBrowser/index.js

@@ -1,6 +1,8 @@
 import { ILayoutRestorer } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
 import { IDocumentManager } from '@jupyterlab/docmanager';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator } from '@jupyterlab/translation';
 import { populateToolbar, registerCommands } from './commands';
 import { XtralabFileBrowser } from './widget';
 const PLUGIN_ID = 'xtralab:plugin';
@@ -13,8 +15,8 @@ const plugin = {
     description: 'A path-first file browser for JupyterLab built on @pierre/trees.',
     autoStart: true,
     requires: [IDocumentManager],
-    optional: [ILayoutRestorer, ISettingRegistry],
-    activate: (app, docManager, restorer, settingRegistry) => {
+    optional: [ILayoutRestorer, ISettingRegistry, ICommandPalette, ITranslator],
+    activate: (app, docManager, restorer, settingRegistry, palette, translator) => {
         const browser = new XtralabFileBrowser({
             contentsManager: app.serviceManager.contents,
             docManager,
@@ -30,7 +32,7 @@ const plugin = {
         if (restorer) {
             restorer.add(browser, browser.id);
         }
-        registerCommands({ app, browser });
+        registerCommands({ app, browser, docManager, palette, translator });
         populateToolbar({ app, browser });
         if (settingRegistry) {
             settingRegistry.load(PLUGIN_ID).catch(reason => {

package/lib/fileTypeIcons/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Share the file browser's tree glyphs with tabs and git file lists.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/fileTypeIcons/index.js

@@ -0,0 +1,144 @@
+import { IDocumentWidgetOpener } from '@jupyterlab/docmanager';
+import { IGitExtension } from '@jupyterlab/git';
+import { getSpecificTreeIcon } from '../fileBrowser/icons';
+const PLUGIN_ID = 'xtralab:file-type-icons';
+/**
+ * Synthetic path used to resolve a file type's tree glyph.
+ */
+function representativePath(fileType) {
+    var _a;
+    const extension = (_a = fileType.extensions) === null || _a === void 0 ? void 0 : _a[0];
+    if (extension === undefined || extension === '') {
+        return null;
+    }
+    // Extensions are stored with a leading dot (e.g. `.py`, `.tar.gz`).
+    return `file${extension.startsWith('.') ? extension : `.${extension}`}`;
+}
+/**
+ * Point a file type's icon at the tree glyph for its extension.
+ */
+function applyTreeIcon(fileType) {
+    const path = representativePath(fileType);
+    if (path === null) {
+        return;
+    }
+    const icon = getSpecificTreeIcon(path);
+    if (icon === null) {
+        return;
+    }
+    // The registry owns these objects; `readonly` only blocks the type shape.
+    fileType.icon = icon;
+}
+/**
+ * Source extensions with tree glyphs but no default JupyterLab file type.
+ */
+const EXTRA_FILE_TYPE_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.go',
+    '.rs',
+    '.rb',
+    '.c',
+    '.h',
+    '.cpp',
+    '.cc',
+    '.hpp',
+    '.swift',
+    '.zig',
+    '.vue',
+    '.svelte',
+    '.astro',
+    '.scss',
+    '.sass',
+    '.sh',
+    '.bash',
+    '.zsh',
+    '.graphql',
+    '.wasm'
+];
+/**
+ * Register icon-only file types for unclaimed source extensions.
+ */
+function registerExtraFileTypes(docRegistry) {
+    for (const extension of EXTRA_FILE_TYPE_EXTENSIONS) {
+        const icon = getSpecificTreeIcon(`file${extension}`);
+        if (icon === null) {
+            continue;
+        }
+        const claimed = docRegistry
+            .getFileTypesForPath(`file${extension}`)
+            .some(fileType => { var _a; return (_a = fileType.extensions) === null || _a === void 0 ? void 0 : _a.some(e => e.toLowerCase() === extension); });
+        if (claimed) {
+            continue;
+        }
+        docRegistry.addFileType({
+            name: `xtralab:file-type:${extension.slice(1)}`,
+            extensions: [extension],
+            icon,
+            contentType: 'file',
+            fileFormat: 'text'
+        });
+    }
+}
+/**
+ * Share the file browser's tree glyphs with tabs and git file lists.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: "Gives the file browser's @pierre/trees glyphs to document tabs, the default file browser, and the git status panel.",
+    autoStart: true,
+    optional: [IDocumentWidgetOpener, IGitExtension],
+    activate: (app, opener, gitExtension) => {
+        const { docRegistry } = app;
+        for (const fileType of docRegistry.fileTypes()) {
+            applyTreeIcon(fileType);
+        }
+        registerExtraFileTypes(docRegistry);
+        // Pick up file types registered after this plugin activates.
+        docRegistry.changed.connect((_, args) => {
+            if (args.type === 'fileType' &&
+                args.change === 'added' &&
+                args.name !== undefined) {
+                const fileType = docRegistry.getFileType(args.name);
+                if (fileType !== undefined) {
+                    applyTreeIcon(fileType);
+                }
+            }
+        });
+        if (opener !== null) {
+            opener.opened.connect((_, widget) => {
+                const setIcon = () => {
+                    const icon = getSpecificTreeIcon(widget.context.path);
+                    if (icon !== null) {
+                        widget.title.icon = icon;
+                    }
+                };
+                setIcon();
+                // Keep the tab icon right after a rename.
+                widget.context.pathChanged.connect(setIcon);
+            });
+        }
+        if (gitExtension !== null) {
+            gitExtension.statusChanged.connect((_, status) => {
+                for (const file of status.files) {
+                    if (file.type === undefined) {
+                        continue;
+                    }
+                    const icon = getSpecificTreeIcon(file.to);
+                    if (icon === null) {
+                        continue;
+                    }
+                    // Cross jupyterlab-git's nested `LabIcon` package boundary.
+                    file.type = { ...file.type, icon };
+                }
+            });
+        }
+    }
+};
+export default plugin;

package/lib/git/commands.d.ts

@@ -1,23 +1,18 @@
 import { JupyterFrontEnd } from '@jupyterlab/application';
-import { IThemeManager } from '@jupyterlab/apputils';
+import { IThemeManager, MainAreaWidget } from '@jupyterlab/apputils';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { Contents } from '@jupyterlab/services';
-import { createGitDiffWidget, diffWidgetId } from './diffWidget';
+import { ISignal } from '@lumino/signaling';
+import { XtralabDiffWidget } from './diffWidget';
 import { IFileChange } from './tokens';
 /**
- * Command IDs exposed by the launcher's git diff path. The launcher
- * dashboard's "Changes" section drives {@link CommandIDs.openDiff} to open
- * its own diff tab, independent of `jupyterlab-git` (whose panel reaches
- * the same rendering via the providers in `diffProvider.tsx`).
+ * Command IDs exposed by the launcher's git diff path.
  */
 export declare namespace CommandIDs {
     const openDiff = "xtralab:git:open-diff";
 }
 /**
- * Argument shapes used by {@link CommandIDs.openDiff}. Cast to this type
- * inside the execute callback for type safety; the registry itself takes
- * `ReadonlyPartialJSONObject` because Lumino does not know about our
- * extension-specific shapes.
+ * Argument shapes used by {@link CommandIDs.openDiff}.
  */
 export declare namespace CommandArguments {
     interface IOpenDiff {
@@ -26,45 +21,51 @@ export declare namespace CommandArguments {
         pin?: boolean;
     }
 }
+/**
+ * Widget id of the single, reused preview diff tab.
+ */
+export declare const PREVIEW_DIFF_WIDGET_ID = "xtralab:diff:preview";
+/**
+ * Deterministic widget id for a pinned file/group pair.
+ */
+export declare function pinnedDiffWidgetId(change: IFileChange): string;
+/**
+ * Launcher-owned host for a shared diff widget.
+ */
+export declare class DiffMainAreaWidget extends MainAreaWidget<XtralabDiffWidget> {
+    constructor(options: MainAreaWidget.IOptions<XtralabDiffWidget>, change: IFileChange, pinned: boolean);
+    get change(): IFileChange;
+    get pinned(): boolean;
+    pin(): void;
+    get pinnedChanged(): ISignal<this, boolean>;
+    setChange(repoPath: string, change: IFileChange): void;
+    private _change;
+    private _pinned;
+    private _pinnedChanged;
+}
 export interface IRegisterGitCommandsOptions {
     app: JupyterFrontEnd;
     themeManager: IThemeManager | null;
     /**
-     * Contents manager used by the diff widget to write hunk-discard
-     * results back to the working tree.
+     * Contents manager used to write hunk-discard results.
      */
     contentsManager: Contents.IManager;
     /**
-     * Rendermime registry used by the notebook diff to render outputs and
-     * markdown cells with their actual mime-type renderers (images as
-     * images, HTML as HTML, etc.). May be `null` in stripped-down hosts —
-     * the notebook diff falls back to a text representation in that case.
+     * Rendermime registry used by notebook diffs; may be `null`.
      */
     rendermime: IRenderMimeRegistry | null;
     /**
-     * Called whenever the diff widget mutates the working tree (e.g. after
-     * a hunk discard). The launcher dashboard polls git status on its own
-     * cadence and `jupyterlab-git`'s panel auto-refreshes on the contents
-     * `fileChanged` signal the save emits, so this is a hook for any extra
-     * bookkeeping rather than a required refresh.
-     */
-    onChanged: () => void;
-    /**
-     * Called for every diff widget created via the {@link CommandIDs.openDiff}
-     * command, before the widget is added to the shell. Lets the plugin track
-     * the widget for layout restoration and reveal-on-reuse.
+     * Track newly created diff widgets before they are added to the shell.
      */
-    trackDiff(widget: ReturnType<typeof createGitDiffWidget>): Promise<void>;
+    trackDiff(widget: DiffMainAreaWidget): Promise<void>;
     /**
-     * Look up an already-open diff widget for a given file change. Returns
-     * `undefined` when none is open.
+     * Look up an already-open diff widget for a file change.
      */
-    findDiff(change: IFileChange, pin?: boolean): ReturnType<typeof createGitDiffWidget> | undefined;
-    onPinned(widget: ReturnType<typeof createGitDiffWidget>): void;
+    findDiff(change: IFileChange, pin?: boolean): DiffMainAreaWidget | undefined;
+    onPinned(widget: DiffMainAreaWidget): void;
 }
 /**
  * Register the launcher's git diff command on the application command
  * registry.
  */
 export declare function registerGitCommands(options: IRegisterGitCommandsOptions): void;
-export { diffWidgetId };