@plmbr/notebook-intelligence 5.0.0

package/lib/task-target-notebook.js

@@ -0,0 +1,28 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { CommandIDs } from './command-ids';
+// Cell-targeting commands accept an optional `notebookPath` to bypass
+// `app.shell.currentWidget`. When the agent runs a task and the user
+// switches tabs mid-run, the previously-active notebook is no longer the
+// focused widget; the chat sidebar injects the captured task-target path
+// into args for these command IDs so cell ops resolve against the right
+// notebook (issue #252). Built from `CommandIDs` so a rename on either
+// side is caught at compile time.
+export const NOTEBOOK_TARGETED_COMMAND_IDS = new Set([
+    CommandIDs.addMarkdownCellToActiveNotebook,
+    CommandIDs.addCodeCellToActiveNotebook,
+    CommandIDs.getCellTypeAndSource,
+    CommandIDs.setCellTypeAndSource,
+    CommandIDs.getNumberOfCells,
+    CommandIDs.getCellOutput,
+    CommandIDs.insertCellAtIndex,
+    CommandIDs.deleteCellAtIndex,
+    CommandIDs.runCellAtIndex
+]);
+export function injectTaskTargetNotebook(commandId, args, taskTargetPath) {
+    if (!taskTargetPath ||
+        !NOTEBOOK_TARGETED_COMMAND_IDS.has(commandId) ||
+        (args && args.notebookPath)) {
+        return args;
+    }
+    return { ...(args !== null && args !== void 0 ? args : {}), notebookPath: taskTargetPath };
+}

package/lib/terminal-drag-format.d.ts

@@ -0,0 +1,9 @@
+export type DragMode = 'mention' | 'raw';
+/**
+ * Format a list of paths for injection per mode. @-mention prefixes each
+ * path with "@" (Claude Code syntax, no quoting); raw mode shell-escapes
+ * absolute paths for non-Claude shell sessions. Single-space separator
+ * is intentional; the trailing space is appended by the caller.
+ */
+export declare function formatForMode(paths: string[], mode: DragMode): string;
+export declare function invertMode(mode: DragMode, shouldInvert: boolean): DragMode;

package/lib/terminal-drag-format.js

@@ -0,0 +1,23 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+// Pure helpers extracted from `terminal-drag.ts` so they can be unit
+// tested without JupyterLab / Lumino imports (which pull DOM globals
+// that jsdom doesn't provide, like DragEvent).
+import { shellSingleQuote } from './shell-utils';
+/**
+ * Format a list of paths for injection per mode. @-mention prefixes each
+ * path with "@" (Claude Code syntax, no quoting); raw mode shell-escapes
+ * absolute paths for non-Claude shell sessions. Single-space separator
+ * is intentional; the trailing space is appended by the caller.
+ */
+export function formatForMode(paths, mode) {
+    if (mode === 'mention') {
+        return paths.map(p => `@${p}`).join(' ');
+    }
+    return paths.map(shellSingleQuote).join(' ');
+}
+export function invertMode(mode, shouldInvert) {
+    if (!shouldInvert) {
+        return mode;
+    }
+    return mode === 'mention' ? 'raw' : 'mention';
+}

package/lib/terminal-drag.d.ts

@@ -0,0 +1,12 @@
+export type { DragMode } from './terminal-drag-format';
+export { formatForMode, invertMode } from './terminal-drag-format';
+export interface ITerminalDragOptions {
+    tracker: unknown;
+    /**
+     * Re-evaluated on each event so flipping the admin policy at runtime
+     * (e.g. force-off via env at next reload) takes effect on listeners
+     * that are already wired without needing to tear them down.
+     */
+    isEnabled: () => boolean;
+}
+export declare function attachTerminalDragDrop(options: ITerminalDragOptions): void;

package/lib/terminal-drag.js

