nebula-notebook 0.1.1 → 0.2.1

package/node_modules/nebula-autocomplete/dist/codemirror/ghostText.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CodeMirror 6 inline ghost-text completion.
+ *
+ * Renders the pending LLM suggestion as dimmed inline text at the cursor;
+ * Tab accepts, Escape dismisses, any edit or cursor move invalidates. Fetching
+ * is debounced and superseded requests are aborted.
+ *
+ * This intentionally does NOT use @codemirror/autocomplete's dropdown — the
+ * kernel/static completion sources keep the dropdown; multi-line LLM
+ * suggestions render as ghost text alongside it.
+ */
+import { EditorState, type Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+export interface GhostTextContext {
+    prefix: string;
+    suffix: string;
+    state: EditorState;
+}
+export type GhostTextFetcher = (ctx: GhostTextContext, opts: {
+    signal: AbortSignal;
+    onChunk: (text: string) => void;
+}) => Promise<string>;
+export interface GhostTextOptions {
+    /** Idle time after the last edit before a fetch fires. Default 400 ms. */
+    debounceMs?: number;
+    /**
+     * Skip fetching when the prefix (trimmed) is shorter than this. Default 0:
+     * with notebook-level context (other cells) available to the fetcher, even
+     * an empty cell is completable — gate in the fetcher, which can see that
+     * context, not here. Set >0 only for context-free single-document use.
+     */
+    minPrefixLength?: number;
+    /**
+     * When this returns true at fetch time, the fetch is skipped — e.g. while a
+     * completion DROPDOWN is open, so the two UIs don't stack and ghost turns
+     * aren't burned while the user browses the list. Injected as a predicate so
+     * this package needs no dependency on @codemirror/autocomplete.
+     */
+    holdWhen?: (state: unknown) => boolean;
+}
+export declare function acceptGhostText(view: EditorView): boolean;
+export declare function dismissGhostText(view: EditorView): boolean;
+export declare function ghostText(fetcher: GhostTextFetcher, options?: GhostTextOptions): Extension;

package/node_modules/nebula-autocomplete/dist/codemirror/ghostText.js

@@ -0,0 +1,175 @@
+/**
+ * CodeMirror 6 inline ghost-text completion.
+ *
+ * Renders the pending LLM suggestion as dimmed inline text at the cursor;
+ * Tab accepts, Escape dismisses, any edit or cursor move invalidates. Fetching
+ * is debounced and superseded requests are aborted.
+ *
+ * This intentionally does NOT use @codemirror/autocomplete's dropdown — the
+ * kernel/static completion sources keep the dropdown; multi-line LLM
+ * suggestions render as ghost text alongside it.
+ */
+import { Prec, StateEffect, StateField, } from "@codemirror/state";
+import { Decoration, EditorView, keymap, ViewPlugin, WidgetType, } from "@codemirror/view";
+const setGhost = StateEffect.define();
+class GhostWidget extends WidgetType {
+    text;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    eq(other) {
+        return other.text === this.text;
+    }
+    toDOM() {
+        const span = document.createElement("span");
+        span.className = "cm-ghost-text";
+        span.style.opacity = "0.45";
+        span.style.whiteSpace = "pre-wrap";
+        span.setAttribute("aria-hidden", "true");
+        span.textContent = this.text;
+        return span;
+    }
+    get lineBreaks() {
+        return (this.text.match(/\n/g) ?? []).length;
+    }
+}
+const ghostField = StateField.define({
+    create: () => null,
+    update(value, tr) {
+        for (const e of tr.effects)
+            if (e.is(setGhost))
+                return e.value;
+        // Any document change or cursor move invalidates the suggestion.
+        if (tr.docChanged || tr.selection)
+            return null;
+        return value;
+    },
+    provide: (field) => EditorView.decorations.from(field, (value) => {
+        if (!value || !value.text)
+            return Decoration.none;
+        return Decoration.set([
+            Decoration.widget({
+                widget: new GhostWidget(value.text),
+                side: 1,
+            }).range(value.pos),
+        ]);
+    }),
+});
+export function acceptGhostText(view) {
+    const ghost = view.state.field(ghostField, false);
+    if (!ghost || !ghost.text)
+        return false;
+    view.dispatch({
+        changes: { from: ghost.pos, insert: ghost.text },
+        selection: { anchor: ghost.pos + ghost.text.length },
+        effects: setGhost.of(null),
+        userEvent: "input.complete",
+    });
+    return true;
+}
+export function dismissGhostText(view) {
+    const ghost = view.state.field(ghostField, false);
+    if (!ghost)
+        return false;
+    view.dispatch({ effects: setGhost.of(null) });
+    return true;
+}
+export function ghostText(fetcher, options = {}) {
+    const debounceMs = options.debounceMs ?? 400;
+    const minPrefixLength = options.minPrefixLength ?? 0;
+    const plugin = ViewPlugin.fromClass(class {
+        view;
+        timer = null;
+        controller = null;
+        // In-flight fetches (supersession can briefly overlap two). While > 0 the
+        // editor root carries .cm-ai-pending so themes can signal "computing"
+        // (e.g. tint the cursor) instead of leaving the wait invisible.
+        inflight = 0;
+        constructor(view) {
+            this.view = view;
+        }
+        trackFetch(delta) {
+            this.inflight += delta;
+            this.view.dom.classList.toggle("cm-ai-pending", this.inflight > 0);
+        }
+        update(update) {
+            if (!update.docChanged)
+                return;
+            // Any user-driven edit triggers a fetch — typing, paste, delete,
+            // undo/redo — EXCEPT accepting a suggestion (that would immediately
+            // re-fetch on its own output). The kind of edit doesn't matter: the
+            // model can complete from whatever state the edit produced.
+            const isUserEdit = update.transactions.some((tr) => (tr.isUserEvent("input") && !tr.isUserEvent("input.complete")) ||
+                tr.isUserEvent("delete") ||
+                tr.isUserEvent("undo") ||
+                tr.isUserEvent("redo") ||
+                tr.isUserEvent("move"));
+            if (!isUserEdit)
+                return;
+            this.schedule();
+        }
+        schedule() {
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.controller?.abort();
+            this.timer = setTimeout(() => this.fetch(), debounceMs);
+        }
+        async fetch() {
+            const { state } = this.view;
+            if (!this.view.hasFocus)
+                return;
+            if (options.holdWhen?.(state))
+                return; // e.g. kernel dropdown open
+            const pos = state.selection.main.head;
+            if (!state.selection.main.empty)
+                return;
+            const prefix = state.sliceDoc(0, pos);
+            const suffix = state.sliceDoc(pos);
+            if (prefix.trim().length < minPrefixLength)
+                return;
+            this.controller = new AbortController();
+            const { signal } = this.controller;
+            const startDoc = state.doc;
+            const stale = () => signal.aborted || this.view.state.doc !== startDoc;
+            let streamed = "";
+            this.trackFetch(1);
+            try {
+                const full = await fetcher({ prefix, suffix, state }, {
+                    signal,
+                    onChunk: (text) => {
+                        if (stale())
+                            return;
+                        streamed += text;
+                        this.view.dispatch({ effects: setGhost.of({ pos, text: streamed }) });
+                    },
+                });
+                if (stale())
+                    return;
+                if (full)
+                    this.view.dispatch({ effects: setGhost.of({ pos, text: full }) });
+            }
+            catch {
+                /* aborted or backend error — ghost text simply doesn't appear */
+            }
+            finally {
+                this.trackFetch(-1);
+            }
+        }
+        destroy() {
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.controller?.abort();
+            this.inflight = 0;
+            this.view.dom.classList.remove("cm-ai-pending");
+        }
+    });
+    return [
+        ghostField,
+        plugin,
+        Prec.highest(keymap.of([
+            { key: "Tab", run: acceptGhostText },
+            { key: "Escape", run: dismissGhostText },
+        ])),
+    ];
+}

package/node_modules/nebula-autocomplete/dist/core/engine.d.ts

@@ -0,0 +1,17 @@
+import type { CompleteOptions, CompletionRequest, CompletionResult, EngineOptions } from "../types.js";
+/**
+ * Backend-agnostic autocomplete engine: prompt assembly, LRU result cache,
+ * and per-session supersession (a new request aborts the previous one with
+ * the same sessionKey).
+ */
+export declare class AutocompleteEngine {
+    private opts;
+    private cache;
+    private inflight;
+    private turnChain;
+    private contextBudget;
+    private maxLines;
+    constructor(opts: EngineOptions);
+    complete(req: CompletionRequest, { signal, onChunk }?: CompleteOptions): Promise<CompletionResult>;
+    dispose(): void;
+}

package/node_modules/nebula-autocomplete/dist/core/engine.js

@@ -0,0 +1,135 @@
+import { LruCache } from "./lru.js";
+import { buildPrompt, cacheKey } from "./prompt.js";
+import { createPrefixTrimStreamFilter, createTagStreamFilter, extractCompletionTag, stripFences, trimPrefixOverlap, trimSuffixOverlap, } from "./text.js";
+/**
+ * Backend-agnostic autocomplete engine: prompt assembly, LRU result cache,
+ * and per-session supersession (a new request aborts the previous one with
+ * the same sessionKey).
+ */
+export class AutocompleteEngine {
+    opts;
+    cache;
+    inflight = new Map();
+    // Per-session dispatch chain (single-flight): a backend turn cannot be
+    // cancelled once dispatched — an aborted request's worker still runs its
+    // turn to completion. Without this, a typing burst fanned superseded
+    // requests out across workers: the pool exhausted, each keystroke cold-
+    // spawned another process, and contending spawns snowballed into ~30s
+    // waits. Chaining per session keeps at most ONE turn per cell in flight;
+    // superseded requests abort while queued and never touch the backend.
+    turnChain = new Map();
+    contextBudget;
+    maxLines;
+    constructor(opts) {
+        this.opts = opts;
+        this.cache = new LruCache(opts.cacheSize ?? 128);
+        this.contextBudget = opts.contextBudget ?? 6000;
+        this.maxLines = opts.maxLines ?? 10; // field-tested: longer caps don't hurt latency; short ones truncate wanted completions
+    }
+    async complete(req, { signal, onChunk } = {}) {
+        const t0 = performance.now();
+        const key = cacheKey(req);
+        const cached = this.cache.get(key);
+        if (cached !== undefined) {
+            onChunk?.(cached);
+            return {
+                text: cached,
+                backend: this.opts.backend.name,
+                fromCache: true,
+                ttfbMs: 0,
+                totalMs: Math.round(performance.now() - t0),
+            };
+        }
+        // Supersede any in-flight request for the same session (cell).
+        const session = req.sessionKey;
+        let controller;
+        if (session !== undefined) {
+            this.inflight.get(session)?.abort(new Error("superseded"));
+            controller = new AbortController();
+            this.inflight.set(session, controller);
+            if (signal) {
+                const upstream = signal;
+                upstream.addEventListener("abort", () => controller.abort(upstream.reason), {
+                    once: true,
+                });
+            }
+        }
+        const effectiveSignal = controller?.signal ?? signal;
+        let ttfb = null;
+        const rawChunkGuard = (t) => {
+            if (ttfb === null)
+                ttfb = performance.now() - t0;
+            onChunk?.(t);
+        };
+        // Streamed ghost text goes through the same shaping as the final text so
+        // the done event never visibly "snaps" it: strip <completion> tags, then
+        // hold back a possible prefix-echo until it either confirms (stripped) or
+        // is ruled out (streamed through).
+        const chunkGuard = createTagStreamFilter(createPrefixTrimStreamFilter(req.prefix, rawChunkGuard));
+        try {
+            // Per-request tuning (Advanced settings), clamped to sane bounds.
+            const clamp = (v, lo, hi, dflt) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, Math.round(v))) : dflt;
+            const prompt = buildPrompt(req, {
+                contextBudget: clamp(req.contextBudget, 0, 200_000, this.contextBudget),
+                maxLines: clamp(req.maxLines, 1, 40, this.maxLines),
+            });
+            const diag = { promptChars: prompt.length };
+            // Single-flight per session: wait for the previous turn on this cell to
+            // settle before dispatching. If we're superseded while queued (the user
+            // kept typing), bail here — no backend turn is ever wasted on us.
+            const prev = session !== undefined ? this.turnChain.get(session) : undefined;
+            const run = (async () => {
+                if (prev) {
+                    const tQueue = performance.now();
+                    await prev; // never rejects (stored pre-caught)
+                    diag.queueWaitMs = Math.round(performance.now() - tQueue);
+                    if (effectiveSignal?.aborted)
+                        throw new Error("superseded");
+                }
+                return this.opts.backend.complete(prompt, {
+                    signal: effectiveSignal,
+                    onChunk: chunkGuard,
+                    diag,
+                });
+            })();
+            if (session !== undefined) {
+                const link = run.then(() => undefined, () => undefined);
+                this.turnChain.set(session, link);
+                void link.then(() => {
+                    if (this.turnChain.get(session) === link)
+                        this.turnChain.delete(session);
+                });
+            }
+            const raw = await run;
+            diag.rawChars = raw.length;
+            // Tag-wrapped replies carry whitespace verbatim; untagged replies fall
+            // back to the fence-stripping pipeline.
+            const tagged = extractCompletionTag(raw);
+            const text = trimSuffixOverlap(req.suffix ?? "", trimPrefixOverlap(req.prefix, tagged !== null ? tagged : stripFences(raw)));
+            // Cache only non-empty results: an empty completion is a transient
+            // model shrug, and caching it pins "no suggestion" onto that exact
+            // prefix for the cache's lifetime (observed as instant empty repeats).
+            if (text)
+                this.cache.set(key, text);
+            return {
+                text,
+                backend: this.opts.backend.name,
+                fromCache: false,
+                ttfbMs: Math.round(ttfb ?? performance.now() - t0),
+                totalMs: Math.round(performance.now() - t0),
+                diag,
+            };
+        }
+        finally {
+            if (session !== undefined && this.inflight.get(session) === controller) {
+                this.inflight.delete(session);
+            }
+        }
+    }
+    dispose() {
+        for (const c of this.inflight.values())
+            c.abort(new Error("engine disposed"));
+        this.inflight.clear();
+        this.opts.backend.dispose();
+    }
+}

