nebula-notebook 0.2.0 → 0.2.2

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";

package/node_modules/nebula-autocomplete/dist/server/fastify.d.ts

@@ -0,0 +1,40 @@
+import type { AutocompleteEngine } from "../core/engine.js";
+import type { CompletionRequest } from "../types.js";
+/**
+ * Minimal structural types so this plugin works with Fastify 4/5 without a
+ * hard dependency on the fastify package.
+ */
+interface FastifyLikeRequest {
+    body: unknown;
+}
+interface FastifyLikeReply {
+    raw: {
+        writeHead(status: number, headers: Record<string, string>): void;
+        write(chunk: string): void;
+        end(): void;
+        on(event: "close", cb: () => void): void;
+        writableEnded: boolean;
+    };
+    hijack?: () => void;
+}
+interface FastifyLikeInstance {
+    post(path: string, handler: (req: FastifyLikeRequest, reply: FastifyLikeReply) => Promise<void>): void;
+}
+export interface AutocompleteRouteOptions {
+    /** Route path. Default "/autocomplete". */
+    path?: string;
+}
+export type EngineResolver = (req: CompletionRequest) => AutocompleteEngine;
+/**
+ * Register `POST <path>` streaming completions as SSE.
+ *
+ * Request body: CompletionRequest (JSON).
+ * Response events: {type:"chunk",text} then {type:"done",...CompletionResult},
+ * or {type:"error",message}.
+ *
+ * Usage in nebula-notebook's node-server:
+ *   const engine = new AutocompleteEngine({ backend: new ClaudeBackend() });
+ *   app.register(async (f) => registerAutocompleteRoute(f, engine), { prefix: "/api" });
+ */
+export declare function registerAutocompleteRoute(fastify: FastifyLikeInstance, engine: AutocompleteEngine | EngineResolver, options?: AutocompleteRouteOptions): void;
+export {};

package/node_modules/nebula-autocomplete/dist/server/fastify.js