@@ -0,0 +1,268 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { Notification } from '@jupyterlab/apputils';
+import { Widget } from '@lumino/widgets';
+import { NBIAPI } from './api';
+import { formatForMode, invertMode } from './terminal-drag-format';
+export { formatForMode, invertMode } from './terminal-drag-format';
+// File-browser drag dispatches a Lumino lm-drop event carrying paths
+// under this MIME (see node_modules/@jupyterlab/filebrowser/lib/listing.js).
+const FILE_BROWSER_MIME = 'application/x-jupyter-icontents';
+const DRAG_OVER_CLASS = 'nbi-terminal-drag-over';
+const TOOLBAR_BUTTON_CLASS = 'nbi-terminal-drag-mode-button';
+const widgetState = new WeakMap();
+export function attachTerminalDragDrop(options) {
+    const tracker = options.tracker;
+    const { isEnabled } = options;
+    const wire = (widget) => {
+        if (widgetState.has(widget)) {
+            return;
+        }
+        setupTerminal(widget, isEnabled);
+    };
+    tracker.forEach(wire);
+    tracker.widgetAdded.connect((_, widget) => wire(widget));
+}
+function setupTerminal(widget, isEnabled) {
+    const host = widget.node;
+    const state = {
+        mode: 'mention',
+        dragDepth: 0,
+        cleanup: () => { }
+    };
+    const inject = (paths, shiftHeld) => {
+        var _a;
+        if (paths.length === 0) {
+            return;
+        }
+        // Async upload paths can finish after the terminal is closed; calling
+        // paste on a disposed Lumino Widget throws.
+        if (widget.isDisposed) {
+            return;
+        }
+        const effectiveMode = invertMode(state.mode, shiftHeld);
+        widget.content.paste(`${formatForMode(paths, effectiveMode)} `);
+        // Activate the outer MainAreaWidget so the terminal also gets raised
+        // if it's a background tab in a split. Otherwise the next keystroke
+        // goes to the file-browser (Enter would "open the selected file") or
+        // to whichever surface held focus before the drag.
+        (_a = widget.activate) === null || _a === void 0 ? void 0 : _a.call(widget);
+    };
+    const handleDragEnter = (event) => {
+        if (!isEnabled() || !event.dataTransfer) {
+            return;
+        }
+        if (!event.dataTransfer.types.includes('Files')) {
+            return;
+        }
+        state.dragDepth += 1;
+        host.classList.add(DRAG_OVER_CLASS);
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    };
+    const handleDragOver = (event) => {
+        if (!isEnabled() || !event.dataTransfer) {
+            return;
+        }
+        if (!event.dataTransfer.types.includes('Files')) {
+            return;
+        }
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        event.dataTransfer.dropEffect = 'copy';
+    };
+    const handleDragLeave = (event) => {
+        if (!isEnabled()) {
+            return;
+        }
+        state.dragDepth = Math.max(0, state.dragDepth - 1);
+        if (state.dragDepth === 0) {
+            host.classList.remove(DRAG_OVER_CLASS);
+        }
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    };
+    const handleDrop = (event) => {
+        if (!isEnabled()) {
+            return;
+        }
+        state.dragDepth = 0;
+        host.classList.remove(DRAG_OVER_CLASS);
+        if (!event.dataTransfer) {
+            return;
+        }
+        const files = Array.from(event.dataTransfer.files);
+        if (files.length === 0) {
+            return;
+        }
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        const shiftHeld = event.shiftKey;
+        void uploadAndInject(files, shiftHeld, inject);
+    };
+    // Lumino dispatches lm-* events on the deepest DOM element under the
+    // cursor. Listening on `host` would in theory catch the bubble, but
+    // intermediate widgets (e.g. xterm's viewport) can call
+    // stopPropagation in a target-phase handler before we see it. Listening
+    // at the document level with a containment check is the most reliable
+    // way to observe a drop that's geometrically inside this terminal.
+    const isInsideHost = (event) => {
+        const target = event.target;
+        return target instanceof Node && host.contains(target);
+    };
+    const handleLuminoDragEnter = (event) => {
+        if (!isEnabled() || !hasFileBrowserPaths(event) || !isInsideHost(event)) {
+            return;
+        }
+        state.dragDepth += 1;
+        host.classList.add(DRAG_OVER_CLASS);
+        event.preventDefault();
+        event.stopPropagation();
+    };
+    const handleLuminoDragOver = (event) => {
+        if (!isEnabled() || !hasFileBrowserPaths(event) || !isInsideHost(event)) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        // Echo the source's proposedAction back as dropAction. The file
+        // browser starts its Drag with supportedActions: 'move', so a
+        // hardcoded 'copy' falls through validateAction to 'none' and
+        // Lumino skips lm-drop on pointerup. Mirroring proposedAction keeps
+        // us inside whatever the source supports.
+        const dragEvent = event;
+        dragEvent.dropAction = dragEvent.proposedAction || 'move';
+    };
+    const handleLuminoDragLeave = (event) => {
+        if (!isEnabled() || !isInsideHost(event)) {
+            return;
+        }
+        state.dragDepth = Math.max(0, state.dragDepth - 1);
+        if (state.dragDepth === 0) {
+            host.classList.remove(DRAG_OVER_CLASS);
+        }
+        event.preventDefault();
+        event.stopPropagation();
+    };
+    const handleLuminoDrop = (event) => {
+        if (!isEnabled() || !hasFileBrowserPaths(event) || !isInsideHost(event)) {
+            return;
+        }
+        const dragEvent = event;
+        const paths = dragEvent.mimeData.getData(FILE_BROWSER_MIME);
+        if (!Array.isArray(paths) || paths.length === 0) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        dragEvent.dropAction = dragEvent.proposedAction || 'move';
+        state.dragDepth = 0;
+        host.classList.remove(DRAG_OVER_CLASS);
+        inject(paths.filter((p) => typeof p === 'string'), dragEvent.shiftKey);
+    };
+    host.addEventListener('dragenter', handleDragEnter, true);
+    host.addEventListener('dragover', handleDragOver, true);
+    host.addEventListener('dragleave', handleDragLeave, true);
+    host.addEventListener('drop', handleDrop, true);
+    // lm-* listeners go on the document (capture phase) so we observe
+    // them before any intermediate widget can stopPropagation. The
+    // containment check filters to events whose target is inside this
+    // terminal's host node.
+    document.addEventListener('lm-dragenter', handleLuminoDragEnter, true);
+    document.addEventListener('lm-dragover', handleLuminoDragOver, true);
+    document.addEventListener('lm-dragleave', handleLuminoDragLeave, true);
+    document.addEventListener('lm-drop', handleLuminoDrop, true);
+    const button = new TerminalDragModeButton('mention', () => {
+        state.mode = state.mode === 'mention' ? 'raw' : 'mention';
+        button.setMode(state.mode);
+    });
+    widget.toolbar.addItem('nbi-terminal-drag-mode', button);
+    state.cleanup = () => {
+        host.removeEventListener('dragenter', handleDragEnter, true);
+        host.removeEventListener('dragover', handleDragOver, true);
+        host.removeEventListener('dragleave', handleDragLeave, true);
+        host.removeEventListener('drop', handleDrop, true);
+        document.removeEventListener('lm-dragenter', handleLuminoDragEnter, true);
+        document.removeEventListener('lm-dragover', handleLuminoDragOver, true);
+        document.removeEventListener('lm-dragleave', handleLuminoDragLeave, true);
+        document.removeEventListener('lm-drop', handleLuminoDrop, true);
+    };
+    widget.disposed.connect(() => {
+        state.cleanup();
+        widgetState.delete(widget);
+    });
+    widgetState.set(widget, state);
+}
+function hasFileBrowserPaths(event) {
+    var _a;
+    const mimeData = event.mimeData;
+    return ((_a = mimeData === null || mimeData === void 0 ? void 0 : mimeData.hasData) === null || _a === void 0 ? void 0 : _a.call(mimeData, FILE_BROWSER_MIME)) === true;
+}
+async function uploadAndInject(files, shiftHeld, inject) {
+    const results = await Promise.allSettled(files.map(f => NBIAPI.uploadFile(f)));
+    const paths = [];
+    const failures = [];
+    results.forEach((result, index) => {
+        const file = files[index];
+        if (result.status === 'fulfilled') {
+            paths.push(result.value.serverPath);
+            return;
+        }
+        failures.push({
+            name: file.name,
+            reason: describeUploadError(result.reason)
+        });
+    });
+    if (failures.length > 0) {
+        // Inline in the toast so the user sees both what failed and why
+        // (e.g. 413 from the size cap). Truncated to 3 entries; rest collapsed
+        // into a "+ N more" footer to fit JL's 140-char notification limit.
+        const head = failures
+            .slice(0, 3)
+            .map(f => `${f.name}: ${f.reason}`)
+            .join('; ');
+        const tail = failures.length > 3 ? ` (+${failures.length - 3} more)` : '';
+        Notification.error(`Terminal drop upload failed for ${head}${tail}`);
+    }
+    inject(paths, shiftHeld);
+}
+function describeUploadError(reason) {
+    if (reason && typeof reason === 'object') {
+        const r = reason;
+        if (typeof r.message === 'string' && r.message.trim().length > 0) {
+            return r.message;
+        }
+        if (r.response && typeof r.response.status === 'number') {
+            return `HTTP ${r.response.status}`;
+        }
+    }
+    return String(reason);
+}
+class TerminalDragModeButton extends Widget {
+    constructor(initialMode, onToggle) {
+        super();
+        this.addClass('jp-Toolbar-item');
+        this.addClass(TOOLBAR_BUTTON_CLASS);
+        this._onToggle = onToggle;
+        this._button = document.createElement('button');
+        this._button.type = 'button';
+        this._button.classList.add('jp-ToolbarButtonComponent');
+        this._button.classList.add(`${TOOLBAR_BUTTON_CLASS}-toggle`);
+        this._button.addEventListener('click', () => this._onToggle());
+        this.node.appendChild(this._button);
+        this.setMode(initialMode);
+    }
+    setMode(mode) {
+        const isMention = mode === 'mention';
+        this._button.textContent = isMention ? '@' : '/';
+        this._button.setAttribute('aria-pressed', isMention ? 'false' : 'true');
+        // aria-label carries the full mode + Shift-modifier explanation;
+        // title is a short hover-tip so screen readers don't double-announce
+        // the same string from both attributes.
+        this._button.setAttribute('aria-label', isMention
+            ? 'Terminal drop inserts @-mention paths. Click to switch to raw path mode. Hold Shift while dropping to invert for one drop.'
+            : 'Terminal drop inserts raw, shell-escaped absolute paths. Click to switch to @-mention mode. Hold Shift while dropping to invert for one drop.');
+        this._button.title = isMention
+            ? 'Drop mode: @-mention'
+            : 'Drop mode: raw path';
+    }
+}

