notebook-intelligence 6.1.0__tar.gz → 6.2.0__tar.gz

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notebook_intelligence
-Version: 6.1.0
+Version: 6.2.0
 Summary: AI coding assistant for JupyterLab
 Project-URL: Homepage, https://github.com/plmbr/notebook-intelligence
 Project-URL: Bug Tracker, https://github.com/plmbr/notebook-intelligence/issues

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/docs/chatbook-extensions.md

@@ -42,7 +42,10 @@ code) is configured in Settings → Chatbook; see [`chatbook.md`](chatbook.md).
 
 Subclass `ChatbookMentionProvider` to add a browsable root. List item values are
 provider-local opaque strings; NBI namespaces them as
-`@ext:<provider-id>:<value>`.
+`@ext:<provider-id>:<value>`, or `@ext:"<provider-id>:<value>"` when the value
+contains whitespace or `@`. `resolve_mention` receives the value exactly as written:
+unlike file and folder mentions, trailing punctuation is not trimmed, because
+only the provider knows whether it is part of the value.
 
 ```python
 from notebook_intelligence import (

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/docs/chatbook.md

@@ -14,9 +14,9 @@ Cell badges show **NL** (natural language) and **Cd** (code). Code cells use the
 
 ## Writing cells
 
-Every cell is either a natural-language prompt (**NL**) or ordinary code (**Cd**), and the badge at the top of the cell shows which. The badge is a button: click it to switch that cell. `Ctrl J` switches the active cell and `Ctrl Shift J` switches every cell in the notebook. Both are literal `Ctrl`, including on macOS, where most JupyterLab bindings use `Cmd`. The notebook toolbar carries the same switch-all action and an export button.
+Every cell is either a natural-language prompt (**NL**) or ordinary code (**Cd**), and the badge at the top of the cell shows which. The badge is a button: click it to switch that cell. `Ctrl J` switches the active cell and `Ctrl Shift J` switches every cell in the notebook. Both are literal `Ctrl`, including on macOS, where most JupyterLab bindings use `Cmd`. The notebook toolbar carries the same switch-all action and an export button, and ordinary notebooks get a button to convert them to a Chatbook.
 
-Chatbook adds six commands, all reachable from the command palette:
+Chatbook adds seven commands, all reachable from the command palette:
 
 | Command                         | What it does                                                       |
 | ------------------------------- | ------------------------------------------------------------------ |
@@ -26,6 +26,7 @@ Chatbook adds six commands, all reachable from the command palette:
 | Show generated code             | Opens the code a prompt cell generated, which is otherwise hidden. |
 | Refresh English representation  | Regenerates the English description of a code cell.                |
 | Export as code notebook         | Writes a plain notebook for the backend language.                  |
+| Convert notebook to Chatbook    | Writes a Chatbook copy of an ordinary notebook.                    |
 
 **Running a code cell also sends it to the model.** The first time a **Cd** cell runs successfully, Chatbook asks the model for a one-line English description of that source and stores it in the cell's metadata, so the cell can be read as prose and switched back to **NL** later. It does not ask again on later runs, and it does not refresh the description when you edit the code: use **Refresh English representation** for that. This is worth knowing in a deployment where code is more sensitive than prompts, because it means hand-written code in a Chatbook reaches the model even under **Always confirm**.
 
@@ -33,13 +34,25 @@ Chatbook adds six commands, all reachable from the command palette:
 
 Typing `@` in a prompt cell opens a menu of context to attach. The built-in **Files & folders** provider browses the Jupyter root, skipping dotfiles, `__pycache__`, and `node_modules`; a selected file is read and truncated at 16,000 characters. Extensions can register providers of their own, which appear in the same menu under their own root (see [`chatbook-extensions.md`](chatbook-extensions.md)).
 
+A mention ends at the first whitespace or `@`, so a path that contains either is written in double quotes, `@file:"data/my notes.md"`; the menu inserts that form for you. A quoted path is taken exactly as written and cannot contain a double quote or a line break, so a name with a double quote can only be mentioned when it needs no quoting, and a name that itself begins and ends with a double quote cannot be mentioned at all.
+
+Sentence punctuation typed right after an unquoted file or folder mention (`.` `,` `;` `:` `!` `?` and `…`, closing brackets and quotes, and their full-width forms) is not part of the path, so `Summarize @file:data/README.md, then chart it` refers to `data/README.md`. The name as written is tried first, then with up to five of those characters removed one at a time, and the first name that exists is used even if it cannot be read. So a file whose real name ends in punctuation still resolves, and a shorter name is never reached past one that exists. Other characters, such as `+` or `-`, are always part of the path.
+
 Mentions work only in prompt cells. A prompt that carries one is regenerated every run rather than reusing the previously approved code, because the mentioned content may have changed since.
 
+## Convert a notebook to a Chatbook
+
+**Convert notebook to Chatbook** is the reverse of [export](#export-as-a-code-notebook). It appears as a toolbar button on ordinary notebooks and in the command palette, and writes a Chatbook copy next to the original, named after it with `-chatbook` appended (`analysis.ipynb` becomes `analysis-chatbook.ipynb`, and a number is added if that name is taken). The copy opens straight away, and the original is left untouched. It converts what is in the editor, so unsaved changes are included.
+
+Every code cell becomes a **Cd** cell and runs exactly as written. The exception is a Chatbook whose kernel was switched to another one: its natural-language cells that have run, and not been edited since, still hold their prompts and stay natural language. Any other natural-language cell in it would become a code cell holding English, so switch such a Chatbook back to the Chatbook kernel rather than converting it. Everything else is kept: markdown and raw cells, outputs, execution counts, attachments, and other notebook metadata; only the kernelspec and language info become Chatbook's. Conversion itself sends nothing to the model. As with any **Cd** cell, the first time a converted cell without an English description runs successfully, its code is sent to the model for a one-line description. A description a cell already carries is kept only when it is known to describe that exact code, as for a Chatbook that was exported and is converted back.
+
+Chatbook runs code in the one backend kernel chosen in Settings → **Chatbook**, so conversion compares the notebook's language with it first. A notebook in the same language converts, with a note when its kernel differs from the backend, and so does a notebook that records no language. A notebook in another language (an R notebook while the backend is Python) is not converted, because every code cell would fail; the dialog explains why and, when a kernel for that language is installed, offers to open the Chatbook settings. Conversion never changes that setting itself, since it applies to every Chatbook. When the notebook names its kernel, that name is recorded in the copy's metadata under `nbi.chatbook.sourceKernel`.
+
 ## Export as a code notebook
 
 **Export as code notebook** writes a plain notebook for the backend language next to the original, named after it with the language appended (`analysis.ipynb` becomes `analysis-python.ipynb`, and a number is added if that name is taken). The Chatbook itself is left untouched.
 
-Prompt cells become their generated code. A prompt cell whose code never ran, or whose prompt changed since it last ran, is written as line comments instead, so an export never passes off code as having been executed when it was not. The exported notebook's `kernelspec` and `language_info` are rewritten to the backend kernel. Export fails if the backend language has no line-comment syntax Chatbook knows, since there would be no way to write those cells safely.
+Prompt cells become their generated code. A prompt cell whose code never ran, or whose prompt changed since it last ran, is written as line comments instead, so an export never passes off code as having been executed when it was not. A code cell switched to natural language exports its own code, as any code cell does, while its English side is empty or is still the description of that code. Once either side changes, it is written as comments too; after editing the code, **Refresh English representation** brings the description back in step. The exported notebook's `kernelspec` and `language_info` are rewritten to the backend kernel. Export fails if the backend language has no line-comment syntax Chatbook knows, since there would be no way to write those cells safely.
 
 ## What the notebook file holds
 

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/notebook_intelligence/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '6.1.0'
+__version__ = VERSION = '6.2.0'

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/notebook_intelligence/chatbook_mentions.py

@@ -33,7 +33,26 @@ MAX_PROVIDER_CONTEXT_CHARS = 16_000
 MAX_DIRECTORY_ITEMS = 100
 BUILTIN_SKIPPED_DIRECTORIES = frozenset({"__pycache__", "node_modules"})
 
-MENTION_TOKEN_RE = re.compile(r"(?<![\w@])@([^\s@]+)")
+# A mention is either quoted, `@file:"data/my notes.md"`, which is how a path
+# containing whitespace or `@` is written, or unquoted and runs to the next
+# whitespace. The quoted form follows Claude Code (`@"path"`) and Codex, which
+# quotes a picked path containing whitespace. NUI's mention parser
+# (plmbr/nui internal/mentions) is meant to accept the same tokens (#503), so
+# change the two together.
+MENTION_TOKEN_RE = re.compile(
+    r'(?<![\w@])@(?:(file|dir|ext):"([^"\n\r\x85\u2028\u2029]+)"(?![\w"])|([^\s@]+))'
+)
+# Sentence punctuation typed after an unquoted file or dir mention
+# (`see @file:notes.md,`) is not part of the path. This follows Claude Code,
+# but only for sentence punctuation: `+` or `-` stay part of the name. The
+# characters are removed one at a time, at most a few, stopping at the first
+# candidate that exists, so a name that really ends in one of them still
+# resolves and a shorter, unrelated name is never reached past it.
+TRAILING_PUNCTUATION = frozenset(
+    ".,;:!?)]}'\"\u2026\u201d\u2019\u00bb"
+    "\u3002\u3001\uff0c\uff1b\uff1a\uff01\uff1f\uff09\u300d\u300f"
+)
+MAX_TRAILING_PUNCTUATION = 5
 
 
 def _root_path() -> Path:
@@ -217,26 +236,72 @@ def list_chatbook_mentions(
     )
 
 
-def parse_chatbook_mentions(prompt: str) -> list[tuple[str, str]]:
-    """Return unique (kind, relative path) mentions, preserving prompt order."""
-    result: list[tuple[str, str]] = []
-    seen: set[tuple[str, str]] = set()
+def _parse_mention_tokens(prompt: str) -> list[tuple[str, str, bool, str]]:
+    """Return (kind, value, quoted, token as written), once each, in order."""
+    result: list[tuple[str, str, bool, str]] = []
+    seen: set[tuple[str, str, bool]] = set()
     for match in MENTION_TOKEN_RE.finditer(prompt or ""):
-        value = match.group(1)
-        if value.startswith("file:"):
-            item = ("file", value.removeprefix("file:"))
-        elif value.startswith("dir:"):
-            item = ("dir", value.removeprefix("dir:"))
-        elif value.startswith(EXTENSION_ROOT_PREFIX):
-            item = ("ext", value.removeprefix(EXTENSION_ROOT_PREFIX))
+        if match.group(1):
+            kind, value, quoted = match.group(1), match.group(2), True
         else:
-            continue
-        if item not in seen:
-            seen.add(item)
-            result.append(item)
+            raw = match.group(3)
+            kind, separator, value = raw.partition(":")
+            if kind not in ("file", "dir", "ext") or not separator:
+                continue
+            quoted = False
+        if (kind, value, quoted) not in seen:
+            seen.add((kind, value, quoted))
+            result.append((kind, value, quoted, match.group(0)))
     return result
 
 
+def _path_candidates(value: str, quoted: bool) -> list[str]:
+    """The path as written, then with trailing punctuation removed one by one."""
+    candidates = [value]
+    if quoted:
+        return candidates
+    while (
+        len(candidates) <= MAX_TRAILING_PUNCTUATION
+        and len(candidates[-1]) > 1
+        and candidates[-1][-1] in TRAILING_PUNCTUATION
+    ):
+        candidates.append(candidates[-1][:-1])
+    return candidates
+
+
+def _locate_mention_path(
+    kind: str,
+    value: str,
+    quoted: bool,
+    root: Path,
+    skipped_directories: Iterable[str],
+) -> tuple[Path | None, tuple[str, str]]:
+    """Find the path a file or dir mention names, and the key to dedupe it on.
+
+    Returns the first candidate that exists, even if it later cannot be read.
+    A refused candidate ends the search, so trimming never steps past it.
+    """
+    candidates = _path_candidates(value, quoted)
+    for candidate in candidates:
+        try:
+            path = _safe_relative_path(candidate, skipped_directories)
+            if path.exists():
+                return path, (kind, _relative_display(path, root))
+        except (OSError, RuntimeError, UnicodeError, ValueError):
+            return None, (kind, candidate)
+    return None, (kind, candidates[-1])
+
+
+def parse_chatbook_mentions(prompt: str) -> list[tuple[str, str]]:
+    """Return (kind, value as written) for each mention, in prompt order.
+
+    A value is not yet a path: trailing punctuation is trimmed only when the
+    mention is resolved. The same text written quoted and unquoted appears
+    twice, because the two can resolve differently.
+    """
+    return [(kind, value) for kind, value, _, _ in _parse_mention_tokens(prompt)]
+
+
 def resolve_chatbook_mentions(
     prompt: str,
     skipped_directories: Iterable[str] = (),
@@ -248,7 +313,7 @@ def resolve_chatbook_mentions(
     context_hash: str = "",
 ) -> list[dict[str, str]]:
     """Resolve mention tokens into bounded, soft-failing reference context."""
-    mentions = parse_chatbook_mentions(prompt)
+    mentions = _parse_mention_tokens(prompt)
     if not mentions:
         return []
     root = _root_path()
@@ -256,9 +321,13 @@ def resolve_chatbook_mentions(
     current = (notebook_context or {}).get("current") or {}
     cell_index = current.get("index") if isinstance(current, dict) else None
     resolved: list[dict[str, str]] = []
-    for kind, relative in mentions:
-        token = f"@{kind}:{relative}"
+    resolved_keys: set[tuple[str, str]] = set()
+    for kind, relative, quoted, token in mentions:
         if kind == "ext":
+            # Quoted and unquoted spellings name the same provider value.
+            if ("ext", relative) in resolved_keys:
+                continue
+            resolved_keys.add(("ext", relative))
             provider_id, value = _split_extension_mention(relative)
             provider = provider_by_id.get(provider_id)
             try:
@@ -302,32 +371,29 @@ def resolve_chatbook_mentions(
                     }
                 )
             continue
-        try:
-            path = _safe_relative_path(relative, skipped_directories)
-            display = _relative_display(path, root)
-            if kind == "file":
-                content = _read_text_file(path)
-            else:
-                content = _list_directory(path)
-            resolved.append(
-                {
-                    "token": token,
-                    "kind": kind,
-                    "path": display,
-                    "content": content,
-                    "available": "true",
-                }
-            )
-        except (OSError, RuntimeError, UnicodeError, ValueError):
-            resolved.append(
-                {
-                    "token": token,
-                    "kind": kind,
-                    "path": relative,
-                    "content": "[unavailable]",
-                    "available": "false",
-                }
-            )
+        path, key = _locate_mention_path(
+            kind, relative, quoted, root, skipped_directories
+        )
+        if key in resolved_keys:
+            continue
+        resolved_keys.add(key)
+        entry = {
+            "token": token,
+            "kind": kind,
+            "path": key[1] if path is not None else relative,
+            "content": "[unavailable]",
+            "available": "false",
+        }
+        if path is not None:
+            try:
+                if kind == "file":
+                    content = _read_text_file(path)
+                else:
+                    content = _list_directory(path)
+                entry.update(content=content, available="true")
+            except (OSError, RuntimeError, UnicodeError, ValueError):
+                pass
+        resolved.append(entry)
     return resolved
 
 

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/notebook_intelligence/labextension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plmbr/notebook-intelligence",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "AI coding assistant for JupyterLab",
   "keywords": [
     "AI",
@@ -176,7 +176,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.e5f6a45f75a47d403e5b.js",
+      "load": "static/remoteEntry.10c9ca7e4b3cffb98413.js",
       "extension": "./extension",
       "style": "./style"
     }

{notebook_intelligence-6.1.0 → notebook_intelligence-6.2.0}/notebook_intelligence/labextension/schemas/@plmbr/notebook-intelligence/package.json.orig

@@ -1,6 +1,6 @@
 {
     "name": "@plmbr/notebook-intelligence",
-    "version": "6.1.0",
+    "version": "6.2.0",
     "description": "AI coding assistant for JupyterLab",
     "keywords": [
         "AI",