jupyterlab-codex-sidebar 0.1.5 → 0.1.7

package/tests/e2e/cell-output-error-tail.spec.js

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const path = require('path');
+const { test, expect } = require('@playwright/test');
+
+const NOTEBOOK_RELATIVE_PATH = 'tests/e2e/fixtures/notebooks/error-output-tail.ipynb';
+const NOTEBOOK_NAME = 'error-output-tail.ipynb';
+const NOTEBOOK_PY_PATH = path.resolve(__dirname, 'fixtures/notebooks/error-output-tail.py');
+const NOTEBOOK_IPYNB_PATH = path.resolve(__dirname, 'fixtures/notebooks/error-output-tail.ipynb');
+const TRACE_HEAD_MARKER = 'TRACE_HEAD_MARKER_ABCDEFGHIJ';
+const TRACE_TAIL_MARKER = 'TRACE_TAIL_MARKER_ZYXWVUTSRQ';
+
+function buildInitialNotebookUrl(baseLabUrl, notebookPath) {
+  const parsed = new URL(baseLabUrl);
+  const basePath = parsed.pathname.replace(/\/$/, '');
+  parsed.pathname = `${basePath}/tree/${notebookPath}`;
+  parsed.searchParams.set('reset', '1');
+  return parsed.toString();
+}
+
+async function dismissBlockingDialogs(page) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const dialog = page.locator('dialog.jp-Dialog, [role="dialog"].jp-Dialog, [role="dialog"]').first();
+    if (!(await dialog.count()) || !(await dialog.isVisible())) {
+      return;
+    }
+
+    const noKernelButton = page.getByRole('button', { name: /^No Kernel$/ }).first();
+    if ((await noKernelButton.count()) > 0 && (await noKernelButton.isVisible())) {
+      await noKernelButton.click();
+      await page.waitForTimeout(150);
+      continue;
+    }
+
+    await page.keyboard.press('Escape');
+    await page.waitForTimeout(150);
+  }
+}
+
+async function ensureCodexPanel(page) {
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexPanel .jp-CodexComposer textarea');
+  if ((await composer.count()) > 0 && (await composer.first().isVisible())) {
+    return;
+  }
+
+  const codexSideTab = page
+    .locator('.jp-SideBar.jp-mod-right .lm-TabBar-tab[title="Codex"], .jp-SideBar.jp-mod-right .lm-TabBar-tab')
+    .filter({ hasText: 'Codex' })
+    .first();
+  await expect(codexSideTab).toBeVisible({ timeout: 20000 });
+  await codexSideTab.click();
+  await expect(composer.first()).toBeVisible({ timeout: 20000 });
+}
+
+function writeNotebookFixture() {
+  const traceback = [
+    'Traceback (most recent call last):',
+    `  ${TRACE_HEAD_MARKER}`,
+    `${'A'.repeat(22000)}`,
+    `ValueError: ${TRACE_TAIL_MARKER}`
+  ];
+  const notebook = {
+    cells: [
+      {
+        cell_type: 'code',
+        execution_count: 1,
+        id: 'error-output-tail-cell',
+        metadata: {},
+        outputs: [
+          {
+            output_type: 'error',
+            ename: 'ValueError',
+            evalue: TRACE_TAIL_MARKER,
+            traceback
+          }
+        ],
+        source: ['raise ValueError("synthetic traceback for tail truncation test")\n']
+      }
+    ],
+    metadata: {
+      jupytext: {
+        formats: 'ipynb,py:percent'
+      },
+      kernelspec: {
+        display_name: 'Python 3 (ipykernel)',
+        language: 'python',
+        name: 'python3'
+      },
+      language_info: {
+        codemirror_mode: {
+          name: 'ipython',
+          version: 3
+        },
+        file_extension: '.py',
+        mimetype: 'text/x-python',
+        name: 'python',
+        nbconvert_exporter: 'python',
+        pygments_lexer: 'ipython3',
+        version: '3.13.9'
+      }
+    },
+    nbformat: 4,
+    nbformat_minor: 5
+  };
+
+  fs.writeFileSync(NOTEBOOK_IPYNB_PATH, `${JSON.stringify(notebook, null, 2)}\n`, 'utf8');
+  fs.writeFileSync(
+    NOTEBOOK_PY_PATH,
+    [
+      '# %%',
+      'raise ValueError("synthetic traceback for tail truncation test")',
+      ''
+    ].join('\n'),
+    'utf8'
+  );
+}
+
+test('error cell output sends the tail of the traceback to Codex', async ({ page, baseURL }) => {
+  const originalNotebook = fs.readFileSync(NOTEBOOK_IPYNB_PATH, 'utf8');
+  const originalPy = fs.readFileSync(NOTEBOOK_PY_PATH, 'utf8');
+  const codexCommandPath =
+    process.env.PLAYWRIGHT_CODEX_COMMAND || path.resolve(__dirname, 'mock-codex-cli-prompt-echo.py');
+  const targetUrl = baseURL || process.env.JUPYTERLAB_URL || 'http://127.0.0.1:8888/lab';
+
+  try {
+    writeNotebookFixture();
+
+    await page.addInitScript(commandPath => {
+      window.localStorage.setItem('jupyterlab-codex:command-path', commandPath);
+      window.localStorage.setItem('jupyterlab-codex:include-active-cell', 'true');
+      window.localStorage.setItem('jupyterlab-codex:include-active-cell-output', 'true');
+    }, codexCommandPath);
+
+    await page.goto(buildInitialNotebookUrl(targetUrl, NOTEBOOK_RELATIVE_PATH), { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('main[aria-label="Main Content"], .jp-LabShell, .lm-DockPanel', {
+      timeout: 30000
+    });
+    await dismissBlockingDialogs(page);
+    await ensureCodexPanel(page);
+
+    const cellEditor = page.locator('.jp-Notebook [aria-label="Code Cell Content with Output"] [role="textbox"]');
+    await expect(cellEditor).toBeVisible({ timeout: 20000 });
+    await cellEditor.click();
+
+    const composer = page.locator('.jp-CodexComposer textarea');
+    const sendBtn = page.locator('.jp-CodexSendBtn');
+    await composer.fill('Inspect the attached output.');
+    await expect(sendBtn).toBeEnabled({ timeout: 15000 });
+    await sendBtn.click();
+    await expect(page.locator('.jp-CodexSendBtn.is-stop')).toHaveCount(0, { timeout: 30000 });
+
+    const assistantMessage = page.locator('.jp-CodexChat-message.jp-CodexChat-assistant').last();
+    await expect(assistantMessage).toContainText('PROMPT_TAIL_START', { timeout: 30000 });
+    const responseText = await assistantMessage.innerText();
+
+    const tailSection = responseText.split('PROMPT_TAIL_START\n')[1]?.split('\nPROMPT_TAIL_END')[0] || '';
+    expect(responseText).toContain('PROMPT_HAS_CURRENT_CELL_CONTENT=true');
+    expect(responseText).toContain('PROMPT_HAS_CURRENT_CELL_OUTPUT=true');
+    expect(tailSection).toContain(TRACE_TAIL_MARKER);
+    expect(tailSection).not.toContain(TRACE_HEAD_MARKER);
+  } finally {
+    fs.writeFileSync(NOTEBOOK_IPYNB_PATH, originalNotebook, 'utf8');
+    fs.writeFileSync(NOTEBOOK_PY_PATH, originalPy, 'utf8');
+  }
+});

package/tests/e2e/codex-ui-test-helpers.js

@@ -0,0 +1,138 @@
+const path = require('node:path');
+
+function buildNotebookUrl(baseLabUrl, notebookPath) {
+  const parsed = new URL(baseLabUrl);
+  const basePath = parsed.pathname.replace(/\/$/, '');
+  parsed.pathname = `${basePath}/tree/${notebookPath}`;
+  parsed.searchParams.set('reset', '1');
+  return parsed.toString();
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+async function dismissBlockingDialogs(page) {
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const dialog = page.locator('dialog.jp-Dialog, [role="dialog"].jp-Dialog, [role="dialog"]').first();
+    if (!(await dialog.count()) || !(await dialog.isVisible())) {
+      return;
+    }
+
+    const noKernelButton = page.getByRole('button', { name: /^No Kernel$/ }).first();
+    if ((await noKernelButton.count()) > 0 && (await noKernelButton.isVisible())) {
+      await noKernelButton.click();
+      await page.waitForTimeout(120);
+      continue;
+    }
+
+    const selectKernelButton = page.getByRole('button', { name: /^Select$/ }).first();
+    if ((await selectKernelButton.count()) > 0 && (await selectKernelButton.isVisible())) {
+      await selectKernelButton.click();
+      await page.waitForTimeout(120);
+      continue;
+    }
+
+    const cancelButton = page.getByRole('button', { name: /^Cancel$/ }).first();
+    if ((await cancelButton.count()) > 0 && (await cancelButton.isVisible())) {
+      await cancelButton.click();
+      await page.waitForTimeout(120);
+      continue;
+    }
+
+    await page.keyboard.press('Escape');
+    await page.waitForTimeout(120);
+  }
+}
+
+async function ensureFileBrowserVisible(page) {
+  await dismissBlockingDialogs(page);
+  const fileBrowserTab = page.getByRole('tab', { name: /File Browser/i }).first();
+  if (await fileBrowserTab.count()) {
+    const isActiveBefore = await fileBrowserTab.evaluate(
+      element =>
+        element.getAttribute('aria-selected') === 'true' ||
+        (typeof element.className === 'string' && element.className.includes('lm-mod-current'))
+    );
+    if (!isActiveBefore) {
+      await fileBrowserTab.click();
+    }
+    const isActiveAfter = await fileBrowserTab.evaluate(
+      element =>
+        element.getAttribute('aria-selected') === 'true' ||
+        (typeof element.className === 'string' && element.className.includes('lm-mod-current'))
+    );
+    if (!isActiveAfter) {
+      await fileBrowserTab.click();
+    }
+  }
+  await page.getByRole('list', { name: /files/i }).first().waitFor({ state: 'visible', timeout: 10000 }).catch(() => {});
+}
+
+async function openDocumentFromFileBrowser(page, documentName) {
+  await ensureFileBrowserVisible(page);
+  let item = page
+    .getByRole('listitem', { name: new RegExp(`\\b${escapeRegExp(documentName)}\\b`, 'i') })
+    .first();
+  if (!(await item.count())) {
+    item = page.locator('.jp-DirListing-item', { hasText: documentName }).first();
+  }
+  if (!(await item.count())) {
+    item = page.locator('.jp-FileBrowser').getByText(documentName, { exact: true }).first();
+  }
+  await item.first().waitFor({ state: 'visible', timeout: 20000 });
+  await item.first().dblclick();
+  await dismissBlockingDialogs(page);
+}
+
+async function activateDocumentTab(page, documentName) {
+  await dismissBlockingDialogs(page);
+  const exactTab = page
+    .getByRole('tab', { name: new RegExp(`^${escapeRegExp(documentName)}$`) })
+    .first();
+  await exactTab.click();
+}
+
+async function ensureCodexPanel(page) {
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexPanel .jp-CodexComposer textarea');
+  if ((await composer.count()) > 0 && (await composer.first().isVisible())) {
+    return;
+  }
+
+  const codexSideTab = page
+    .locator('.jp-SideBar.jp-mod-right .lm-TabBar-tab[title="Codex"], .jp-SideBar.jp-mod-right .lm-TabBar-tab')
+    .filter({ hasText: 'Codex' })
+    .first();
+  await codexSideTab.click();
+  await expect(composer.first()).toBeVisible({ timeout: 20000 });
+}
+
+async function openNotebookInCodex(page, baseURL, notebook) {
+  const commandPath = notebook.commandPath || path.resolve(__dirname, 'mock-codex-cli.py');
+  await page.addInitScript(cmd => {
+    window.localStorage.setItem('jupyterlab-codex:command-path', cmd);
+    if (!window.localStorage.getItem('jupyterlab-codex:model')) {
+      window.localStorage.removeItem('jupyterlab-codex:model');
+    }
+  }, commandPath);
+
+  const targetUrl = buildNotebookUrl(baseURL, notebook.path);
+  await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
+  await page.waitForSelector('main[aria-label="Main Content"], .jp-LabShell, .lm-DockPanel', { timeout: 30000 });
+  await dismissBlockingDialogs(page);
+  await ensureCodexPanel(page);
+
+  await openDocumentFromFileBrowser(page, notebook.name);
+  await activateDocumentTab(page, notebook.name);
+}
+
+module.exports = {
+  buildNotebookUrl,
+  dismissBlockingDialogs,
+  ensureFileBrowserVisible,
+  openDocumentFromFileBrowser,
+  activateDocumentTab,
+  ensureCodexPanel,
+  openNotebookInCodex
+};

package/tests/e2e/fixtures/notebooks/error-output-tail.ipynb

@@ -0,0 +1,58 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "error-output-tail-cell",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "synthetic traceback for tail truncation test",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msynthetic traceback for tail truncation test\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "\u001b[0;31mValueError\u001b[0m: synthetic traceback for tail truncation test"
+     ]
+    }
+   ],
+   "source": [
+    "raise ValueError(\"synthetic traceback for tail truncation test\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "05fa12e1-3ea7-4081-b658-7e2799c32d07",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

package/tests/e2e/fixtures/notebooks/error-output-tail.py

@@ -0,0 +1,19 @@
+# ---
+# jupyter:
+#   jupytext:
+#     formats: ipynb,py:percent
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.1
+#   kernelspec:
+#     display_name: Python 3 (ipykernel)
+#     language: python
+#     name: python3
+# ---
+
+# %%
+raise ValueError("synthetic traceback for tail truncation test")
+
+# %%

package/tests/e2e/mock-codex-cli-prompt-echo.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+import json
+import sys
+import uuid
+from typing import Any
+
+
+def _emit(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload) + "\n")
+    sys.stdout.flush()
+
+
+def _run_app_server() -> int:
+    for raw_line in sys.stdin:
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        req_id = req.get("id")
+        method = req.get("method")
+        if method == "initialize" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {"capabilities": {}}})
+            continue
+        if method == "model/list" and req_id is not None:
+            _emit(
+                {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "data": [
+                            {
+                                "model": "mock-gpt",
+                                "displayName": "Mock GPT",
+                                "supportedReasoningEfforts": ["low", "medium", "high"],
+                                "defaultReasoningEffort": "medium",
+                            }
+                        ]
+                    },
+                }
+            )
+            continue
+        if method == "shutdown" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {}})
+            continue
+
+    return 0
+
+
+def _run_exec_mode() -> int:
+    prompt = sys.stdin.read()
+    thread_id = f"mock-thread-{uuid.uuid4().hex[:12]}"
+    head = prompt[:800]
+    tail = prompt[-800:] if prompt else ""
+    has_current_cell_content = "Current Cell Content:" in prompt
+    has_current_cell_output = "Current Cell Output:" in prompt
+
+    _emit({"type": "thread.started", "thread_id": thread_id})
+    _emit(
+        {
+            "type": "item.completed",
+            "item": {
+                "type": "agent_message",
+                "text": (
+                    f"PROMPT_HAS_CURRENT_CELL_CONTENT={str(has_current_cell_content).lower()}\n"
+                    f"PROMPT_HAS_CURRENT_CELL_OUTPUT={str(has_current_cell_output).lower()}\n"
+                    "PROMPT_HEAD_START\n"
+                    f"{head}\n"
+                    "PROMPT_HEAD_END\n"
+                    "PROMPT_TAIL_START\n"
+                    f"{tail}\n"
+                    "PROMPT_TAIL_END"
+                ),
+            },
+        }
+    )
+    return 0
+
+
+def main() -> int:
+    argv = sys.argv[1:]
+    if len(argv) >= 1 and argv[0] == "app-server":
+        return _run_app_server()
+    return _run_exec_mode()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/tests/unit/codexChatAttachmentLimit.spec.ts