package/lib/tokens.d.ts

@@ -0,0 +1,149 @@
+import { Widget } from '@lumino/widgets';
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { Token } from '@lumino/coreutils';
+export interface IActiveDocumentInfo {
+    activeWidget: Widget | null;
+    language: string;
+    filename: string;
+    filePath: string;
+    activeCellIndex: number;
+    selection?: CodeEditor.IRange;
+}
+export interface IChatCompletionResponseEmitter {
+    emit: (response: any) => void;
+}
+export declare enum RequestDataType {
+    ChatRequest = "chat-request",
+    ChatUserInput = "chat-user-input",
+    ClearChatHistory = "clear-chat-history",
+    RunUICommandResponse = "run-ui-command-response",
+    GenerateCode = "generate-code",
+    CancelChatRequest = "cancel-chat-request",
+    InlineCompletionRequest = "inline-completion-request",
+    CancelInlineCompletionRequest = "cancel-inline-completion-request"
+}
+export declare enum BackendMessageType {
+    StreamMessage = "stream-message",
+    StreamEnd = "stream-end",
+    RunUICommand = "run-ui-command",
+    GitHubCopilotLoginStatusChange = "github-copilot-login-status-change",
+    MCPServerStatusChange = "mcp-server-status-change",
+    ClaudeCodeStatusChange = "claude-code-status-change",
+    ClaudeCodeHeartbeat = "claude-code-heartbeat",
+    SkillsReloaded = "skills-reloaded"
+}
+export declare enum ResponseStreamDataType {
+    LLMRaw = "llm-raw",
+    Markdown = "markdown",
+    MarkdownPart = "markdown-part",
+    Image = "image",
+    HTMLFrame = "html-frame",
+    Button = "button",
+    Anchor = "anchor",
+    Progress = "progress",
+    Confirmation = "confirmation",
+    AskUserQuestion = "ask-user-question"
+}
+export declare enum ContextType {
+    Custom = "custom",
+    CurrentFile = "current-file",
+    OutputContext = "output-context"
+}
+export interface IOutputContextItem {
+    cellSource: string;
+    mimeBundles: {
+        mimeType: string;
+        data: string;
+        sizeTokens: number;
+    }[];
+    isError: boolean;
+    truncated: boolean;
+}
+export declare enum MCPServerStatus {
+    NotConnected = "not-connected",
+    Connecting = "connecting",
+    Disconnecting = "disconnecting",
+    FailedToConnect = "failed-to-connect",
+    Connected = "connected",
+    UpdatingToolList = "updating-tool-list",
+    UpdatedToolList = "updated-tool-list",
+    UpdatingPromptList = "updating-prompt-list",
+    UpdatedPromptList = "updated-prompt-list"
+}
+export interface IContextItem {
+    type: ContextType;
+    content: string;
+    currentCellContents: ICellContents;
+    filePath?: string;
+    cellIndex?: number;
+    startLine?: number;
+    endLine?: number;
+    isImage?: boolean;
+    mimeType?: string;
+    outputContext?: IOutputContextItem;
+}
+export interface ICellContents {
+    input: string;
+    output: string;
+}
+export interface IChatParticipant {
+    id: string;
+    name: string;
+    description: string;
+    iconPath: string;
+    commands: string[];
+}
+export interface IToolSelections {
+    builtinToolsets?: string[];
+    mcpServers?: {
+        [key: string]: string[];
+    };
+    extensions?: {
+        [key: string]: string[];
+    };
+}
+export declare enum BuiltinToolsetType {
+    NotebookEdit = "nbi-notebook-edit",
+    NotebookExecute = "nbi-notebook-execute",
+    PythonFileEdit = "nbi-python-file-edit",
+    FileEdit = "nbi-file-edit",
+    FileRead = "nbi-file-read",
+    CommandExecute = "nbi-command-execute"
+}
+export declare const GITHUB_COPILOT_PROVIDER_ID = "github-copilot";
+export declare const CLAUDE_CODE_CHAT_PARTICIPANT_ID = "claude-code";
+export declare enum AssistantMode {
+    Default = "default",
+    Claude = "claude"
+}
+export declare enum TelemetryEventType {
+    InlineCompletionRequest = "inline-completion-request",
+    ExplainThisRequest = "explain-this-request",
+    FixThisCodeRequest = "fix-this-code-request",
+    ExplainThisOutputRequest = "explain-this-output-request",
+    TroubleshootThisOutputRequest = "troubleshoot-this-output-request",
+    OutputFollowUpRequest = "output-follow-up-request",
+    GenerateCodeRequest = "generate-code-request",
+    ChatRequest = "chat-request",
+    InlineChatRequest = "inline-chat-request",
+    ChatResponse = "chat-response",
+    InlineChatResponse = "inline-chat-response",
+    InlineCompletionResponse = "inline-completion-response",
+    Feedback = "feedback"
+}
+export interface ITelemetryEvent {
+    type: TelemetryEventType;
+    data?: any;
+}
+export interface ITelemetryListener {
+    get name(): string;
+    onTelemetryEvent: (event: ITelemetryEvent) => void;
+}
+export interface ITelemetryEmitter {
+    emitTelemetryEvent(event: ITelemetryEvent): void;
+}
+export declare const INotebookIntelligence: Token<INotebookIntelligence>;
+export interface INotebookIntelligence {
+    registerTelemetryListener: (listener: ITelemetryListener) => void;
+    unregisterTelemetryListener: (listener: ITelemetryListener) => void;
+}