package/node_modules/nebula-autocomplete/dist/core/lru.d.ts

@@ -0,0 +1,7 @@
+export declare class LruCache<V> {
+    private capacity;
+    private map;
+    constructor(capacity: number);
+    get(key: string): V | undefined;
+    set(key: string, value: V): void;
+}

package/node_modules/nebula-autocomplete/dist/core/lru.js

@@ -0,0 +1,26 @@
+export class LruCache {
+    capacity;
+    map = new Map();
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    get(key) {
+        const v = this.map.get(key);
+        if (v !== undefined) {
+            this.map.delete(key);
+            this.map.set(key, v);
+        }
+        return v;
+    }
+    set(key, value) {
+        if (this.capacity <= 0)
+            return;
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, value);
+        if (this.map.size > this.capacity) {
+            const oldest = this.map.keys().next().value;
+            this.map.delete(oldest);
+        }
+    }
+}

package/node_modules/nebula-autocomplete/dist/core/prompt.d.ts

@@ -0,0 +1,12 @@
+import type { CompletionRequest } from "../types.js";
+export interface PromptOptions {
+    contextBudget: number;
+    maxLines: number;
+}
+/**
+ * Build the completion prompt: instruction, cross-cell context (nearest cells
+ * kept when over budget), then the active cell with a <CURSOR> marker.
+ */
+export declare function buildPrompt(req: CompletionRequest, opts: PromptOptions): string;
+/** Cache key: exact near-cursor text + a cheap digest of the wider context. */
+export declare function cacheKey(req: CompletionRequest): string;

