zidane 6.6.3 → 7.0.0

package/dist/inline-autocomplete-D0MPvBaS.js

@@ -1,596 +0,0 @@
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { readdirSync } from "node:fs";
-import { homedir } from "node:os";
-//#region src/chat/commands.ts
-/**
-* Persisted form of output blocks inside a display-only `command` turn:
-* plain blocks → `text` content; `detail` blocks → `tool_result` content
-* with the label/syntax carried in namespaced metadata (rebuilt into the
-* collapsed rendering on reload). Shared by the command emit flush and
-* `ctx.appendNote` so both persist identically.
-*/
-function commandBlocksToContent(blocks) {
-	return blocks.map((block) => {
-		if (!block.detail && !block.custom) return {
-			type: "text",
-			text: block.text
-		};
-		const commandMeta = block.custom ? { custom: {
-			renderer: block.custom.renderer,
-			...block.custom.data !== void 0 ? { data: block.custom.data } : {}
-		} } : {
-			...block.detail?.label ? { label: block.detail.label } : {},
-			...block.detail?.syntax ? { syntax: block.detail.syntax } : {}
-		};
-		return {
-			type: "tool_result",
-			callId: `command_detail_${crypto.randomUUID()}`,
-			output: block.text,
-			...Object.keys(commandMeta).length > 0 ? { metadata: { command: commandMeta } } : {}
-		};
-	});
-}
-/**
-* Map ONE command-output block to its LIVE transcript event — the
-* in-memory mirror of {@link commandBlocksToContent}'s persisted shape
-* (whose replay side lives in `eventsFromTurns`). One definition shared
-* by the command emit flush and the `ctx.appendNote` host impl so live
-* rendering can never drift from reloaded rendering — the exact drift
-* that shipped `custom` blocks rendering only after a reload.
-*
-* Precedence matches the persisted side: `custom` > `detail` > markdown.
-*/
-function commandBlockToEvent(block) {
-	if (block.custom) return {
-		kind: "custom",
-		text: block.text,
-		custom: {
-			renderer: block.custom.renderer,
-			...block.custom.data !== void 0 ? { data: block.custom.data } : {}
-		}
-	};
-	if (block.detail) return {
-		kind: "command-detail",
-		text: block.text,
-		...block.detail.label ? { label: block.detail.label } : {},
-		...block.detail.syntax ? { syntax: block.detail.syntax } : {}
-	};
-	return {
-		kind: "markdown",
-		text: block.text,
-		streaming: false
-	};
-}
-/** Normalize a command to its ordered step list (`steps` wins over `run`). */
-function commandSteps(command) {
-	if (command.steps && command.steps.length > 0) return command.steps;
-	if (command.run) return [{ run: command.run }];
-	return [];
-}
-/**
-* Parse a prompt as a command invocation, but only when the command token is
-* the LEADING token of the whole prompt and names a known command. This is
-* what keeps mid-prompt `/skill` mentions routed to the skills provider:
-* `"summarize /research"` is not a command, `"/research foo"` is.
-*
-* `known` is matched case-insensitively; entries may be bare names or
-* `{ name, aliases }` records — an alias hit canonicalizes to the entry's
-* `name` (registered casing), so dispatch-by-name downstream just works.
-*/
-function parseCommandInvocation(prompt, known) {
-	const body = prompt.trimStart();
-	if (body[0] !== "/") return null;
-	const afterSlash = body.slice(1);
-	const wsIdx = afterSlash.search(/\s/);
-	const typed = (wsIdx === -1 ? afterSlash : afterSlash.slice(0, wsIdx)).toLowerCase();
-	if (typed.length === 0) return null;
-	let canonical;
-	for (const entry of known) {
-		const name = typeof entry === "string" ? entry : entry.name;
-		if (name.toLowerCase() === typed) {
-			canonical = name;
-			break;
-		}
-		if (typeof entry !== "string" && entry.aliases?.some((a) => a.toLowerCase() === typed)) {
-			canonical = name;
-			break;
-		}
-	}
-	if (canonical === void 0) return null;
-	const args = (wsIdx === -1 ? "" : afterSlash.slice(wsIdx + 1)).trim();
-	return {
-		name: canonical,
-		invokedAs: typed,
-		args,
-		argv: args.length > 0 ? args.split(/\s+/) : []
-	};
-}
-/**
-* Run a command's steps in order, threading `ctx.data`. Stops at the first
-* step that throws (error isolated + returned, not rethrown) or when the
-* signal aborts. Pure orchestration — all I/O lives in the host-supplied
-* `ctx` capabilities.
-*/
-async function executeCommand(command, ctx) {
-	const steps = commandSteps(command);
-	let ranSteps = 0;
-	for (const step of steps) {
-		if (ctx.signal.aborted) return {
-			ok: false,
-			ranSteps,
-			aborted: true
-		};
-		ranSteps++;
-		try {
-			const result = await step.run(ctx);
-			if (result && result.data) Object.assign(ctx.data, result.data);
-		} catch (error) {
-			if (ctx.signal.aborted) return {
-				ok: false,
-				ranSteps,
-				aborted: true
-			};
-			return {
-				ok: false,
-				ranSteps,
-				error
-			};
-		}
-	}
-	return {
-		ok: true,
-		ranSteps
-	};
-}
-//#endregion
-//#region src/zod.ts
-function isStandardSchema(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const marker = value["~standard"];
-	return typeof marker === "object" && marker !== null && typeof marker.vendor === "string";
-}
-/**
-* Resolve a {@link SchemaInput} to the plain JSON Schema object providers
-* expect. Zod schemas convert via the lazily-imported `z.toJSONSchema`
-* (v4 native); other Standard Schema vendors are rejected with a clear
-* error — conversion is vendor-specific and only zod is wired today.
-*/
-async function resolveSchemaInput(schema) {
-	if (!isStandardSchema(schema)) return schema;
-	const vendor = schema["~standard"].vendor;
-	if (vendor !== "zod") throw new Error(`unsupported schema vendor "${vendor}" — pass a zod v4 schema or a plain JSON Schema object`);
-	let toJSONSchema;
-	try {
-		toJSONSchema = (await import("zod")).z.toJSONSchema;
-	} catch {
-		throw new Error("a zod schema was passed but the \"zod\" package could not be imported — install zod >= 4");
-	}
-	return zodToJsonSchema(toJSONSchema(schema));
-}
-/**
-* Normalize a JSON Schema (e.g. from zod v4's z.toJSONSchema()) for use
-* as a ToolSpec.inputSchema.
-*
-* Strips the $schema key that some providers reject.
-*/
-function zodToJsonSchema(jsonSchema) {
-	const { $schema, ...rest } = jsonSchema;
-	return rest;
-}
-//#endregion
-//#region src/chat/generate-title.ts
-/** Hard cap on the result length. Anything longer is truncated client-side. */
-const TITLE_MAX_CHARS = 60;
-/** Default turn count fed to the model. 10 covers most exchanges without bloat. */
-const DEFAULT_MAX_TURNS = 10;
-/** Tokens budgeted for the model's reply. 64 fits any sane title with headroom. */
-const TITLE_RESPONSE_MAX_TOKENS = 64;
-/** Per-turn body cap when assembling the prompt — keeps the request payload tight. */
-const PROMPT_TURN_CHAR_MAX = 2e3;
-/**
-* System prompt for the titling call.
-*
-* Written as a LABELING task, not a chat turn: handed a bare "generate a
-* title for this conversation" instruction with the transcript inline, a
-* cheap model reads the trailing assistant message and just keeps
-* talking — observed in the wild as a session titled `I don't have a
-* "plan tool" available in this conversation…`, i.e. the model answering
-* the last user turn instead of naming it. The rules below say what the
-* model IS (an annotator, not a participant), and the examples show the
-* shape — including the exact failure case (a transcript whose last turn
-* is a refusal) so the answer-shaped completion has a labeled
-* counter-example to copy instead.
-*/
-const TITLE_SYSTEM_PROMPT = [
-	"You label conversations. Each input is a transcript of a session between a user and a coding agent.",
-	"Name what the session is ABOUT. You are an annotator, never a participant in the conversation.",
-	"",
-	"Rules:",
-	"- Reply with ONLY the label: no quotes, no markdown, no trailing punctuation, no preamble.",
-	`- 3 to 7 words, under ${TITLE_MAX_CHARS} characters, written as a noun phrase or an imperative.`,
-	"- Name the user's topic or task using concrete nouns from the transcript: files, tools, features, errors.",
-	"- NEVER answer, continue, or comment on the conversation — not even when the last message is a question, a refusal, or an error.",
-	"- No first person (\"I\", \"we\"), no \"the user\", and no filler words like conversation, session, chat, request, discussion, help.",
-	"",
-	"Examples of a transcript and its label:",
-	"- user asks why `bun test` hangs after an upgrade, agent finds a stuck worker → Bun test hangs on stuck worker",
-	"- user asks for a --json flag on the CLI → Add JSON output flag to the CLI",
-	"- user asks about a plan tool, agent replies that no such tool exists → Missing plan tool in the agent toolset"
-].join("\n");
-/**
-* Openers that mark a model reply rather than a label — the model
-* answering the transcript instead of naming it. Treated as a failed
-* generation (see {@link cleanTitle}) so the auto-titler retries on the
-* next run rather than persisting a sentence as the session name.
-*
-* Deliberately conservative: only phrasings that a real title would
-* never start with. Excluded on purpose because they head perfectly good
-* titles: `no` / `there is` ("No JSON output in the CLI"), `ok` / `yes` /
-* `great` ("OK button never fires", "Yes/no confirm regression").
-*
-* The pronoun cases require FOLLOWING WHITESPACE rather than a word
-* boundary — `\b` after `i` also matches punctuation, which rejected
-* "I/O timeout in the docker context". Contractions are matched
-* explicitly instead, with both the straight and typographic apostrophe
-* (models emit U+2019 freely, and `here's` / `let's` have no bare-word
-* alternative to fall back on).
-*/
-const ANSWER_SHAPED_OPENER = /^(?:i\s|i['’](?:m|ve|ll|d)\b|we\s|we['’](?:re|ve|ll)\b|let['’]s\b|let\s+(?:me|us)\b|sure\b|certainly\b|okay\b|sorry\b|thanks\b|unfortunately\b|here['’]s\b|here\s+is\b|as\s+an\b|you\s+(?:can|should|need)\b|it\s+(?:looks|seems|appears)\b)/i;
-/**
-* Drive the provider's `stream()` once and return a concise title for
-* the conversation represented by `turns`. Throws when:
-*   - `turns` contains no text-bearing content (nothing to summarize),
-*   - the provider stream completes with no output text,
-*   - the model answered the transcript instead of labeling it (see
-*     {@link cleanTitle}) — a failed generation the caller retries,
-*   - `signal` is aborted (rethrown verbatim).
-*
-* Output is trimmed, single-line, with surrounding quotes / trailing
-* punctuation stripped, and truncated to `TITLE_MAX_CHARS`.
-*/
-async function generateSessionTitle({ provider, model, turns, maxTurns = DEFAULT_MAX_TURNS, signal }) {
-	const transcript = renderTitleTranscript(turns, maxTurns);
-	if (!transcript) throw new Error("No text content in the recent turns to summarize.");
-	const userPrompt = [
-		"<transcript>",
-		transcript,
-		"</transcript>",
-		"",
-		"Write the label for the session in the transcript above. Label only."
-	].join("\n");
-	let text = "";
-	const result = await provider.stream({
-		model,
-		system: TITLE_SYSTEM_PROMPT,
-		tools: [],
-		messages: [provider.userMessage(userPrompt)],
-		maxTokens: TITLE_RESPONSE_MAX_TOKENS,
-		...signal ? { signal } : {}
-	}, { onText: (delta) => {
-		text += delta;
-	} });
-	return cleanTitle(text.trim().length > 0 ? text : result.text);
-}
-/**
-* Decide whether a session is ready for one-shot automatic titling.
-*
-* Returns `true` iff the conversation has had its first exchange — at
-* least two turns, i.e. the opening user message plus the assistant's
-* reply (this is exactly the "N turns" count the sessions list shows) —
-* AND no explicit title has been set yet. An existing `metadata.title`
-* (a previous auto-generation, or a manual title from the session-details
-* "generate title" action) is never clobbered.
-*
-* Pure + total. The runtime layers its own "is one already in flight?"
-* and "is a provider picked?" guards on top of this; the predicate only
-* encodes the content-level rule so it can be pinned in tests without a
-* mock provider — same rationale as the exported {@link cleanTitle}.
-*/
-function shouldAutoGenerateTitle(turns, metadata) {
-	if ((typeof metadata?.title === "string" ? metadata.title.trim() : "").length > 0) return false;
-	return turns.length >= 2;
-}
-/**
-* Assemble the transcript fed to the titling model: the session's
-* OPENING user turn (when it falls outside the window) followed by the
-* last `maxTurns` turns, separated by an `…` gap marker.
-*
-* The tail alone is not enough. A session's topic is set by the first
-* thing the user asked; after a dozen turns that message is off the
-* window and the model ends up naming whatever tangent the conversation
-* was on when titling fired — or, worse, the assistant's last reply.
-* Anchoring on the opening intent keeps the label about the session.
-*
-* `maxTurns` keeps its meaning (a cap on TRAILING turns); the anchor is
-* one extra entry on top, and only exists when the window actually cut
-* it off. Returns `''` when nothing in the selection carries text.
-*/
-function renderTitleTranscript(turns, maxTurns) {
-	const cap = Math.max(1, maxTurns);
-	const tail = renderTurnsForPrompt(turns.slice(-cap));
-	const opening = turns.slice(0, Math.max(0, turns.length - cap)).find((turn) => turn.role === "user" && textBodyOf(turn).length > 0);
-	const anchor = opening ? renderTurnsForPrompt([opening]) : "";
-	if (anchor && tail) return `${anchor}\n\n…\n\n${tail}`;
-	return anchor || tail;
-}
-/**
-* Compact a turn list into a transcript-style prompt:
-*
-*   user: …
-*   assistant: …
-*   user: …
-*
-* Tool calls and tool results are dropped entirely — a cheap title model
-* happily echoes plumbing like `[tool: list_files]` back as "the title"
-* when a marker is the only assistant content it sees. The topical text
-* is what a title needs. Per-turn text is clipped at `PROMPT_TURN_CHAR_MAX`
-* so a single huge code dump doesn't blow the budget.
-*
-* Returns an empty string when the slice has no text-bearing content
-* (e.g. a turn list that's only tool plumbing).
-*
-* Exported for reuse by other silent one-shot helpers (`generate-data`'s
-* optional conversation context) so every side-channel inference compacts
-* history the same way.
-*/
-function renderTurnsForPrompt(turns) {
-	const lines = [];
-	for (const turn of turns) {
-		const body = textBodyOf(turn);
-		if (!body) continue;
-		const role = turn.role === "assistant" ? "assistant" : turn.role === "user" ? "user" : "system";
-		lines.push(`${role}: ${clip(body, PROMPT_TURN_CHAR_MAX)}`);
-	}
-	return lines.join("\n\n");
-}
-function textBodyOf(turn) {
-	const parts = [];
-	for (const block of turn.content) if (block.type === "text" && block.text.trim()) parts.push(block.text.trim());
-	return parts.join(" ");
-}
-/** Strip one layer of matched surrounding quotes (`"foo"`, `'foo'`, `` `foo` ``, `“foo”`). */
-function unwrapQuotes(s) {
-	if (s.length < 2) return s;
-	const first = s.charAt(0);
-	const last = s.charAt(s.length - 1);
-	return first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`" || first === "“" && last === "”" ? s.slice(1, -1).trim() : s;
-}
-/**
-* Normalize a model-generated title into the shape we want to persist:
-*
-*   - Collapse internal whitespace + take the first line only (some
-*     models emit "Title: foo\n\nReason: …" despite instructions).
-*   - Strip surrounding quotes, a leading `Title:` / `title -` preamble,
-*     and a `user:` / `assistant:` role prefix echoed from the transcript
-*     — repeatedly, in any nesting order.
-*   - Reject placeholders and answer-shaped replies (see
-*     {@link ANSWER_SHAPED_OPENER}) by throwing.
-*   - Strip trailing punctuation (`.`, `!`, `?`) — titles read cleaner
-*     without it.
-*   - Truncate to `TITLE_MAX_CHARS` with a trailing `…` when over.
-*
-* Exported as `cleanTitle` so tests can pin the normalization rules
-* without going through a mock provider.
-*/
-function cleanTitle(raw) {
-	let s = raw.split("\n")[0]?.trim() ?? "";
-	for (let pass = 0; pass < 4; pass++) {
-		const before = s;
-		s = unwrapQuotes(s);
-		s = s.replace(/^\s*title\s*[:\-–—]\s*/i, "");
-		s = s.replace(/^\s*(?:user|assistant|system)\s*:\s*/i, "");
-		if (s === before) break;
-	}
-	s = s.replace(/[.!?]+$/, "").trim();
-	if (s.length === 0) throw new Error("Model returned an empty title.");
-	if (/^\[.*\]$/.test(s)) throw new Error("Model returned a placeholder instead of a title.");
-	if (ANSWER_SHAPED_OPENER.test(s)) throw new Error("Model answered the conversation instead of titling it.");
-	return s.length > TITLE_MAX_CHARS ? `${s.slice(0, TITLE_MAX_CHARS - 1)}…` : s;
-}
-function clip(text, max) {
-	return text.length > max ? `${text.slice(0, max)}…` : text;
-}
-//#endregion
-//#region src/chat/generate-data.ts
-/** Synthetic forced-choice tool name (never persisted — the call is side-channel only). */
-const DATA_TOOL_NAME = "__data__";
-/** Default cap on conversation turns folded into the context block. */
-const DEFAULT_CONTEXT_TURNS = 12;
-async function generateStructuredData(options) {
-	const { provider, model, prompt, signal } = options;
-	const spec = {
-		name: DATA_TOOL_NAME,
-		description: "Return the result. The input of this call IS the answer — it must conform to the schema.",
-		inputSchema: await resolveSchemaInput(options.schema)
-	};
-	const contextTurns = options.turns && options.turns.length > 0 ? options.turns.slice(-(options.maxContextTurns ?? DEFAULT_CONTEXT_TURNS)) : [];
-	const transcript = contextTurns.length > 0 ? renderTurnsForPrompt(contextTurns) : "";
-	const userPrompt = transcript ? `<conversation>\n${transcript}\n</conversation>\n\n${prompt}` : prompt;
-	const payload = (await provider.stream({
-		model,
-		system: options.system ?? `You produce structured data. Call the ${DATA_TOOL_NAME} tool exactly once with the requested value. No prose.`,
-		tools: provider.formatTools([spec]),
-		messages: [provider.userMessage(userPrompt)],
-		toolChoice: {
-			type: "tool",
-			name: DATA_TOOL_NAME
-		},
-		...signal ? { signal } : {}
-	}, { onText: () => {} })).toolCalls.find((tc) => tc.name === DATA_TOOL_NAME)?.input;
-	if (payload === void 0) throw new Error("generateStructuredData: the model returned no structured payload");
-	return payload;
-}
-//#endregion
-//#region src/chat/inline-autocomplete.ts
-/**
-* Inline (ghost-text) autocomplete for the prompt.
-*
-* Distinct from the trigger-based completion popover (`@` files, `/`
-* commands): providers here suggest plain text SUFFIX candidates to
-* append at the cursor — the first renders as dim ghost text, up/down
-* rotates through the rest, Tab accepts. No popover.
-*
-* Providers are queried in registration order with a shared AbortSignal;
-* the engine returns the first provider's non-empty candidate list.
-* Extensions add providers via `ctx.registerInlineAutocompleteProvider`
-* — the built-in path provider ({@link createPathAutocompleteProvider})
-* is always first.
-*/
-/** Default per-provider deadline — a hung provider is treated as "no suggestion". */
-const PROVIDER_DEADLINE_MS = 150;
-/** Hard cap on a provider's `deadlineMs` — past this, waiting for a ghost reads as broken. */
-const MAX_PROVIDER_DEADLINE_MS = 2e3;
-/**
-* Query `providers` in order; the first provider yielding a non-empty
-* candidate list wins (a bare string normalizes to a 1-element list).
-* Provider errors are swallowed (a broken extension provider must not
-* break typing), and each provider races its deadline —
-* {@link PROVIDER_DEADLINE_MS} by default, a provider's own `deadlineMs`
-* (capped at {@link MAX_PROVIDER_DEADLINE_MS}) when declared — so one
-* hung provider can't permanently suppress the ghosts of providers
-* behind it. Returns null when aborted or nothing matched.
-*/
-async function resolveInlineSuggestion(providers, ctx, deadlineMs = PROVIDER_DEADLINE_MS, maxDeadlineMs = MAX_PROVIDER_DEADLINE_MS) {
-	const TIMEOUT = Symbol("timeout");
-	for (const provider of providers) {
-		if (ctx.signal.aborted) return null;
-		try {
-			let timer;
-			const budget = provider.deadlineMs !== void 0 ? Math.min(Math.max(provider.deadlineMs, 1), maxDeadlineMs) : deadlineMs;
-			const result = await Promise.race([Promise.resolve(provider.suggest(ctx)), new Promise((r) => {
-				timer = setTimeout(r, budget, TIMEOUT);
-			})]);
-			if (timer !== void 0) clearTimeout(timer);
-			if (result === TIMEOUT) continue;
-			if (ctx.signal.aborted) return null;
-			const suffixes = (typeof result === "string" ? [result] : result ?? []).filter((s) => typeof s === "string" && s.length > 0);
-			if (suffixes.length > 0) return {
-				suffixes,
-				providerId: provider.id
-			};
-		} catch {}
-	}
-	return null;
-}
-/**
-* Extract the whitespace-delimited token that ends at `cursor`. Returns
-* null when the cursor sits right after whitespace (nothing to complete).
-*/
-function tokenEndingAtCursor(text, cursor) {
-	const match = text.slice(0, cursor).match(/\S+$/);
-	return match ? match[0] : null;
-}
-/**
-* Does this token carry an explicit path shape (`/` separator or a `~`
-* prefix)? Path-shaped tokens complete from the first character after
-* the separator; bare tokens (`sr` → `c/`) still complete against the
-* cwd listing but need ≥2 chars first — see the provider.
-*/
-function looksLikePath(token) {
-	return token.includes("/") || token.startsWith("~");
-}
-/**
-* Cap on candidates returned for an ambiguous fragment — rotation past
-* a dozen-odd entries stops being faster than typing another character.
-*/
-const MAX_PATH_CANDIDATES = 16;
-function defaultReaddir(dir) {
-	return readdirSync(dir, { withFileTypes: true }).map((e) => ({
-		name: e.name,
-		isDirectory: e.isDirectory()
-	}));
-}
-/**
-* Built-in provider: complete filesystem paths under `cwd` (or absolute /
-* `~` paths). Given the token `src/chat/comp`, lists `src/chat/` and
-* returns every matching continuation of `comp` as a candidate list —
-* directories first, alphabetical, `/`-terminated for directories so
-* typing can continue. The host ghosts the first candidate and rotates
-* through the rest on up/down.
-*
-* Bare tokens (no `/` yet) are matched against the cwd listing too, so
-* a directory ghost appears as soon as the first characters of `src`
-* are typed — but only from the second character on, so 1-letter prose
-* words don't ghost-spam.
-*
-* Dotfiles are only offered when the typed fragment itself starts with
-* `.` — the usual completion convention.
-*/
-function createPathAutocompleteProvider(opts = {}) {
-	const readdir = opts.io?.readdir ?? defaultReaddir;
-	const fallbackCwd = opts.cwd ?? (() => process.cwd());
-	return {
-		id: "paths",
-		suggest(ctx) {
-			const token = tokenEndingAtCursor(ctx.text, ctx.cursor);
-			if (!token) return null;
-			if (!looksLikePath(token) && token.length < 2) return null;
-			const expanded = token.startsWith("~") ? join(homedir(), token.slice(1)) : token;
-			const endsWithSep = expanded.endsWith("/");
-			const dirPart = endsWithSep ? expanded : dirname(expanded);
-			const fragment = endsWithSep ? "" : basename(expanded);
-			const baseCwd = ctx.cwd || fallbackCwd();
-			const dir = isAbsolute(dirPart) ? dirPart : resolve(baseCwd, dirPart);
-			let entries;
-			try {
-				entries = readdir(dir);
-			} catch {
-				return null;
-			}
-			const matches = entries.filter((e) => e.name.startsWith(fragment) && (fragment.startsWith(".") || !e.name.startsWith(".")));
-			matches.sort((a, b) => a.isDirectory !== b.isDirectory ? a.isDirectory ? -1 : 1 : a.name.localeCompare(b.name));
-			const suffixes = matches.map((e) => e.name.slice(fragment.length) + (e.isDirectory ? "/" : "")).filter((s) => s.length > 0).slice(0, MAX_PATH_CANDIDATES);
-			return suffixes.length > 0 ? suffixes : null;
-		}
-	};
-}
-/**
-* Optimistically transform the current ghost across a buffer edit so it
-* stays visible while the debounced provider re-query is in flight —
-* without this, every keystroke inside a completable token blinks the
-* ghost (hide → 120 ms → reshow).
-*
-* Two edits are reconcilable (everything else returns null and waits for
-* the authoritative result):
-*   - typing FORWARD along the suggestion (`bi` → `bin` with ghost
-*     `n/`): candidates are filtered to those starting with the typed
-*     chars and trimmed;
-*   - deleting BACKWARD within the token (`bin` → `bi` with ghost `/`):
-*     the deleted chars are re-prepended to every candidate. Guarded to
-*     non-whitespace so crossing a token boundary drops the ghost.
-*
-* The patched ghost is provisional — the provider's answer replaces it
-* (and may add candidates the patch couldn't know about).
-*/
-function patchInlineGhost(prev, text, cursor) {
-	if (!prev) return null;
-	if (text === prev.text && cursor === prev.cursor) return prev;
-	if (text.slice(cursor) !== prev.text.slice(prev.cursor)) return null;
-	if (cursor > prev.cursor) {
-		if (text.slice(0, prev.cursor) !== prev.text.slice(0, prev.cursor)) return null;
-		const typed = text.slice(prev.cursor, cursor);
-		const shown = prev.suffixes[prev.index];
-		const suffixes = prev.suffixes.filter((s) => s.startsWith(typed) && s.length > typed.length).map((s) => s.slice(typed.length));
-		if (suffixes.length === 0) return null;
-		const shownTrimmed = shown.startsWith(typed) ? shown.slice(typed.length) : null;
-		return {
-			suffixes,
-			index: shownTrimmed !== null ? Math.max(0, suffixes.indexOf(shownTrimmed)) : 0,
-			text,
-			cursor
-		};
-	}
-	if (prev.text.slice(0, cursor) !== text.slice(0, cursor)) return null;
-	const deleted = prev.text.slice(cursor, prev.cursor);
-	if (deleted.length === 0 || /\s/.test(deleted)) return null;
-	return {
-		suffixes: prev.suffixes.map((s) => deleted + s),
-		index: prev.index,
-		text,
-		cursor
-	};
-}
-//#endregion
-export { generateStructuredData as a, shouldAutoGenerateTitle as c, zodToJsonSchema as d, commandBlockToEvent as f, parseCommandInvocation as g, executeCommand as h, tokenEndingAtCursor as i, isStandardSchema as l, commandSteps as m, patchInlineGhost as n, cleanTitle as o, commandBlocksToContent as p, resolveInlineSuggestion as r, generateSessionTitle as s, createPathAutocompleteProvider as t, resolveSchemaInput as u };
-
-//# sourceMappingURL=inline-autocomplete-D0MPvBaS.js.map