@plmbr/notebook-intelligence 5.0.0

package/lib/cell-output-bundle.d.ts

@@ -0,0 +1,25 @@
+import { CodeCell } from '@jupyterlab/cells';
+import { IOutputContextItem } from './tokens';
+export declare const MAX_TOKENS_PER_OUTPUT = 4000;
+export declare const MAX_TOKENS_PER_TURN = 8000;
+export type IMimeBundle = IOutputContextItem['mimeBundles'][number];
+export type IOutputContextBundle = IOutputContextItem;
+export interface IBundleOptions {
+    maxTokensPerOutput?: number;
+    maxTokensPerTurn?: number;
+    supportsVision?: boolean;
+}
+interface ICellLike {
+    outputArea: {
+        model: {
+            toJSON: () => any[];
+        };
+    };
+    model?: {
+        sharedModel?: {
+            getSource: () => string;
+        };
+    };
+}
+export declare function cellOutputAsContextBundle(cell: CodeCell | ICellLike, opts?: IBundleOptions): IOutputContextBundle;
+export {};

package/lib/cell-output-bundle.js

@@ -0,0 +1,129 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { formatJupyterError, joinMultilineString, truncateToTokenCount } from './utils';
+export const MAX_TOKENS_PER_OUTPUT = 4000;
+export const MAX_TOKENS_PER_TURN = 8000;
+// Above this raw base64 length (~150 KiB decoded), we drop the image and
+// emit a placeholder rather than blow up the context window.
+const MAX_IMAGE_BASE64_BYTES = 200000;
+export function cellOutputAsContextBundle(cell, opts = {}) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const maxOut = (_a = opts.maxTokensPerOutput) !== null && _a !== void 0 ? _a : MAX_TOKENS_PER_OUTPUT;
+    const maxTurn = (_b = opts.maxTokensPerTurn) !== null && _b !== void 0 ? _b : MAX_TOKENS_PER_TURN;
+    const supportsVision = (_c = opts.supportsVision) !== null && _c !== void 0 ? _c : false;
+    const cellLike = cell;
+    const cellSource = (_f = (_e = (_d = cellLike.model) === null || _d === void 0 ? void 0 : _d.sharedModel) === null || _e === void 0 ? void 0 : _e.getSource()) !== null && _f !== void 0 ? _f : '';
+    const outputs = cellLike.outputArea.model.toJSON();
+    const mimeBundles = [];
+    let truncated = false;
+    let isError = false;
+    let totalTokens = 0;
+    const remaining = () => Math.max(0, maxTurn - totalTokens);
+    const pushBundle = (mimeType, data) => {
+        const perOutCap = Math.min(maxOut, remaining());
+        const { text, size, truncated: didTruncate } = truncateToTokenCount(data, perOutCap);
+        if (didTruncate) {
+            truncated = true;
+        }
+        if (size === 0 && text.length === 0) {
+            return;
+        }
+        mimeBundles.push({ mimeType, data: text, sizeTokens: size });
+        totalTokens += size;
+    };
+    for (const output of outputs) {
+        if (remaining() === 0) {
+            truncated = true;
+            break;
+        }
+        if (output.output_type === 'error') {
+            isError = true;
+            pushBundle('application/vnd.jupyter.error', formatJupyterError(output));
+            continue;
+        }
+        if (output.output_type === 'stream') {
+            pushBundle('text/plain', joinMultilineString(output.text));
+            continue;
+        }
+        // execute_result and display_data
+        const data = ((_g = output.data) !== null && _g !== void 0 ? _g : {});
+        // DataFrames render as both text/html and text/plain; prefer the plain
+        // form — it's the formatted ASCII table, cheaper, and an LLM reads it
+        // just fine. text/html alone is stripped to plain text below.
+        // Use ``in`` rather than truthy check: an empty array ``[]`` is legal
+        // (if rare) nbformat for ``text/plain`` but falsy in JS, which would
+        // otherwise let the html branch fire over an explicit-but-empty plain
+        // entry.
+        if ('text/plain' in data) {
+            pushBundle('text/plain', joinMultilineString(data['text/plain']));
+        }
+        else if ('text/html' in data) {
+            pushBundle('text/html', stripHtml(joinMultilineString(data['text/html'])));
+        }
+        if (data['application/vnd.plotly.v1+json']) {
+            pushBundle('application/vnd.plotly.v1+json', summarizePlotly(data['application/vnd.plotly.v1+json']));
+        }
+        else if (data['application/json']) {
+            pushBundle('application/json', JSON.stringify(data['application/json'], null, 2));
+        }
+        for (const imgMime of ['image/png', 'image/jpeg']) {
+            if (!data[imgMime]) {
+                continue;
+            }
+            const raw = joinMultilineString(data[imgMime]);
+            if (!supportsVision) {
+                pushBundle(imgMime, '<image omitted: model lacks vision support>');
+            }
+            else if (raw.length > MAX_IMAGE_BASE64_BYTES) {
+                pushBundle(imgMime, '<image omitted: too large for inline attachment>');
+                truncated = true;
+            }
+            else if (!isValidBase64(raw)) {
+                pushBundle(imgMime, '<image omitted: invalid base64 payload>');
+            }
+            else {
+                // Send raw base64; the server constructs the data URL after
+                // re-validating, so a forged POST can't inject markdown.
+                pushBundle(imgMime, raw);
+            }
+        }
+    }
+    return { cellSource, mimeBundles, isError, truncated };
+}
+function isValidBase64(s) {
+    // Standard base64 alphabet only. No URL-safe chars; no characters that
+    // could break out of a markdown image URL on the server side.
+    const compact = s.replace(/\s+/g, '');
+    return /^[A-Za-z0-9+/]+=*$/.test(compact);
+}
+function stripHtml(html) {
+    // NOTE: not a sanitizer. Output is intended only for LLM context; never
+    // route this back into the DOM without a real sanitizer.
+    // Replace block-level closers with a newline so structure survives, then
+    // strip the remaining tags. Cheap and good enough for LLM consumption.
+    return html
+        .replace(/<\/(p|div|tr|li|h[1-6]|br)\s*\/?>/gi, '\n')
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<[^>]+>/g, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function summarizePlotly(payload) {
+    var _a, _b, _c, _d, _e, _f;
+    const lines = [];
+    const traces = Array.isArray(payload === null || payload === void 0 ? void 0 : payload.data) ? payload.data : [];
+    const types = traces.map((t) => { var _a; return (_a = t === null || t === void 0 ? void 0 : t.type) !== null && _a !== void 0 ? _a : 'trace'; }).join(', ');
+    if (types) {
+        lines.push(`Plotly figure traces: ${types}`);
+    }
+    const layout = (_a = payload === null || payload === void 0 ? void 0 : payload.layout) !== null && _a !== void 0 ? _a : {};
+    if ((_b = layout.title) === null || _b === void 0 ? void 0 : _b.text) {
+        lines.push(`Title: ${layout.title.text}`);
+    }
+    if ((_d = (_c = layout.xaxis) === null || _c === void 0 ? void 0 : _c.title) === null || _d === void 0 ? void 0 : _d.text) {
+        lines.push(`X axis: ${layout.xaxis.title.text}`);
+    }
+    if ((_f = (_e = layout.yaxis) === null || _e === void 0 ? void 0 : _e.title) === null || _f === void 0 ? void 0 : _f.text) {
+        lines.push(`Y axis: ${layout.yaxis.title.text}`);
+    }
+    return lines.join('\n');
+}

package/lib/cell-output-toolbar.d.ts

@@ -0,0 +1,26 @@
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { CommandRegistry } from '@lumino/commands';
+import { IDisposable } from '@lumino/disposable';
+/**
+ * Show a hover toolbar over Jupyter cell outputs that surfaces the existing
+ * Explain / Ask / Troubleshoot commands as one-click buttons.
+ *
+ * The toolbar respects the `output_toolbar` feature flag (whole-toolbar
+ * gate) and the per-action `explain_error` / `output_followup` flags so a
+ * locked-off feature stays locked off here too.
+ */
+export declare class CellOutputHoverToolbar implements IDisposable {
+    private _app;
+    private _commands;
+    private _disposed;
+    private _activeArea;
+    private _onMouseOver;
+    private _onMouseLeave;
+    constructor(app: JupyterFrontEnd, commands: CommandRegistry);
+    get isDisposed(): boolean;
+    dispose(): void;
+    private _handleMouseOver;
+    private _removeActiveToolbar;
+    private _locateCell;
+    private _buildToolbar;
+}

package/lib/cell-output-toolbar.js

@@ -0,0 +1,188 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { CodeCell } from '@jupyterlab/cells';
+import { NotebookPanel } from '@jupyterlab/notebook';
+import { LabIcon } from '@jupyterlab/ui-components';
+import { NBIAPI } from './api';
+import { cellOutputHasError } from './utils';
+import sparkleSvgstr from '../style/icons/cell-toolbar-sparkle.svg';
+import chatSvgstr from '../style/icons/cell-toolbar-chat.svg';
+import bugSvgstr from '../style/icons/cell-toolbar-bug.svg';
+const TOOLBAR_CLASS = 'nbi-cell-output-toolbar';
+const BUTTON_CLASS = 'nbi-cell-output-toolbar-button';
+// SVGs live under style/icons/ and are loaded via LabIcon to match the rest
+// of the project's icon plumbing. The source assets are Microsoft's
+// vscode-codicons (sparkle, comment-discussion, bug), CC BY 4.0 — the
+// license header lives inside each .svg file.
+const sparkleIcon = new LabIcon({
+    name: 'notebook-intelligence:cell-toolbar-sparkle',
+    svgstr: sparkleSvgstr
+});
+const chatIcon = new LabIcon({
+    name: 'notebook-intelligence:cell-toolbar-chat',
+    svgstr: chatSvgstr
+});
+const bugIcon = new LabIcon({
+    name: 'notebook-intelligence:cell-toolbar-bug',
+    svgstr: bugSvgstr
+});
+const ACTIONS = [
+    {
+        id: 'explain',
+        label: 'Explain',
+        title: "Explain this cell's output",
+        icon: sparkleIcon,
+        command: 'notebook-intelligence:editor-explain-this-output',
+        featureFlag: 'output_followup'
+    },
+    {
+        id: 'ask',
+        label: 'Ask',
+        title: 'Ask about this output',
+        icon: chatIcon,
+        command: 'notebook-intelligence:editor-ask-about-this-output',
+        featureFlag: 'output_followup'
+    },
+    {
+        id: 'troubleshoot',
+        label: 'Troubleshoot',
+        title: 'Troubleshoot the error in this cell',
+        icon: bugIcon,
+        command: 'notebook-intelligence:editor-troubleshoot-this-output',
+        featureFlag: 'explain_error',
+        requireError: true
+    }
+];
+/**
+ * Show a hover toolbar over Jupyter cell outputs that surfaces the existing
+ * Explain / Ask / Troubleshoot commands as one-click buttons.
+ *
+ * The toolbar respects the `output_toolbar` feature flag (whole-toolbar
+ * gate) and the per-action `explain_error` / `output_followup` flags so a
+ * locked-off feature stays locked off here too.
+ */
+export class CellOutputHoverToolbar {
+    constructor(app, commands) {
+        this._disposed = false;
+        this._activeArea = null;
+        this._app = app;
+        // The Explain / Ask / Troubleshoot commands live on the context-menu's
+        // private CommandRegistry, not on `app.commands`, so callers must pass
+        // the same registry the menu uses.
+        this._commands = commands;
+        this._onMouseOver = this._handleMouseOver.bind(this);
+        // mouseleave only fires when the cursor exits the area entirely —
+        // descendants (including the toolbar itself) don't trigger it.
+        this._onMouseLeave = this._removeActiveToolbar.bind(this);
+        document.body.addEventListener('mouseover', this._onMouseOver);
+    }
+    get isDisposed() {
+        return this._disposed;
+    }
+    dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        document.body.removeEventListener('mouseover', this._onMouseOver);
+        this._removeActiveToolbar();
+    }
+    _handleMouseOver(event) {
+        if (!NBIAPI.config.cellOutputFeatures.output_toolbar.enabled) {
+            this._removeActiveToolbar();
+            return;
+        }
+        const target = event.target;
+        if (!target) {
+            return;
+        }
+        const area = target.closest('.jp-Cell-outputArea');
+        if (!area) {
+            return;
+        }
+        if (area === this._activeArea) {
+            return;
+        }
+        this._removeActiveToolbar();
+        const cellEl = area.closest('.jp-Cell');
+        if (!cellEl) {
+            return;
+        }
+        const located = this._locateCell(cellEl);
+        if (!located) {
+            return;
+        }
+        const toolbar = this._buildToolbar(located.panel, located.cellIndex, located.cell);
+        if (!toolbar) {
+            return;
+        }
+        area.appendChild(toolbar);
+        this._activeArea = area;
+        area.addEventListener('mouseleave', this._onMouseLeave);
+    }
+    _removeActiveToolbar() {
+        if (!this._activeArea) {
+            return;
+        }
+        this._activeArea.removeEventListener('mouseleave', this._onMouseLeave);
+        const existing = this._activeArea.querySelector(`.${TOOLBAR_CLASS}`);
+        if (existing) {
+            existing.remove();
+        }
+        this._activeArea = null;
+    }
+    _locateCell(cellEl) {
+        const widget = this._app.shell.currentWidget;
+        if (!(widget instanceof NotebookPanel)) {
+            return null;
+        }
+        const widgets = widget.content.widgets;
+        for (let i = 0; i < widgets.length; i++) {
+            const cell = widgets[i];
+            if (cell.node === cellEl && cell instanceof CodeCell) {
+                return { panel: widget, cell, cellIndex: i };
+            }
+        }
+        return null;
+    }
+    _buildToolbar(panel, cellIndex, cell) {
+        const features = NBIAPI.config.cellOutputFeatures;
+        const hasError = cellOutputHasError(cell);
+        const visible = ACTIONS.filter(a => {
+            if (!features[a.featureFlag].enabled) {
+                return false;
+            }
+            if (a.requireError && !hasError) {
+                return false;
+            }
+            return true;
+        });
+        if (visible.length === 0) {
+            return null;
+        }
+        const toolbar = document.createElement('div');
+        toolbar.className = TOOLBAR_CLASS;
+        toolbar.setAttribute('role', 'toolbar');
+        toolbar.setAttribute('aria-label', 'Notebook Intelligence cell actions');
+        for (const action of visible) {
+            const button = document.createElement('button');
+            button.type = 'button';
+            button.className = BUTTON_CLASS;
+            button.title = action.title;
+            button.setAttribute('aria-label', action.title);
+            action.icon.element({ container: button, tag: 'span' });
+            const label = document.createElement('span');
+            label.className = `${BUTTON_CLASS}-label`;
+            label.textContent = action.label;
+            button.appendChild(label);
+            button.addEventListener('click', event => {
+                event.stopPropagation();
+                // The editor commands act on the active cell, so activate the
+                // hovered one first.
+                panel.content.activeCellIndex = cellIndex;
+                void this._commands.execute(action.command);
+            });
+            toolbar.appendChild(button);
+        }
+        return toolbar;
+    }
+}