package/node_modules/nebula-autocomplete/dist/core/text.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Does a Claude Code project-transcript directory name belong to a workspace
+ * carrying `token`? Claude munges the cwd into the dir name by replacing
+ * non-alphanumerics, so we compare alphanumeric-only forms — munge-algorithm
+ * independent, and a UUID token cannot collide with a real project path.
+ */
+export declare function transcriptDirMatchesToken(dirName: string, token: string): boolean;
+/**
+ * Extract the tag-wrapped completion, whitespace preserved VERBATIM.
+ *
+ * Why tags: models structurally avoid beginning a message with whitespace, so
+ * a completion that must START with "\n" (cursor at the end of a finished
+ * comment like `# fibonacci`) loses its newline when asked for raw output —
+ * verified empirically; no prompt wording fixed it. Inside a tag pair the
+ * leading newline survives generation. Returns null when the reply isn't
+ * tag-wrapped (fall back to the fence-stripping pipeline).
+ */
+export declare function extractCompletionTag(text: string): string | null;
+/**
+ * Streaming variant: wraps an onChunk callback so tag delimiters never leak
+ * into streamed ghost text, while the inner text (leading whitespace included)
+ * streams through as it arrives. If no opening tag shows up within the first
+ * 64 chars, assumes an untagged reply and passes everything through.
+ */
+export declare function createTagStreamFilter(emit: (t: string) => void): (t: string) => void;
+/**
+ * Strip a wrapping markdown code fence, if present. Leading whitespace of an
+ * UNFENCED completion is preserved verbatim — it is often meaningful: with
+ * the cursor at the end of `# fibonacci` the completion must START with "\n"
+ * to put code on the next line, and indentation after `if x:` matters too.
+ * (A blanket .trim() here silently glued completions onto comments.)
+ */
+export declare function stripFences(text: string): string;
+/**
+ * Streaming variant of trimPrefixOverlap: emits the completion as it streams,
+ * holding back ONLY while the text so far could still be the beginning of a
+ * longer prefix-echo. Without this the ghost text visibly "snaps" when the
+ * done event applies the trim that streaming skipped (echo shown, then
+ * removed). For non-echo completions the hold is typically zero characters.
+ */
+export declare function createPrefixTrimStreamFilter(prefix: string, emit: (t: string) => void): (t: string) => void;
+/**
+ * Models sometimes echo the tail of the prefix (e.g. the current line) before
+ * continuing. Trim the longest suffix-of-prefix that the completion starts
+ * with, so accepting the suggestion never duplicates typed text.
+ */
+export declare function trimPrefixOverlap(prefix: string, completion: string): string;
+/**
+ * Models also often close constructs that the suffix already closes (quotes,
+ * brackets, parens). Trim the longest head-of-suffix that the completion ends
+ * with, so accepted text composes with what follows the cursor.
+ */
+export declare function trimSuffixOverlap(suffix: string, completion: string): string;