package/lib/tokens.js

@@ -0,0 +1,88 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+import { Token } from '@lumino/coreutils';
+export var RequestDataType;
+(function (RequestDataType) {
+    RequestDataType["ChatRequest"] = "chat-request";
+    RequestDataType["ChatUserInput"] = "chat-user-input";
+    RequestDataType["ClearChatHistory"] = "clear-chat-history";
+    RequestDataType["RunUICommandResponse"] = "run-ui-command-response";
+    RequestDataType["GenerateCode"] = "generate-code";
+    RequestDataType["CancelChatRequest"] = "cancel-chat-request";
+    RequestDataType["InlineCompletionRequest"] = "inline-completion-request";
+    RequestDataType["CancelInlineCompletionRequest"] = "cancel-inline-completion-request";
+})(RequestDataType || (RequestDataType = {}));
+export var BackendMessageType;
+(function (BackendMessageType) {
+    BackendMessageType["StreamMessage"] = "stream-message";
+    BackendMessageType["StreamEnd"] = "stream-end";
+    BackendMessageType["RunUICommand"] = "run-ui-command";
+    BackendMessageType["GitHubCopilotLoginStatusChange"] = "github-copilot-login-status-change";
+    BackendMessageType["MCPServerStatusChange"] = "mcp-server-status-change";
+    BackendMessageType["ClaudeCodeStatusChange"] = "claude-code-status-change";
+    BackendMessageType["ClaudeCodeHeartbeat"] = "claude-code-heartbeat";
+    BackendMessageType["SkillsReloaded"] = "skills-reloaded";
+})(BackendMessageType || (BackendMessageType = {}));
+export var ResponseStreamDataType;
+(function (ResponseStreamDataType) {
+    ResponseStreamDataType["LLMRaw"] = "llm-raw";
+    ResponseStreamDataType["Markdown"] = "markdown";
+    ResponseStreamDataType["MarkdownPart"] = "markdown-part";
+    ResponseStreamDataType["Image"] = "image";
+    ResponseStreamDataType["HTMLFrame"] = "html-frame";
+    ResponseStreamDataType["Button"] = "button";
+    ResponseStreamDataType["Anchor"] = "anchor";
+    ResponseStreamDataType["Progress"] = "progress";
+    ResponseStreamDataType["Confirmation"] = "confirmation";
+    ResponseStreamDataType["AskUserQuestion"] = "ask-user-question";
+})(ResponseStreamDataType || (ResponseStreamDataType = {}));
+export var ContextType;
+(function (ContextType) {
+    ContextType["Custom"] = "custom";
+    ContextType["CurrentFile"] = "current-file";
+    ContextType["OutputContext"] = "output-context";
+})(ContextType || (ContextType = {}));
+export var MCPServerStatus;
+(function (MCPServerStatus) {
+    MCPServerStatus["NotConnected"] = "not-connected";
+    MCPServerStatus["Connecting"] = "connecting";
+    MCPServerStatus["Disconnecting"] = "disconnecting";
+    MCPServerStatus["FailedToConnect"] = "failed-to-connect";
+    MCPServerStatus["Connected"] = "connected";
+    MCPServerStatus["UpdatingToolList"] = "updating-tool-list";
+    MCPServerStatus["UpdatedToolList"] = "updated-tool-list";
+    MCPServerStatus["UpdatingPromptList"] = "updating-prompt-list";
+    MCPServerStatus["UpdatedPromptList"] = "updated-prompt-list";
+})(MCPServerStatus || (MCPServerStatus = {}));
+export var BuiltinToolsetType;
+(function (BuiltinToolsetType) {
+    BuiltinToolsetType["NotebookEdit"] = "nbi-notebook-edit";
+    BuiltinToolsetType["NotebookExecute"] = "nbi-notebook-execute";
+    BuiltinToolsetType["PythonFileEdit"] = "nbi-python-file-edit";
+    BuiltinToolsetType["FileEdit"] = "nbi-file-edit";
+    BuiltinToolsetType["FileRead"] = "nbi-file-read";
+    BuiltinToolsetType["CommandExecute"] = "nbi-command-execute";
+})(BuiltinToolsetType || (BuiltinToolsetType = {}));
+export const GITHUB_COPILOT_PROVIDER_ID = 'github-copilot';
+export const CLAUDE_CODE_CHAT_PARTICIPANT_ID = 'claude-code';
+export var AssistantMode;
+(function (AssistantMode) {
+    AssistantMode["Default"] = "default";
+    AssistantMode["Claude"] = "claude";
+})(AssistantMode || (AssistantMode = {}));
+export var TelemetryEventType;
+(function (TelemetryEventType) {
+    TelemetryEventType["InlineCompletionRequest"] = "inline-completion-request";
+    TelemetryEventType["ExplainThisRequest"] = "explain-this-request";
+    TelemetryEventType["FixThisCodeRequest"] = "fix-this-code-request";
+    TelemetryEventType["ExplainThisOutputRequest"] = "explain-this-output-request";
+    TelemetryEventType["TroubleshootThisOutputRequest"] = "troubleshoot-this-output-request";
+    TelemetryEventType["OutputFollowUpRequest"] = "output-follow-up-request";
+    TelemetryEventType["GenerateCodeRequest"] = "generate-code-request";
+    TelemetryEventType["ChatRequest"] = "chat-request";
+    TelemetryEventType["InlineChatRequest"] = "inline-chat-request";
+    TelemetryEventType["ChatResponse"] = "chat-response";
+    TelemetryEventType["InlineChatResponse"] = "inline-chat-response";
+    TelemetryEventType["InlineCompletionResponse"] = "inline-completion-response";
+    TelemetryEventType["Feedback"] = "feedback";
+})(TelemetryEventType || (TelemetryEventType = {}));
+export const INotebookIntelligence = new Token('@plmbr/notebook-intelligence:INotebookIntelligence', 'AI coding assistant for JupyterLab.');