@@ -0,0 +1,52 @@
+/**
+ * Register `POST <path>` streaming completions as SSE.
+ *
+ * Request body: CompletionRequest (JSON).
+ * Response events: {type:"chunk",text} then {type:"done",...CompletionResult},
+ * or {type:"error",message}.
+ *
+ * Usage in nebula-notebook's node-server:
+ *   const engine = new AutocompleteEngine({ backend: new ClaudeBackend() });
+ *   app.register(async (f) => registerAutocompleteRoute(f, engine), { prefix: "/api" });
+ */
+export function registerAutocompleteRoute(fastify, engine, options = {}) {
+    const path = options.path ?? "/autocomplete";
+    const resolve = typeof engine === "function" ? engine : () => engine;
+    fastify.post(path, async (req, reply) => {
+        reply.hijack?.(); // take over the raw socket for SSE (Fastify 4/5)
+        const res = reply.raw;
+        res.writeHead(200, {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache",
+            connection: "keep-alive",
+        });
+        const send = (obj) => res.write(`data: ${JSON.stringify(obj)}\n\n`);
+        const abort = new AbortController();
+        // Detect client disconnect via the RESPONSE stream closing before we
+        // ended it. (The request's "close" fires as soon as its body is fully
+        // consumed on modern Node — listening there aborts every request.)
+        res.on("close", () => {
+            if (!res.writableEnded)
+                abort.abort(new Error("client disconnected"));
+        });
+        try {
+            const body = req.body;
+            if (!body || typeof body.prefix !== "string") {
+                send({ type: "error", message: "prefix (string) is required" });
+                res.end();
+                return;
+            }
+            const result = await resolve(body).complete(body, {
+                signal: abort.signal,
+                onChunk: (text) => send({ type: "chunk", text }),
+            });
+            send({ type: "done", ...result });
+        }
+        catch (e) {
+            if (!abort.signal.aborted) {
+                send({ type: "error", message: e instanceof Error ? e.message : String(e) });
+            }
+        }
+        res.end();
+    });
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Process transport for backends: run a provider CLI either LOCALLY (same host
+ * as this process) or OVER SSH on a remote host.
+ *
+ * The over-ssh case powers "remote Nebula, local agent": the Nebula server runs
+ * on a cluster, but autocomplete should drive the user's OWN claude/codex on
+ * their laptop — reached over the reverse SSH tunnel the user already has. The
+ * CLI's stream-json stdio flows transparently over the ssh channel; a persistent
+ * warm worker keeps one ssh connection open (handshake paid once, not per turn),
+ * and ControlMaster makes any reconnect ~free. See the validated latency probe:
+ * per-turn overhead ≈ one network RTT (~50ms), negligible vs ~2s model latency.
+ */
+export interface SshTransport {
+    kind: 'ssh';
+    /** Host to ssh to — typically 'localhost' (the reverse-tunnel endpoint). */
+    host: string;
+    /** Reverse-tunnel port on this (server) host that forwards to the user's sshd. */
+    port: number;
+    /** Username on the user's machine. */
+    user: string;
+    /** Absolute path to the provider binary ON THE USER'S machine (PATH isn't set
+     *  for a non-interactive ssh, so this must be absolute). */
+    remoteBin: string;
+    /** ControlMaster socket path, so warm workers + reconnects reuse one connection. */
+    controlPath?: string;
+    /** Working dir on the remote side (created if absent). Keep it empty of any
+     *  CLAUDE.md so the agent harness stays minimal. */
+    remoteCwd?: string;
+}
+export type Transport = {
+    kind: 'local';
+} | SshTransport;
+export interface SpawnPlan {
+    command: string;
+    args: string[];
+    /** Options to pass to child_process.spawn (env/cwd). For ssh these are empty
+     *  because env/cwd are embedded in the remote command line. */
+    options: {
+        env?: NodeJS.ProcessEnv;
+        cwd?: string;
+    };
+}
+/** POSIX single-quote a string so it survives the remote shell verbatim. */
+export declare function shellQuote(s: string): string;
+/**
+ * Plan how to spawn `bin argv` with `env` in `cwd`, honoring the transport.
+ * - local: spawn the binary directly; env/cwd go to spawn().
+ * - ssh: spawn `ssh …host <remoteCmd>` where remoteCmd re-establishes cwd + env
+ *   on the far side (via `cd` and `env K=V …`) and execs the binary. `cwd`/`env`
+ *   passed here are interpreted on the REMOTE side.
+ */
+export declare function planSpawn(transport: Transport, bin: string, argv: string[], env: Record<string, string>, cwd: string): SpawnPlan;
+/** Best-effort remote cleanup (e.g. wipe an ephemeral config dir) over the same
+ *  ssh path. Returns the command+args for a fire-and-forget spawn. */
+export declare function planRemoteCleanup(transport: SshTransport, remotePath: string): SpawnPlan;

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

@@ -0,0 +1,66 @@
+/**
+ * Process transport for backends: run a provider CLI either LOCALLY (same host
+ * as this process) or OVER SSH on a remote host.
+ *
+ * The over-ssh case powers "remote Nebula, local agent": the Nebula server runs
+ * on a cluster, but autocomplete should drive the user's OWN claude/codex on
+ * their laptop — reached over the reverse SSH tunnel the user already has. The
+ * CLI's stream-json stdio flows transparently over the ssh channel; a persistent
+ * warm worker keeps one ssh connection open (handshake paid once, not per turn),
+ * and ControlMaster makes any reconnect ~free. See the validated latency probe:
+ * per-turn overhead ≈ one network RTT (~50ms), negligible vs ~2s model latency.
+ */
+/** POSIX single-quote a string so it survives the remote shell verbatim. */
+export function shellQuote(s) {
+    return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+const SSH_BASE_OPTS = [
+    '-o', 'ProxyCommand=none',
+    '-o', 'StrictHostKeyChecking=accept-new',
+    '-o', 'BatchMode=yes',
+    '-o', 'ServerAliveInterval=30',
+];
+/**
+ * Plan how to spawn `bin argv` with `env` in `cwd`, honoring the transport.
+ * - local: spawn the binary directly; env/cwd go to spawn().
+ * - ssh: spawn `ssh …host <remoteCmd>` where remoteCmd re-establishes cwd + env
+ *   on the far side (via `cd` and `env K=V …`) and execs the binary. `cwd`/`env`
+ *   passed here are interpreted on the REMOTE side.
+ */
+export function planSpawn(transport, bin, argv, env, cwd) {
+    if (transport.kind === 'local') {
+        return { command: bin, args: argv, options: { env: { ...process.env, ...env }, cwd } };
+    }
+    const sshOpts = [...SSH_BASE_OPTS, '-p', String(transport.port)];
+    if (transport.controlPath) {
+        // ControlPersist 1h (was 120s): the master handshake is the expensive part
+        // over the reverse tunnel, and a 2-minute persist meant any idle gap made
+        // the next worker spawn pay it again — part of the "autocomplete lags
+        // after I come back" cold start. An idle master on a localhost tunnel
+        // costs one file descriptor; keep it warm for the whole work session.
+        sshOpts.push('-o', 'ControlMaster=auto', '-o', `ControlPath=${transport.controlPath}`, '-o', 'ControlPersist=3600');
+    }
+    const remoteCwd = transport.remoteCwd ?? cwd;
+    const envPrefix = Object.entries(env).map(([k, v]) => `${k}=${shellQuote(v)}`).join(' ');
+    // mkdir+cd so the remote agent runs in a clean, CLAUDE.md-free dir; `exec env …`
+    // sets the child env on the far side (the local process.env doesn't reach it).
+    const remoteCmd = `mkdir -p ${shellQuote(remoteCwd)} 2>/dev/null; cd ${shellQuote(remoteCwd)} 2>/dev/null; ` +
+        `exec env ${envPrefix} ${shellQuote(transport.remoteBin)} ${argv.map(shellQuote).join(' ')}`;
+    return {
+        command: 'ssh',
+        args: [...sshOpts, `${transport.user}@${transport.host}`, remoteCmd],
+        options: {},
+    };
+}
+/** Best-effort remote cleanup (e.g. wipe an ephemeral config dir) over the same
+ *  ssh path. Returns the command+args for a fire-and-forget spawn. */
+export function planRemoteCleanup(transport, remotePath) {
+    const sshOpts = [...SSH_BASE_OPTS, '-p', String(transport.port)];
+    if (transport.controlPath)
+        sshOpts.push('-o', `ControlPath=${transport.controlPath}`);
+    return {
+        command: 'ssh',
+        args: [...sshOpts, `${transport.user}@${transport.host}`, `rm -rf ${shellQuote(remotePath)}`],
+        options: {},
+    };
+}

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

@@ -0,0 +1,103 @@
+export interface NotebookCellContext {
+    type: "code" | "markdown";
+    content: string;
+}
+export interface CompletionRequest {
+    /** Text before the cursor in the active cell. Required. */
+    prefix: string;
+    /** Text after the cursor in the active cell. */
+    suffix?: string;
+    /** Explicit language, if known. Usually omitted — prefer the hints below and
+     *  let the model infer the language from the code + kernel/filename. */
+    language?: string;
+    /** Active kernel name/spec (e.g. "python3", "ir", "julia-1.9"). A hint. */
+    kernelName?: string;
+    /** Notebook filename (e.g. "analysis.ipynb"). A hint. */
+    filename?: string;
+    /** All notebook cells, in order, for cross-cell context. */
+    cells?: NotebookCellContext[];
+    /** Index of the active cell within `cells`. */
+    activeCellIndex?: number;
+    /**
+     * Requests sharing a sessionKey supersede each other: issuing a new one
+     * aborts the previous in-flight request. Use the cell id.
+     */
+    sessionKey?: string;
+    /** Model override (e.g. "haiku" | "sonnet"). Engines are pooled per model. */
+    model?: string;
+    /** Per-request cross-cell context budget in chars (clamped server-side).
+     *  More context grounds suggestions in the notebook (fewer hallucinated
+     *  names) at the cost of a bigger prompt. */
+    contextBudget?: number;
+    /** Per-request cap on suggested lines (clamped server-side). */
+    maxLines?: number;
+    /** Backend selector, for servers hosting more than one engine. */
+    backend?: string;
+}
+export interface CompletionResult {
+    text: string;
+    backend: string;
+    fromCache: boolean;
+    ttfbMs: number;
+    totalMs: number;
+    /** Per-request engine/worker diagnostics (see CompletionDiag). */
+    diag?: CompletionDiag;
+}
+/**
+ * Where a completion's latency went — filled by the backend, forwarded in the
+ * SSE done event so the browser console can show the breakdown.
+ */
+export interface CompletionDiag {
+    /** Transport the worker ran on. */
+    transport?: string;
+    /** ms spent queued behind an earlier in-flight turn for the same session
+     *  (single-flight per cell — typing bursts wait for the previous turn
+     *  instead of fanning out across workers; see engine.complete). */
+    queueWaitMs?: number;
+    /** ms from request start until the turn was dispatched to a warm worker
+     *  (pool scan + possible spawn + warmup wait). The silent part of TTFB. */
+    workerWaitMs?: number;
+    /** A fresh worker process had to be spawned for this request. */
+    coldSpawn?: boolean;
+    /** The turn was retried on a fresh worker after the first one died. */
+    retried?: boolean;
+    /** How many turns this worker had already served (conversation history
+     *  grows with each turn, inflating time-to-first-byte). */
+    workerTurn?: number;
+    /** Accumulated prompt chars in this worker's history before this turn —
+     *  the actual TTFB-drag driver (recycled past maxHistoryCharsPerWorker). */
+    workerHistoryChars?: number;
+    /** Busy workers / pool size at request time (busy=size → cold spawn). */
+    poolBusy?: number;
+    poolSize?: number;
+    /** Characters in the assembled prompt. */
+    promptChars?: number;
+    /** Characters in the RAW model reply, before tag/fence/overlap trimming —
+     *  rawChars>0 with empty final text means post-processing removed it. */
+    rawChars?: number;
+}
+export interface CompleteOptions {
+    signal?: AbortSignal;
+    /** Called with each streamed text chunk (claude backend streams; codex emits once). */
+    onChunk?: (text: string) => void;
+}
+/** A completion backend: turns a prompt into text. */
+export interface CompletionBackend {
+    readonly name: string;
+    complete(prompt: string, opts: {
+        signal?: AbortSignal;
+        onChunk?: (text: string) => void;
+        diag?: CompletionDiag;
+    }): Promise<string>;
+    /** Release child processes. */
+    dispose(): void;
+}
+export interface EngineOptions {
+    backend: CompletionBackend;
+    /** Max completions cached (keyed on context). Default 128. 0 disables. */
+    cacheSize?: number;
+    /** Character budget for cross-cell context in the prompt. Default 6000. */
+    contextBudget?: number;
+    /** Max lines the model is asked to produce. Default 5. */
+    maxLines?: number;
+}

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

@@ -0,0 +1 @@
+export {};

package/node_modules/nebula-autocomplete/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "nebula-autocomplete",
+  "version": "0.1.0",
+  "description": "LLM code autocomplete engine backed by Claude Code / Codex CLI subscriptions, with a Fastify plugin and CodeMirror 6 ghost-text extension.",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/fastify.d.ts",
+      "default": "./dist/server/fastify.js"
+    },
+    "./client": {
+      "types": "./dist/client/fetcher.d.ts",
+      "default": "./dist/client/fetcher.js"
+    },
+    "./codemirror": {
+      "types": "./dist/codemirror/ghostText.d.ts",
+      "default": "./dist/codemirror/ghostText.js"
+    }
+  },
+  "files": [
+    "dist",
+    "server.js",
+    "server.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "node scripts/prepare.cjs",
+    "test": "vitest run",
+    "smoke": "node scripts/smoke.mjs"
+  },
+  "peerDependencies": {
+    "@codemirror/state": "^6.0.0",
+    "@codemirror/view": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@codemirror/state": {
+      "optional": true
+    },
+    "@codemirror/view": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@codemirror/state": "^6.5.0",
+    "@codemirror/view": "^6.36.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.0.0"
+  }
+}

package/node_modules/nebula-autocomplete/server.d.ts

@@ -0,0 +1,3 @@
+// Type shim for consumers on classic (node10) module resolution, which cannot
+// read the "exports" map. Runtime resolution still goes through "exports".
+export * from "./dist/server/fastify.js";

package/node_modules/nebula-autocomplete/server.js

@@ -0,0 +1,3 @@
+// Runtime shim mirroring server.d.ts (only used by resolvers that bypass the
+// "exports" map).
+export * from "./dist/server/fastify.js";