@@ -2,11 +2,12 @@ import { expect, test } from '@playwright/test';
 
 import {
   buildAttachmentTruncationNotice,
-  limitActiveCellAttachmentPayload
+  limitActiveCellAttachmentPayload,
+  resolveSentAttachmentTruncation
 } from '../../src/codexChatAttachmentLimit';
 
 test('limitActiveCellAttachmentPayload keeps payload unchanged when within max', () => {
-  const result = limitActiveCellAttachmentPayload('abc', 'def', 10);
+  const result = limitActiveCellAttachmentPayload('abc', 'def', 10, 10);
   expect(result).toEqual({
     selection: 'abc',
     cellOutput: 'def',
@@ -15,8 +16,8 @@ test('limitActiveCellAttachmentPayload keeps payload unchanged when within max',
   });
 });
 
-test('limitActiveCellAttachmentPayload preserves output first, then input', () => {
-  const result = limitActiveCellAttachmentPayload('12345', 'abcdef', 8);
+test('limitActiveCellAttachmentPayload applies separate limits to input and output', () => {
+  const result = limitActiveCellAttachmentPayload('12345', 'abcdef', 2, 6);
   expect(result).toEqual({
     selection: '12',
     cellOutput: 'abcdef',
@@ -25,10 +26,20 @@ test('limitActiveCellAttachmentPayload preserves output first, then input', () =
   });
 });
 
-test('limitActiveCellAttachmentPayload truncates output first when output exceeds max', () => {
-  const result = limitActiveCellAttachmentPayload('12345', 'abcdefghij', 4);
+test('limitActiveCellAttachmentPayload truncates long single-line input from the middle', () => {
+  const result = limitActiveCellAttachmentPayload(`start-${'x'.repeat(3000)}-end`, '', 4000, 10);
+  expect(result.selection).toContain('[long line truncated]');
+  expect(result.selection.startsWith('start-')).toBeTruthy();
+  expect(result.selection.endsWith('-end')).toBeTruthy();
+  expect(result.selection.length).toBeLessThanOrEqual(4000);
+  expect(result.selectionTruncated).toBeTruthy();
+  expect(result.cellOutputTruncated).toBeFalsy();
+});
+
+test('limitActiveCellAttachmentPayload truncates output independently when output exceeds max', () => {
+  const result = limitActiveCellAttachmentPayload('12345', 'abcdefghij', 4, 4);
   expect(result).toEqual({
-    selection: '',
+    selection: '1234',
     cellOutput: 'abcd',
     selectionTruncated: true,
     cellOutputTruncated: true
@@ -36,7 +47,21 @@ test('limitActiveCellAttachmentPayload truncates output first when output exceed
 });
 
 test('buildAttachmentTruncationNotice includes source hint when input is truncated', () => {
-  const notice = buildAttachmentTruncationNotice(true, false, 4000);
+  const notice = buildAttachmentTruncationNotice(true, false, 4000, 20000);
   expect(notice).toContain('source file/cell');
   expect(notice).toContain('4000');
 });
+
+test('resolveSentAttachmentTruncation only reports truncation for attachments that were sent', () => {
+  expect(
+    resolveSentAttachmentTruncation({
+      includeSelection: false,
+      includeCellOutput: true,
+      selectionTruncated: true,
+      cellOutputTruncated: true
+    })
+  ).toEqual({
+    selectionTruncated: false,
+    cellOutputTruncated: true
+  });
+});

package/tests/unit/codexChatAttachmentState.spec.ts

@@ -0,0 +1,71 @@
+import { expect, test } from '@playwright/test';
+
+import { resolveCellAttachmentState } from '../../src/codexChatAttachmentState';
+
+test('resolveCellAttachmentState shows notebook cell attachment for jupytext notebook editor', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: true,
+      includeActiveCellOutput: true,
+      notebookMode: 'jupytext_py',
+      isNotebookEditor: true,
+      currentNotebookPath: '/tmp/example.py',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: true,
+    contentEnabled: true,
+    outputEnabled: true
+  });
+});
+
+test('resolveCellAttachmentState hides cell attachment for jupytext text editor', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: true,
+      includeActiveCellOutput: true,
+      notebookMode: 'jupytext_py',
+      isNotebookEditor: false,
+      currentNotebookPath: '/tmp/example.py',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: false,
+    contentEnabled: false,
+    outputEnabled: false
+  });
+});
+
+test('resolveCellAttachmentState hides badge for plain python notebook mode', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: true,
+      includeActiveCellOutput: true,
+      notebookMode: 'plain_py',
+      isNotebookEditor: true,
+      currentNotebookPath: '/tmp/example.py',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: false,
+    contentEnabled: false,
+    outputEnabled: false
+  });
+});
+
+test('resolveCellAttachmentState keeps the toggle visible when attachment is off', () => {
+  expect(
+    resolveCellAttachmentState({
+      includeActiveCell: false,
+      includeActiveCellOutput: true,
+      notebookMode: 'ipynb',
+      isNotebookEditor: true,
+      currentNotebookPath: '/tmp/example.ipynb',
+      pairedOk: true
+    })
+  ).toEqual({
+    showBadge: true,
+    contentEnabled: false,
+    outputEnabled: false
+  });
+});