package/node_modules/nebula-autocomplete/dist/core/text.js

@@ -0,0 +1,169 @@
+/**
+ * Does a Claude Code project-transcript directory name belong to a workspace
+ * carrying `token`? Claude munges the cwd into the dir name by replacing
+ * non-alphanumerics, so we compare alphanumeric-only forms — munge-algorithm
+ * independent, and a UUID token cannot collide with a real project path.
+ */
+export function transcriptDirMatchesToken(dirName, token) {
+    const norm = (s) => s.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    const needle = norm(token);
+    return needle.length > 0 && norm(dirName).includes(needle);
+}
+const OPEN_TAG = "<completion>";
+const CLOSE_TAG = "</completion>";
+/**
+ * Extract the tag-wrapped completion, whitespace preserved VERBATIM.
+ *
+ * Why tags: models structurally avoid beginning a message with whitespace, so
+ * a completion that must START with "\n" (cursor at the end of a finished
+ * comment like `# fibonacci`) loses its newline when asked for raw output —
+ * verified empirically; no prompt wording fixed it. Inside a tag pair the
+ * leading newline survives generation. Returns null when the reply isn't
+ * tag-wrapped (fall back to the fence-stripping pipeline).
+ */
+export function extractCompletionTag(text) {
+    const start = text.indexOf(OPEN_TAG);
+    if (start === -1)
+        return null;
+    const inner = text.slice(start + OPEN_TAG.length);
+    const end = inner.indexOf(CLOSE_TAG);
+    return end === -1 ? inner : inner.slice(0, end);
+}
+/**
+ * Streaming variant: wraps an onChunk callback so tag delimiters never leak
+ * into streamed ghost text, while the inner text (leading whitespace included)
+ * streams through as it arrives. If no opening tag shows up within the first
+ * 64 chars, assumes an untagged reply and passes everything through.
+ */
+export function createTagStreamFilter(emit) {
+    let state = "seeking";
+    let buf = "";
+    return (chunk) => {
+        if (state === "done")
+            return;
+        if (state === "passthrough")
+            return emit(chunk);
+        buf += chunk;
+        if (state === "seeking") {
+            const at = buf.indexOf(OPEN_TAG);
+            if (at !== -1) {
+                state = "inside";
+                buf = buf.slice(at + OPEN_TAG.length);
+            }
+            else if (buf.length > 64 && !OPEN_TAG.startsWith(buf.slice(-OPEN_TAG.length))) {
+                state = "passthrough";
+                emit(buf);
+                buf = "";
+                return;
+            }
+            else {
+                return; // keep buffering — the tag may still be arriving
+            }
+        }
+        // inside: emit everything except a possible partial close tag at the tail
+        const close = buf.indexOf(CLOSE_TAG);
+        if (close !== -1) {
+            if (close > 0)
+                emit(buf.slice(0, close));
+            state = "done";
+            buf = "";
+            return;
+        }
+        // Hold back the longest suffix that could be the start of the close tag.
+        let hold = 0;
+        for (let n = Math.min(CLOSE_TAG.length - 1, buf.length); n > 0; n--) {
+            if (CLOSE_TAG.startsWith(buf.slice(-n))) {
+                hold = n;
+                break;
+            }
+        }
+        const emittable = buf.slice(0, buf.length - hold);
+        if (emittable)
+            emit(emittable);
+        buf = buf.slice(buf.length - hold);
+    };
+}
+/**
+ * Strip a wrapping markdown code fence, if present. Leading whitespace of an
+ * UNFENCED completion is preserved verbatim — it is often meaningful: with
+ * the cursor at the end of `# fibonacci` the completion must START with "\n"
+ * to put code on the next line, and indentation after `if x:` matters too.
+ * (A blanket .trim() here silently glued completions onto comments.)
+ */
+export function stripFences(text) {
+    const t = text.trim();
+    const open = t.match(/^```[a-zA-Z0-9_-]*\n?/);
+    if (open) {
+        return t.slice(open[0].length).replace(/\n?```\s*$/, "");
+    }
+    // No fence: keep leading whitespace, drop only trailing whitespace.
+    return text.replace(/\s+$/, "");
+}
+/**
+ * Streaming variant of trimPrefixOverlap: emits the completion as it streams,
+ * holding back ONLY while the text so far could still be the beginning of a
+ * longer prefix-echo. Without this the ghost text visibly "snaps" when the
+ * done event applies the trim that streaming skipped (echo shown, then
+ * removed). For non-echo completions the hold is typically zero characters.
+ */
+export function createPrefixTrimStreamFilter(prefix, emit) {
+    const tail = prefix.slice(-200);
+    let buf = "";
+    let settled = false;
+    return (chunk) => {
+        if (settled)
+            return emit(chunk);
+        buf += chunk;
+        // Could buf still grow into a LONGER echo of the prefix tail?
+        let couldExtend = false;
+        for (let n = buf.length + 1; n <= tail.length; n++) {
+            if (tail.slice(-n).startsWith(buf)) {
+                couldExtend = true;
+                break;
+            }
+        }
+        if (couldExtend)
+            return; // hold — echo still possible
+        // Settle: strip the longest confirmed echo, stream the rest.
+        let confirmed = 0;
+        for (let n = Math.min(tail.length, buf.length); n > 0; n--) {
+            if (buf.startsWith(tail.slice(-n))) {
+                confirmed = n;
+                break;
+            }
+        }
+        settled = true;
+        const out = buf.slice(confirmed);
+        buf = "";
+        if (out)
+            emit(out);
+    };
+}
+/**
+ * Models sometimes echo the tail of the prefix (e.g. the current line) before
+ * continuing. Trim the longest suffix-of-prefix that the completion starts
+ * with, so accepting the suggestion never duplicates typed text.
+ */
+export function trimPrefixOverlap(prefix, completion) {
+    const tail = prefix.slice(-200);
+    for (let n = Math.min(tail.length, completion.length); n > 0; n--) {
+        if (completion.startsWith(tail.slice(-n))) {
+            return completion.slice(n);
+        }
+    }
+    return completion;
+}
+/**
+ * Models also often close constructs that the suffix already closes (quotes,
+ * brackets, parens). Trim the longest head-of-suffix that the completion ends
+ * with, so accepted text composes with what follows the cursor.
+ */
+export function trimSuffixOverlap(suffix, completion) {
+    const head = suffix.slice(0, 200);
+    for (let n = Math.min(head.length, completion.length); n > 0; n--) {
+        if (completion.endsWith(head.slice(0, n))) {
+            return completion.slice(0, completion.length - n);
+        }
+    }
+    return completion;
+}

package/node_modules/nebula-autocomplete/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { AutocompleteEngine } from "./core/engine.js";
+export { ClaudeBackend, type ClaudeBackendOptions } from "./backends/claude.js";
+export { CodexBackend, type CodexBackendOptions } from "./backends/codex.js";
+export { buildPrompt, cacheKey } from "./core/prompt.js";
+export type { Transport, SshTransport } from "./transport.js";
+export { stripFences, trimPrefixOverlap, trimSuffixOverlap, transcriptDirMatchesToken, } from "./core/text.js";
+export type { CompletionBackend, CompletionRequest, CompletionResult, CompleteOptions, EngineOptions, NotebookCellContext, } from "./types.js";

package/node_modules/nebula-autocomplete/dist/index.js

@@ -0,0 +1,5 @@
+export { AutocompleteEngine } from "./core/engine.js";
+export { ClaudeBackend } from "./backends/claude.js";
+export { CodexBackend } from "./backends/codex.js";
+export { buildPrompt, cacheKey } from "./core/prompt.js";
+export { stripFences, trimPrefixOverlap, trimSuffixOverlap, transcriptDirMatchesToken, } from "./core/text.js";