package/lib/chat-progress-feedback.d.ts

@@ -0,0 +1,3 @@
+export declare const HEARTBEAT_STALE_MS = 30000;
+export declare function formatElapsedSeconds(totalSeconds: number): string;
+export declare function isHeartbeatStale(lastHeartbeatAt: number | null, now: number, staleMs?: number): boolean;

package/lib/chat-progress-feedback.js

@@ -0,0 +1,27 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+// Small helpers for the chat sidebar's "Generating" progress indicator.
+// Pulled out so each piece (elapsed-time formatting, heartbeat staleness)
+// can be unit-tested without dragging JupyterLab into Jest's import graph.
+// 30 seconds without a heartbeat counts as "stalled" — long enough that a
+// healthy round-trip + retransmission delay can't account for it, short
+// enough that a real hang is signaled while there's still time to act.
+// The Claude heartbeat fires every 20s server-side, so 30s gives roughly
+// 1.5 expected intervals of slack before we change copy.
+export const HEARTBEAT_STALE_MS = 30000;
+export function formatElapsedSeconds(totalSeconds) {
+    const safe = Math.max(0, Math.floor(totalSeconds));
+    const hours = Math.floor(safe / 3600);
+    const minutes = Math.floor((safe % 3600) / 60);
+    const seconds = safe % 60;
+    const ss = String(seconds).padStart(2, '0');
+    if (hours > 0) {
+        return `${hours}:${String(minutes).padStart(2, '0')}:${ss}`;
+    }
+    return `${minutes}:${ss}`;
+}
+export function isHeartbeatStale(lastHeartbeatAt, now, staleMs = HEARTBEAT_STALE_MS) {
+    if (lastHeartbeatAt === null) {
+        return false;
+    }
+    return now - lastHeartbeatAt > staleMs;
+}

