@m4ike1/ion-coding-agent 0.1.0

package/dist/extensions/cue/autocomplete.js

@@ -0,0 +1,744 @@
+import { fuzzyFilter } from "@m4ike1/ion-tui";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+/**
+ * Autocomplete provider for Cue directives.
+ *
+ * Triggers:
+ * - `[` at line start or after whitespace -> element name suggestions
+ * - `[Element: ` -> tag suggestions for that element
+ * - `[Element: tag` (complete tag) -> `>` or `]` flow suggestions
+ * - `[Element: tag1>tag2>` -> smart tag suggestions (no override conflicts)
+ * - `{@` -> file/dir path suggestions from disk
+ * - `{@path:` -> line range suggestions
+ *
+ * Bare `@path` outside braces is handled by the base provider, which inserts
+ * a standalone `{@path}` scope statement.
+ */
+export class CueAutocompleteProvider {
+    triggerCharacters = ["[", ">", "]", "{"];
+    registry;
+    projectRoot;
+    constructor(registry, projectRoot = process.cwd()) {
+        this.registry = registry;
+        this.projectRoot = projectRoot;
+    }
+    /** Get override dimensions for a tag, checking element-local then shared tags. */
+    getTagOverrides(element, tagName) {
+        const normalized = tagName.toLowerCase();
+        const tagDef = element.tags[normalized];
+        if (tagDef)
+            return tagDef.overrides;
+        const shared = this.registry.getSharedTagOverrides(normalized);
+        return shared ?? [];
+    }
+    async getSuggestions(lines, cursorLine, cursorCol, _options) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        // 0. Alias completion: `/name` on its own line suggests cue.toml shortcuts.
+        // Bare `/` returns null so the slash-command menu keeps working.
+        const aliasPrefix = this.extractAliasPrefix(textBeforeCursor);
+        if (aliasPrefix !== null) {
+            return this.getAliasSuggestions(aliasPrefix);
+        }
+        // 1. Element name completion: `[` at line start or after whitespace
+        const bracketPrefix = this.extractBracketPrefix(textBeforeCursor);
+        if (bracketPrefix !== null) {
+            return this.getElementSuggestions(bracketPrefix);
+        }
+        // 2. After element selected but no colon yet: `[Element` -> suggest `:` or `]`
+        const elementNoColon = this.extractElementNoColon(textBeforeCursor);
+        if (elementNoColon !== null) {
+            return this.getElementFlowSuggestions(elementNoColon);
+        }
+        // 3. Tag context extraction
+        const tagContext = this.extractTagContext(textBeforeCursor);
+        if (tagContext) {
+            // 2a. If we have a complete tag (not partial), suggest flow: `>` or `]`
+            if (tagContext.isComplete && tagContext.lastTag) {
+                return this.getFlowSuggestions(tagContext.element, tagContext.selectedTags);
+            }
+            // 2b. If we have tags already selected, filter by non-conflicting overrides
+            if (tagContext.selectedTags.length > 0) {
+                const smart = this.getSmartTagSuggestions(tagContext.element, tagContext.partial, tagContext.selectedTags);
+                if (smart && smart.items.length > 0)
+                    return smart;
+                // No more valid tags -- only `]` left
+                return this.getCloseOnlySuggestions();
+            }
+            // 2c. First tag - show all available tags
+            return this.getTagSuggestions(tagContext.element, tagContext.partial);
+        }
+        // 5. Scope completion: `{` anywhere (standalone scope statements)
+        const scopePrefix = this.extractScopePrefix(textBeforeCursor);
+        if (scopePrefix !== null) {
+            if (scopePrefix.type === "file") {
+                return this.getScopedSuggestions(scopePrefix.partial);
+            }
+            if (scopePrefix.type === "skill") {
+                // Delegate to base provider for skill name completions (e.g. {$commit})
+                return null;
+            }
+            // Just `{` - suggest the `@` / `$` scope starters
+            return this.getScopePrefixSuggestions(scopePrefix.partial);
+        }
+        return null;
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        const currentLine = lines[cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, cursorCol);
+        const textAfterCursor = currentLine.slice(cursorCol);
+        const cueItem = item;
+        if (cueItem._cueType === "element") {
+            return this.applyElementCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        if (cueItem._cueType === "tag") {
+            return this.applyTagCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        if (cueItem._cueType === "flow") {
+            return this.applyFlowCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        if (cueItem._cueType === "scope") {
+            return this.applyScopeCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        if (cueItem._cueType === "scopeFlow") {
+            return this.applyScopeFlowCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        if (cueItem._cueType === "scopePrefix") {
+            return this.applyScopePrefixCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        if (cueItem._cueType === "alias") {
+            return this.applyAliasCompletion(lines, cursorLine, cursorCol, item, textBeforeCursor, textAfterCursor);
+        }
+        // Fallback: just insert the value
+        const beforePrefix = textBeforeCursor.slice(0, textBeforeCursor.length - prefix.length);
+        const newLine = beforePrefix + item.value + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        return { lines: newLines, cursorLine, cursorCol: beforePrefix.length + item.value.length };
+    }
+    // ─── Extraction Methods ────────────────────────────────────────────────────
+    /** Extract `[` prefix for element completion */
+    extractBracketPrefix(text) {
+        const match = text.match(/(?:^|\s)\[([A-Za-z][A-Za-z0-9_-]*)?$/);
+        if (match) {
+            const partial = match[1] || "";
+            // If the partial matches a real element, let extractElementNoColon handle it
+            if (partial && this.registry.get(partial))
+                return null;
+            return partial;
+        }
+        if (text.endsWith("[") && (text.length === 1 || /\s/.test(text[text.length - 2] ?? ""))) {
+            return "";
+        }
+        return null;
+    }
+    /** Extract element name when we have `[Element` but no colon yet */
+    extractElementNoColon(text) {
+        // Don't match if the bracket is closed
+        if (text.endsWith("]"))
+            return null;
+        const match = text.match(/\[([A-Za-z][A-Za-z0-9_-]*)$/);
+        if (!match)
+            return null;
+        const element = match[1] ?? "";
+        if (!this.registry.get(element))
+            return null;
+        return element;
+    }
+    /**
+     * Extract tag context from the text before cursor.
+     * Returns null if not in a tag context.
+     */
+    extractTagContext(text) {
+        // Check if we're inside a `[Element: ...]` directive
+        // Use [^]]*$ to match only up to the LAST unclosed bracket
+        const bracketMatch = text.match(/\[([A-Za-z][A-Za-z0-9_-]*):\s*([^\]]*)$/);
+        if (!bracketMatch)
+            return null;
+        const element = bracketMatch[1] ?? "";
+        const afterColon = bracketMatch[2] ?? "";
+        // If directive is closed, not in tag context
+        if (afterColon.includes("]"))
+            return null;
+        // Parse tag chain by splitting on `>`
+        const parts = afterColon.split(">").map((p) => p.trim());
+        const selectedTags = [];
+        let partial = "";
+        let isComplete = false;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i] ?? "";
+            const isLast = i === parts.length - 1;
+            if (isLast) {
+                if (afterColon.includes(">")) {
+                    // There's a `>` in the chain -- after `> `, user wants to chain more tags
+                    if (part === "") {
+                        // Empty after `> ` -- ready for next tag, show tag suggestions
+                        isComplete = false;
+                    }
+                    else if (afterColon.endsWith(" ")) {
+                        // Tag followed by space after `>` -- complete tag, show tag suggestions
+                        selectedTags.push(part);
+                    }
+                    else {
+                        // Tag at end without space -- partial (user still typing)
+                        partial = part;
+                    }
+                }
+                else {
+                    // No `>` in chain yet
+                    if (part === "") {
+                        // Empty after `: ` -- ready for first tag
+                        isComplete = true;
+                    }
+                    else if (afterColon.endsWith(" ")) {
+                        // Tag followed by space -- complete, show flow (`>`/`]`)
+                        selectedTags.push(part);
+                        isComplete = true;
+                    }
+                    else {
+                        // Tag being typed
+                        partial = part;
+                    }
+                }
+            }
+            else {
+                // Not last part -- must be a complete selected tag
+                if (part)
+                    selectedTags.push(part);
+            }
+        }
+        const lastTag = selectedTags.length > 0 ? (selectedTags[selectedTags.length - 1] ?? null) : null;
+        // If partial exactly matches a valid tag, treat it as complete
+        if (!isComplete && partial) {
+            const elementDef = this.registry.get(element);
+            const isLocal = elementDef?.tags[partial.toLowerCase()];
+            const isShared = this.registry.getSharedTagDefs().has(partial.toLowerCase());
+            if (isLocal || isShared) {
+                selectedTags.push(partial);
+                partial = "";
+                isComplete = true;
+            }
+        }
+        return {
+            element,
+            partial,
+            selectedTags,
+            lastTag: isComplete && selectedTags.length > 0 ? (selectedTags[selectedTags.length - 1] ?? null) : lastTag,
+            isComplete,
+        };
+    }
+    /**
+     * Extract scope prefix from text before cursor.
+     * Matches `{` anywhere (standalone scope statement).
+     * Returns null if not in scope context.
+     * Returns { type: null, partial } for just `{`
+     * Returns { type: "file", partial } for `{@`
+     * Returns { type: "skill", partial } for `{$`
+     */
+    extractScopePrefix(text) {
+        // Match `{` anywhere, followed by optional scope prefix and content
+        const match = text.match(/\{([@$]?)([^}]*)$/);
+        if (!match)
+            return null;
+        const prefix = match[1] ?? "";
+        const partial = match[2] ?? "";
+        if (prefix === "@")
+            return { type: "file", partial };
+        if (prefix === "$")
+            return { type: "skill", partial };
+        return { type: null, partial };
+    }
+    /**
+     * Extract an alias partial: `/name` alone on its line (mirrors the
+     * dispatcher's first-line alias form). Returns null for bare `/` so
+     * the slash-command menu keeps working, and for non-first-line `/`
+     * uses like `/skill:name`.
+     */
+    extractAliasPrefix(text) {
+        const match = text.match(/^\s*\/(\w+)$/);
+        if (!match)
+            return null;
+        return match[1] ?? "";
+    }
+    // ─── Suggestion Methods ────────────────────────────────────────────────────
+    /** Get element name suggestions */
+    getElementSuggestions(partial) {
+        const elements = this.registry.list();
+        const items = elements.map((el) => ({
+            value: el.name,
+            label: el.name,
+            description: el.description,
+            _cueType: "element",
+        }));
+        const filtered = fuzzyFilter(items, partial, (item) => item.value);
+        if (filtered.length === 0)
+            return null;
+        return { items: filtered, prefix: `[${partial}` };
+    }
+    /** Get flow suggestions after element selected: `:` (add tags) or `]` (close) */
+    getElementFlowSuggestions(elementName) {
+        const element = this.registry.get(elementName);
+        if (!element)
+            return null;
+        const hasTags = Object.keys(element.tags).length > 0;
+        const items = [];
+        if (hasTags) {
+            items.push({
+                value: ":",
+                label: ": tag",
+                description: `Add a tag to ${elementName}`,
+                _cueType: "flow",
+            });
+        }
+        items.push({
+            value: "]",
+            label: "] close",
+            description: "Close the directive",
+            _cueType: "flow",
+        });
+        return { items, prefix: "" };
+    }
+    /**
+     * Get flow suggestions after a complete tag: `>` (chain) or `]` (close).
+     * Only shows `>` if there are non-conflicting tags remaining.
+     */
+    getFlowSuggestions(elementName, selectedTags) {
+        const element = this.registry.get(elementName);
+        if (!element)
+            return null;
+        // Collect override dimensions from all selected tags (including shared tags)
+        const usedDimensions = new Set();
+        for (const tag of selectedTags) {
+            for (const dim of this.getTagOverrides(element, tag)) {
+                usedDimensions.add(dim);
+            }
+        }
+        // Check if any tag can still be chained (doesn't conflict with used dimensions)
+        const hasNonConflictingTag = Object.entries(element.tags).some(([name, tag]) => {
+            // Skip already-selected tags
+            if (selectedTags.some((t) => t.toLowerCase() === name))
+                return false;
+            // Tag is valid if none of its overrides are already used
+            return !tag.overrides.some((dim) => usedDimensions.has(dim));
+        });
+        const items = [];
+        if (hasNonConflictingTag) {
+            items.push({
+                value: ">",
+                label: "> chain",
+                description: "Chain another tag",
+                _cueType: "flow",
+            });
+        }
+        items.push({
+            value: "]",
+            label: "] close",
+            description: "Close the directive",
+            _cueType: "flow",
+        });
+        return { items, prefix: "" };
+    }
+    /** Get close-only suggestion when no more tags can be chained */
+    getCloseOnlySuggestions() {
+        const items = [
+            {
+                value: "]",
+                label: "] close",
+                description: "Close the directive",
+                _cueType: "flow",
+            },
+        ];
+        return { items, prefix: "" };
+    }
+    /**
+     * Get smart tag suggestions that don't conflict with already-selected tags.
+     * Filters out tags whose `overrides` dimensions overlap with selected tags.
+     */
+    getSmartTagSuggestions(elementName, partial, selectedTags) {
+        const element = this.registry.get(elementName);
+        if (!element)
+            return null;
+        // Collect all override dimensions from selected tags (including shared tags)
+        const usedDimensions = new Set();
+        for (const tag of selectedTags) {
+            for (const dim of this.getTagOverrides(element, tag)) {
+                usedDimensions.add(dim);
+            }
+        }
+        // Filter tags: exclude those that override already-used dimensions
+        const items = [];
+        for (const [name, tag] of Object.entries(element.tags)) {
+            // Skip already-selected tags
+            if (selectedTags.some((t) => t.toLowerCase() === name))
+                continue;
+            // Check for override conflicts
+            const conflicts = tag.overrides.filter((dim) => usedDimensions.has(dim));
+            if (conflicts.length > 0) {
+            }
+            else {
+                // No conflict - clean composition
+                items.push({
+                    value: name,
+                    label: name,
+                    description: tag.overrides.length > 0
+                        ? `${tag.description} (overrides: ${tag.overrides.join(", ")})`
+                        : tag.description,
+                    _cueType: "tag",
+                });
+            }
+        }
+        const filtered = fuzzyFilter(items, partial, (item) => item.value);
+        if (filtered.length === 0)
+            return null;
+        return { items: filtered, prefix: partial };
+    }
+    /** Get all tag suggestions for a specific element (first tag, no filtering) */
+    getTagSuggestions(elementName, partial) {
+        const element = this.registry.get(elementName);
+        if (!element)
+            return null;
+        const items = Object.entries(element.tags).map(([name, tag]) => ({
+            value: name,
+            label: name,
+            description: tag.overrides.length > 0 ? `${tag.description} (overrides: ${tag.overrides.join(", ")})` : tag.description,
+            _cueType: "tag",
+        }));
+        // Add shared tags that aren't already defined locally
+        const localNames = new Set(Object.keys(element.tags));
+        const sharedDefs = this.registry.getSharedTagDefs();
+        for (const [name, def] of sharedDefs) {
+            if (localNames.has(name))
+                continue;
+            items.push({
+                value: name,
+                label: name,
+                description: def.overrides.length > 0
+                    ? `${def.description} (overrides: ${def.overrides.join(", ")})`
+                    : def.description,
+                _cueType: "tag",
+            });
+        }
+        const filtered = fuzzyFilter(items, partial, (item) => item.value);
+        if (filtered.length === 0)
+            return null;
+        return { items: filtered, prefix: partial };
+    }
+    /**
+     * Get scope starter suggestions for just `{`.
+     * Shows @ for file scope and $ for skill scope.
+     */
+    getScopePrefixSuggestions(partial) {
+        const items = [
+            {
+                value: "@",
+                label: "@ file",
+                description: "Scope to a file or directory",
+                _cueType: "scopePrefix",
+                _scopeType: "file",
+            },
+            {
+                value: "$",
+                label: "$ skill",
+                description: "Reference a skill",
+                _cueType: "scopePrefix",
+                _scopeType: "file",
+            },
+        ];
+        const filtered = fuzzyFilter(items, partial, (item) => item.value);
+        if (filtered.length === 0)
+            return null;
+        return { items: filtered, prefix: partial };
+    }
+    /**
+     * Get alias suggestions for `/partial` from cue.toml shortcuts.
+     * Returns null when nothing matches so slash commands keep working.
+     */
+    getAliasSuggestions(partial) {
+        const aliases = this.registry.loadAliases(this.projectRoot);
+        const items = Object.entries(aliases).map(([name, expansion]) => ({
+            value: `/${name}`,
+            label: `/${name}`,
+            description: `→ ${expansion.length > 60 ? `${expansion.slice(0, 60)}...` : expansion}`,
+            _cueType: "alias",
+        }));
+        const filtered = fuzzyFilter(items, partial, (item) => item.value);
+        if (filtered.length === 0)
+            return null;
+        return { items: filtered, prefix: `/${partial}` };
+    }
+    /**
+     * Get scoped suggestions after `{@`.
+     * - `{@partial`  → file/dir suggestions from disk (relative to projectRoot)
+     * - `{@path:r`   → line range suggestions for that file
+     */
+    getScopedSuggestions(partial) {
+        const colonIndex = partial.indexOf(":");
+        if (colonIndex !== -1) {
+            const items = this.getRangeSuggestions(partial.slice(0, colonIndex), partial.slice(colonIndex + 1));
+            if (items.length === 0)
+                return null;
+            return { items, prefix: partial };
+        }
+        const filtered = this.getPathSuggestions(partial);
+        const items = [];
+        // A fully typed file path offers two endings: open a line range or close the scope
+        const isCompleteFile = filtered.some((f) => f.value === partial && f._scopeType === "file");
+        if (isCompleteFile) {
+            items.push({
+                value: ":",
+                label: ": range",
+                description: "Add a line range (e.g. :3-5)",
+                _cueType: "scopeFlow",
+            }, {
+                value: "}",
+                label: "} end scope",
+                description: "Close the scope statement",
+                _cueType: "scopeFlow",
+            });
+        }
+        items.push(...filtered.filter((f) => !(f.value === partial && f._scopeType === "file")));
+        if (items.length === 0)
+            return null;
+        return { items, prefix: partial };
+    }
+    /** List files/dirs from disk under projectRoot matching the partial path. */
+    getPathSuggestions(partial) {
+        const hasTrailingSlash = partial.endsWith("/");
+        const segments = partial.split("/").filter((s) => s !== "" && s !== ".");
+        const lastSegment = hasTrailingSlash ? "" : (segments.pop() ?? "");
+        const base = join(this.projectRoot, ...segments);
+        let entries = [];
+        try {
+            if (!existsSync(base) || !statSync(base).isDirectory())
+                return [];
+            entries = readdirSync(base);
+        }
+        catch {
+            return [];
+        }
+        const MAX_ITEMS = 100;
+        const items = [];
+        for (const entry of entries) {
+            if (entry.startsWith("."))
+                continue;
+            if (items.length >= MAX_ITEMS)
+                break;
+            const full = join(base, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            const rel = segments.length > 0 ? `${segments.join("/")}/${entry}` : entry;
+            items.push({
+                value: isDir ? `${rel}/` : rel,
+                label: isDir ? `${rel}/` : rel,
+                description: isDir ? "directory" : "file",
+                _cueType: "scope",
+                _scopeType: isDir ? "dir" : "file",
+            });
+        }
+        return fuzzyFilter(items, lastSegment, (item) => item.value);
+    }
+    /**
+     * Suggest line numbers and range ends for a `{@file:` scope.
+     *
+     * With an empty range part each suggestion is one file line rendered as
+     * `<line number>  <line content>`; picking one keeps the brace open
+     * (`{@file:N`) so a range can be extended. After a start line N (typed or
+     * picked) the suggestions become the range ends (`{@file:N-M`), and
+     * picking one closes the scope (`{@file:N-M} `). Lines longer than
+     * MAX_LINE are truncated with `...`.
+     */
+    getRangeSuggestions(pathPart, rangePart) {
+        const full = join(this.projectRoot, pathPart);
+        let content = "";
+        try {
+            content = readFileSync(full, "utf-8");
+        }
+        catch {
+            return [];
+        }
+        const lines = content.split("\n");
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        const totalLines = lines.length;
+        const MAX_LINE = 100;
+        const MAX_ITEMS = 50;
+        const CHUNK = 10;
+        const truncate = (s) => (s.length > MAX_LINE ? `${s.slice(0, MAX_LINE)}...` : s);
+        const width = String(totalLines).length;
+        const lineLabel = (n) => `${String(n).padStart(width)}  ${truncate(lines[n - 1] ?? "")}`;
+        const items = [];
+        const pushLine = (n, value) => {
+            if (n < 1 || n > totalLines)
+                return;
+            items.push({ value, label: lineLabel(n), _cueType: "scope" });
+        };
+        if (rangePart === "") {
+            for (let n = 1; n <= totalLines && items.length < MAX_ITEMS; n++) {
+                pushLine(n, `${pathPart}:${n}`);
+            }
+        }
+        else if (/^(\d+)-?$/.test(rangePart)) {
+            const start = parseInt(rangePart, 10);
+            if (start < 1 || start > totalLines)
+                return [];
+            for (let end = start + 1; end <= Math.min(start + CHUNK, totalLines); end++) {
+                pushLine(end, `${pathPart}:${start}-${end}`);
+            }
+        }
+        else {
+            return [];
+        }
+        return items;
+    }
+    // ─── Apply Completion Methods ──────────────────────────────────────────────
+    applyElementCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        const bracketPos = textBeforeCursor.lastIndexOf("[");
+        const beforeBracket = textBeforeCursor.slice(0, bracketPos);
+        const insertText = `[${item.value}`;
+        const newLine = beforeBracket + insertText + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        return { lines: newLines, cursorLine, cursorCol: bracketPos + insertText.length };
+    }
+    applyTagCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        // Find the last `>` or `:` to determine where to insert
+        const colonPos = textBeforeCursor.lastIndexOf(":");
+        const beforeColon = textBeforeCursor.slice(0, colonPos + 1);
+        const afterColon = textBeforeCursor.slice(colonPos + 1);
+        const lastTagStart = afterColon.lastIndexOf(">");
+        const beforeTag = afterColon.slice(0, lastTagStart + 1);
+        // Insert the tag with a single space after the `:` or `>` separator.
+        // Everything between the separator and the cursor (a partial tag) is
+        // replaced by the picked tag. User types `>` or `]` to continue.
+        const newLine = `${beforeColon + beforeTag} ${item.value}${textAfterCursor}`;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        const newCursorCol = colonPos + 1 + beforeTag.length + 1 + item.value.length;
+        return { lines: newLines, cursorLine, cursorCol: newCursorCol };
+    }
+    applyFlowCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        if (item.value === ":") {
+            const newLine = `${textBeforeCursor}: ${textAfterCursor}`;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + 2 };
+        }
+        if (item.value === ">") {
+            const newLine = `${textBeforeCursor} > ${textAfterCursor}`;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + 3 };
+        }
+        if (item.value === "]") {
+            const newLine = `${textBeforeCursor}]${textAfterCursor}`;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + 1 };
+        }
+        // Fallback
+        const newLine = textBeforeCursor + item.value + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + item.value.length };
+    }
+    applyScopeCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        // Find the `{@` or `{#` prefix and replace the partial
+        const scopeMatch = textBeforeCursor.match(/\{([@#])([^}]*)$/);
+        if (!scopeMatch) {
+            // Fallback: just insert
+            const newLine = textBeforeCursor + item.value + textAfterCursor;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + item.value.length };
+        }
+        const typeChar = scopeMatch[1] ?? "@";
+        const scopeStart = textBeforeCursor.lastIndexOf(`{${typeChar}`);
+        const beforeScope = textBeforeCursor.slice(0, scopeStart);
+        const insertText = `{${typeChar}${item.value}`;
+        // Directories and completed ranges close the scope (`{@dir/} `,
+        // `{@file:N-M} `); a file pick leaves the brace open so the `:` range
+        // and `}` close flow items can be picked next, and a bare line number
+        // leaves it open so a range end can be picked next
+        const isDir = item._scopeType === "dir";
+        const rangePart = item.value.slice(item.value.indexOf(":") + 1);
+        const isRangeEnd = rangePart.includes("-");
+        const suffix = isDir || isRangeEnd ? "} " : "";
+        const newLine = beforeScope + insertText + suffix + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        const newCursorCol = beforeScope.length + insertText.length + suffix.length;
+        return { lines: newLines, cursorLine, cursorCol: newCursorCol };
+    }
+    /**
+     * Apply a scope ending: `:` opens a line range (brace stays open),
+     * `}` closes the scope statement.
+     */
+    applyScopeFlowCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        const scopeMatch = textBeforeCursor.match(/\{([@#])([^}]*)$/);
+        if (!scopeMatch) {
+            // Fallback: just insert
+            const newLine = textBeforeCursor + item.value + textAfterCursor;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + item.value.length };
+        }
+        const typeChar = scopeMatch[1] ?? "@";
+        const scopeStart = textBeforeCursor.lastIndexOf(`{${typeChar}`);
+        const beforeScope = textBeforeCursor.slice(0, scopeStart);
+        const partial = scopeMatch[2] ?? "";
+        const isRange = item.value === ":";
+        const insertText = isRange ? `{${typeChar}${partial}:` : `{${typeChar}${partial}}`;
+        const suffix = isRange ? "" : " ";
+        const newLine = beforeScope + insertText + suffix + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        const newCursorCol = beforeScope.length + insertText.length + suffix.length;
+        return { lines: newLines, cursorLine, cursorCol: newCursorCol };
+    }
+    applyScopePrefixCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        // Find the `{` prefix and insert the scope prefix
+        const scopeMatch = textBeforeCursor.match(/\{([@#$]?)([^}]*)$/);
+        if (!scopeMatch) {
+            // Fallback: just insert
+            const newLine = textBeforeCursor + item.value + textAfterCursor;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + item.value.length };
+        }
+        const scopeStart = textBeforeCursor.lastIndexOf("{");
+        const beforeScope = textBeforeCursor.slice(0, scopeStart);
+        const insertText = `{${item.value}`;
+        const newLine = beforeScope + insertText + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        const newCursorCol = beforeScope.length + insertText.length;
+        return { lines: newLines, cursorLine, cursorCol: newCursorCol };
+    }
+    /**
+     * Apply an alias pick: replace the `/partial` with `/name` plus a
+     * trailing space so the alias submits as its own message.
+     */
+    applyAliasCompletion(lines, cursorLine, _cursorCol, item, textBeforeCursor, textAfterCursor) {
+        const aliasMatch = textBeforeCursor.match(/^(\s*)\/(\w*)$/);
+        if (!aliasMatch) {
+            // Fallback: just insert
+            const newLine = textBeforeCursor + item.value + textAfterCursor;
+            const newLines = [...lines];
+            newLines[cursorLine] = newLine;
+            return { lines: newLines, cursorLine, cursorCol: textBeforeCursor.length + item.value.length };
+        }
+        const beforeAlias = aliasMatch[1] ?? "";
+        const insertText = `${item.value} `;
+        const newLine = beforeAlias + insertText + textAfterCursor;
+        const newLines = [...lines];
+        newLines[cursorLine] = newLine;
+        return { lines: newLines, cursorLine, cursorCol: beforeAlias.length + insertText.length };
+    }
+}
+//# sourceMappingURL=autocomplete.js.map