package/lib/tour/tour-anchors.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Anchor-id constants shared between the tour step definitions and the
+ * chat-sidebar JSX. Centralising these keeps the two halves coupled at
+ * the TypeScript level rather than by string identity — a typo on
+ * either side now surfaces at compile time instead of silently
+ * skipping a step at runtime.
+ */
+export declare const TOUR_ANCHOR: {
+    readonly newChat: "new-chat";
+    readonly settingsGear: "settings-gear";
+    readonly claudeHistory: "claude-history";
+    readonly slashCommands: "slash-commands";
+    readonly addContext: "add-context";
+    readonly uploadFile: "upload-file";
+    readonly promptInput: "prompt-input";
+    readonly chatMode: "chat-mode";
+};
+export type TourAnchorId = (typeof TOUR_ANCHOR)[keyof typeof TOUR_ANCHOR];

package/lib/tour/tour-anchors.js

@@ -0,0 +1,18 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+/**
+ * Anchor-id constants shared between the tour step definitions and the
+ * chat-sidebar JSX. Centralising these keeps the two halves coupled at
+ * the TypeScript level rather than by string identity — a typo on
+ * either side now surfaces at compile time instead of silently
+ * skipping a step at runtime.
+ */
+export const TOUR_ANCHOR = {
+    newChat: 'new-chat',
+    settingsGear: 'settings-gear',
+    claudeHistory: 'claude-history',
+    slashCommands: 'slash-commands',
+    addContext: 'add-context',
+    uploadFile: 'upload-file',
+    promptInput: 'prompt-input',
+    chatMode: 'chat-mode'
+};