package/lib/chat-sidebar.d.ts

@@ -0,0 +1,92 @@
+import React from 'react';
+import { ReactWidget } from '@jupyterlab/apputils';
+import { IActiveDocumentInfo, ICellContents, IContextItem, ITelemetryEmitter, IToolSelections } from './tokens';
+import { JupyterFrontEnd } from '@jupyterlab/application';
+export declare enum RunChatCompletionType {
+    Chat = 0,
+    ExplainThis = 1,
+    FixThis = 2,
+    GenerateCode = 3,
+    NotebookGeneration = 4
+}
+export interface IRunChatCompletionRequest {
+    messageId: string;
+    chatId: string;
+    type: RunChatCompletionType;
+    content: string;
+    language?: string;
+    currentDirectory?: string;
+    filename?: string;
+    prefix?: string;
+    suffix?: string;
+    existingCode?: string;
+    additionalContext?: IContextItem[];
+    chatMode: string;
+    toolSelections?: IToolSelections;
+    externalRequestId?: string;
+    hideInChat?: boolean;
+}
+export interface IChatSidebarOptions {
+    getCurrentDirectory: () => string;
+    getActiveDocumentInfo: () => IActiveDocumentInfo;
+    getActiveSelectionContent: () => string;
+    getCurrentCellContents: () => ICellContents;
+    openFile: (path: string) => void;
+    getApp: () => JupyterFrontEnd;
+    getTelemetryEmitter: () => ITelemetryEmitter;
+}
+export declare class ChatSidebar extends ReactWidget {
+    constructor(options: IChatSidebarOptions);
+    render(): JSX.Element;
+    private _options;
+}
+export interface IInlinePromptWidgetOptions {
+    prompt: string;
+    existingCode: string;
+    prefix: string;
+    suffix: string;
+    language?: string;
+    filename?: string;
+    onRequestSubmitted: (prompt: string) => void;
+    onRequestCancelled: () => void;
+    onContentStream: (content: string) => void;
+    onContentStreamEnd: (streamError?: string | null) => void;
+    onUpdatedCodeChange: (content: string) => void;
+    onUpdatedCodeAccepted: () => void;
+    telemetryEmitter: ITelemetryEmitter;
+}
+export declare class InlinePromptWidget extends ReactWidget {
+    constructor(rect: DOMRect | null, options: IInlinePromptWidgetOptions);
+    updatePosition(rect: DOMRect): void;
+    _onResponse(response: any): void;
+    _onRequestSubmitted(prompt: string): void;
+    render(): JSX.Element;
+    private _options;
+    private _requestTime;
+    private _streamError;
+    private _floating;
+}
+export declare class GitHubCopilotStatusBarItem extends ReactWidget {
+    constructor(options: {
+        getApp: () => JupyterFrontEnd;
+    });
+    render(): JSX.Element;
+    private _getApp;
+}
+export declare class GitHubCopilotLoginDialogBody extends ReactWidget {
+    constructor(options: {
+        onLoggedIn: () => void;
+    });
+    render(): JSX.Element;
+    private _onLoggedIn;
+}
+export declare function InlinePopoverComponent(props: any): React.JSX.Element;
+export declare class FormInputDialogBody extends ReactWidget {
+    constructor(options: {
+        fields: any;
+        onDone: (formData: any) => void;
+    });
+    render(): JSX.Element;
+    private _fields;
+    private _onDone;
+}