@dev-sergeev/datalab-kit 0.1.2 → 0.1.4

package/node_modules/@zigai/pi-mention-anything/src/editor.ts

@@ -0,0 +1,180 @@
+import { CustomEditor, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { registerEditorEnhancer, type EditorEnhancerHandle } from "@zigai/pi-extension-internals";
+
+import { autocompleteStartIndex } from "./rendering.ts";
+
+type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
+type EditorLike = ReturnType<EditorFactory>;
+
+type AutocompleteVisibility = {
+    isShowingAutocomplete(): boolean;
+};
+
+type AutocompleteTrigger = {
+    tryTriggerAutocomplete(): void;
+};
+
+type CursorAccess = {
+    getCursor(): { readonly line: number; readonly col: number };
+    getLines(): string[];
+};
+
+type SubmitAccess = {
+    onSubmit?: (text: string) => void;
+};
+
+export type MentionContinuation = {
+    request(): void;
+    consume(): boolean;
+};
+
+export type MentionEditorContext = Pick<ExtensionContext, "hasUI"> & {
+    readonly ui: Pick<ExtensionContext["ui"], "getEditorComponent" | "setEditorComponent">;
+};
+
+export type MentionEditorOptions = {
+    readonly key: symbol;
+    readonly isMentionContext: (line: string) => boolean;
+    readonly colorLine: (line: string) => string;
+    readonly continuation?: MentionContinuation;
+    readonly onTextChange?: (text: string) => void;
+    readonly onSubmitText?: (text: string) => void;
+};
+
+function hasAutocompleteVisibility(
+    editor: EditorLike,
+): editor is EditorLike & AutocompleteVisibility {
+    return "isShowingAutocomplete" in editor && typeof editor.isShowingAutocomplete === "function";
+}
+
+function hasAutocompleteTrigger(editor: EditorLike): editor is EditorLike & AutocompleteTrigger {
+    return (
+        "tryTriggerAutocomplete" in editor && typeof editor.tryTriggerAutocomplete === "function"
+    );
+}
+
+function hasCursorAccess(editor: EditorLike): editor is EditorLike & CursorAccess {
+    return (
+        "getCursor" in editor &&
+        typeof editor.getCursor === "function" &&
+        "getLines" in editor &&
+        typeof editor.getLines === "function"
+    );
+}
+
+function hasSubmitAccess(editor: EditorLike): editor is EditorLike & SubmitAccess {
+    return "onSubmit" in editor;
+}
+
+function isShowingAutocomplete(editor: EditorLike): boolean {
+    return hasAutocompleteVisibility(editor) && editor.isShowingAutocomplete();
+}
+
+function tryTriggerAutocomplete(editor: EditorLike): void {
+    if (hasAutocompleteTrigger(editor)) editor.tryTriggerAutocomplete();
+}
+
+export function createMentionContinuation(): MentionContinuation {
+    let requested = false;
+
+    return {
+        request() {
+            requested = true;
+        },
+        consume() {
+            const result = requested;
+            requested = false;
+            return result;
+        },
+    };
+}
+
+function handleInputWithSubmitCapture(
+    editor: EditorLike,
+    originalHandleInput: (data: string) => void,
+    data: string,
+    onSubmitText: ((text: string) => void) | undefined,
+): void {
+    if (onSubmitText === undefined || !hasSubmitAccess(editor)) {
+        originalHandleInput(data);
+        return;
+    }
+
+    const originalOnSubmit = editor.onSubmit;
+    const capturedOnSubmit = (text: string): void => {
+        onSubmitText(text);
+        originalOnSubmit?.(text);
+    };
+
+    editor.onSubmit = capturedOnSubmit;
+
+    try {
+        originalHandleInput(data);
+    } finally {
+        if (editor.onSubmit === capturedOnSubmit) editor.onSubmit = originalOnSubmit;
+    }
+}
+
+function enhanceEditor(editor: EditorLike, options: MentionEditorOptions): EditorLike {
+    const originalHandleInput = editor.handleInput.bind(editor);
+
+    editor.handleInput = (data: string) => {
+        const textBeforeInput = editor.getText();
+        const autocompleteWasShowing = isShowingAutocomplete(editor);
+
+        handleInputWithSubmitCapture(editor, originalHandleInput, data, options.onSubmitText);
+
+        const text = editor.getText();
+        const textChanged = text !== textBeforeInput;
+        if (textChanged) options.onTextChange?.(text);
+
+        if (options.continuation?.consume() === true) {
+            if (!isShowingAutocomplete(editor)) tryTriggerAutocomplete(editor);
+            return;
+        }
+
+        if (autocompleteWasShowing || isShowingAutocomplete(editor)) return;
+
+        if (!textChanged) {
+            const inputCharacters = Array.from(data);
+            if (inputCharacters.length !== 1 || /[\p{C}\s]/u.test(inputCharacters[0] ?? "")) return;
+        }
+
+        let currentLine = text.split("\n").at(-1) ?? "";
+        if (hasCursorAccess(editor)) {
+            const cursor = editor.getCursor();
+            currentLine = editor.getLines()[cursor.line] ?? "";
+            currentLine = currentLine.slice(0, cursor.col);
+        }
+
+        if (!options.isMentionContext(currentLine)) return;
+
+        tryTriggerAutocomplete(editor);
+    };
+
+    const originalRender = editor.render.bind(editor);
+
+    editor.render = (width: number): string[] => {
+        const renderedLines = originalRender(width);
+        let colorThrough = renderedLines.length;
+        if (isShowingAutocomplete(editor)) colorThrough = autocompleteStartIndex(renderedLines);
+        return renderedLines.map((line, index) => {
+            if (index >= colorThrough) return line;
+            return options.colorLine(line);
+        });
+    };
+
+    return editor;
+}
+
+export function applyMentionEditor(
+    ctx: MentionEditorContext,
+    options: MentionEditorOptions,
+): EditorEnhancerHandle<Parameters<EditorFactory>, EditorLike> {
+    return registerEditorEnhancer(
+        ctx,
+        options.key,
+        (tui, theme, keybindings) => new CustomEditor(tui, theme, keybindings),
+        (editor) => enhanceEditor(editor, options),
+    );
+}

package/node_modules/@zigai/pi-mention-anything/src/expand-mentions.ts

@@ -0,0 +1,162 @@
+import type { ContextEvent } from "@earendil-works/pi-coding-agent";
+
+import { mentionPattern, parseMentionName } from "./mention-syntax.ts";
+
+export type MentionExpansionOptions<T> = {
+    readonly trigger: string;
+    readonly items: readonly T[];
+    readonly nameOf: (item: T) => string;
+    readonly replacementOf: (item: T) => string;
+};
+
+function itemMap<T>(items: readonly T[], nameOf: (item: T) => string): Map<string, T> {
+    const byName = new Map<string, T>();
+    for (const item of items) {
+        const name = nameOf(item);
+        if (!byName.has(name)) byName.set(name, item);
+    }
+
+    return byName;
+}
+
+export function expandMentions<T>(text: string, options: MentionExpansionOptions<T>): string {
+    const byName = itemMap(options.items, options.nameOf);
+    const knownNames = new Set(byName.keys());
+
+    return text.replace(
+        mentionPattern(options.trigger),
+        (
+            match: string,
+            leading: string,
+            quotedName: string | undefined,
+            unquotedName: string | undefined,
+        ) => {
+            const parsed = parseMentionName(quotedName, unquotedName, knownNames);
+            if (parsed === undefined) return match;
+
+            const item = byName.get(parsed.name);
+            if (item === undefined) return match;
+
+            return `${leading}${options.replacementOf(item)}${parsed.suffix}`;
+        },
+    );
+}
+
+type ContextMessage = ContextEvent["messages"][number];
+type UserContextMessage = Extract<ContextMessage, { role: "user" }>;
+type UserContentBlock = Exclude<UserContextMessage["content"], string>[number];
+type UserTextContentBlock = Extract<UserContentBlock, { type: "text" }>;
+
+function isUserTextContentBlock(block: UserContentBlock): block is UserTextContentBlock {
+    return block.type === "text";
+}
+
+type ParsedUserContent =
+    | { readonly kind: "text"; readonly text: string }
+    | { readonly kind: "blocks"; readonly blocks: UserContentBlock[] };
+
+function parseUserContent(content: UserContextMessage["content"]): ParsedUserContent {
+    if (Array.isArray(content)) return { kind: "blocks", blocks: content };
+
+    return { kind: "text", text: content };
+}
+
+function firstRecentMessageIndex(messages: ContextEvent["messages"]): number {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages.at(index);
+        if (message?.role === "assistant" && message.stopReason !== "toolUse") return index + 1;
+    }
+
+    return 0;
+}
+
+function recentUserMessageIndexesWithTrigger(
+    messages: ContextEvent["messages"],
+    trigger: string,
+): number[] {
+    const indexes: number[] = [];
+    for (let index = firstRecentMessageIndex(messages); index < messages.length; index += 1) {
+        const message = messages.at(index);
+        if (message?.role !== "user") continue;
+
+        const content = parseUserContent(message.content);
+        if (content.kind === "text") {
+            if (content.text.includes(trigger)) indexes.push(index);
+            continue;
+        }
+
+        if (
+            content.blocks.some(
+                (block) => isUserTextContentBlock(block) && block.text.includes(trigger),
+            )
+        ) {
+            indexes.push(index);
+        }
+    }
+
+    return indexes;
+}
+
+export function contextContainsMentionTrigger(
+    messages: ContextEvent["messages"],
+    trigger: string,
+): boolean {
+    return recentUserMessageIndexesWithTrigger(messages, trigger).length > 0;
+}
+
+function expandMentionsInUserMessage<T>(
+    message: UserContextMessage,
+    options: MentionExpansionOptions<T>,
+): UserContextMessage {
+    const parsedContent = parseUserContent(message.content);
+    if (parsedContent.kind === "text") {
+        const expanded = expandMentions(parsedContent.text, options);
+        if (expanded === parsedContent.text) return message;
+
+        return { ...message, content: expanded };
+    }
+
+    let changed = false;
+    const content: UserContentBlock[] = [];
+    for (const block of parsedContent.blocks) {
+        if (!isUserTextContentBlock(block) || !block.text.includes(options.trigger)) {
+            content.push(block);
+            continue;
+        }
+
+        const expanded = expandMentions(block.text, options);
+        if (expanded === block.text) {
+            content.push(block);
+            continue;
+        }
+
+        changed = true;
+        content.push({ ...block, text: expanded });
+    }
+
+    if (!changed) return message;
+
+    return { ...message, content };
+}
+
+export function expandMentionsInMessages<T>(
+    messages: ContextEvent["messages"],
+    options: MentionExpansionOptions<T>,
+): ContextEvent["messages"] {
+    const indexes = recentUserMessageIndexesWithTrigger(messages, options.trigger);
+    if (indexes.length === 0) return messages;
+
+    let expandedMessages: ContextEvent["messages"] | undefined;
+    for (const index of indexes) {
+        const message = messages.at(index);
+        if (message?.role !== "user") continue;
+
+        const expanded = expandMentionsInUserMessage(message, options);
+        if (expanded === message) continue;
+
+        expandedMessages ??= [...messages];
+        expandedMessages[index] = expanded;
+    }
+
+    return expandedMessages ?? messages;
+}

package/node_modules/@zigai/pi-mention-anything/src/index.ts

@@ -0,0 +1,54 @@
+import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+
+import { createConfiguredProvider } from "./configured-source.ts";
+import { registerMentionSources, type MentionConfiguration } from "./register-mention.ts";
+import { loadMentionAnythingSettings } from "./settings.ts";
+
+export default function (pi: Pick<ExtensionAPI, "on">): void {
+    registerMentionSources(pi, (ctx) =>
+        loadMentionAnythingSettings(ctx).mentions.map((mention) => ({
+            id: mention.id,
+            configuration: (): MentionConfiguration => {
+                const base = {
+                    trigger: mention.trigger,
+                    separator: mention.separator,
+                    completionSuffix: mention.completionSuffix,
+                    initialSuggestions: mention.initialSuggestions,
+                    expansionPolicy: mention.expansionPolicy,
+                    replacementTemplate: mention.replacementTemplate,
+                };
+                if (mention.source.type === "static") return { ...base, cache: true };
+
+                const source = mention.source;
+                const configurationKey = createHash("sha256")
+                    .update(JSON.stringify(mention))
+                    .digest("hex");
+                const configuration = {
+                    ...base,
+                    cache: source.cache,
+                    debounceMs: source.debounceMs,
+                    cacheTtlMs: source.cacheTtlMs,
+                    refreshOnStartup: source.refreshOnStartup,
+                    refreshIntervalMs: source.refreshIntervalMs,
+                    watchFiles: source.watchFiles,
+                    configurationKey,
+                };
+                if (source.persistentCache === true)
+                    return {
+                        ...configuration,
+                        persistentCachePath: join(
+                            getAgentDir(),
+                            "cache",
+                            "pi-mention-anything",
+                            `${mention.id}.json`,
+                        ),
+                    };
+
+                return configuration;
+            },
+            provider: () => createConfiguredProvider(mention, ctx.cwd),
+        })),
+    );
+}

package/node_modules/@zigai/pi-mention-anything/src/initial-suggestions.ts

@@ -0,0 +1,190 @@
+const FRECENCY_HALF_LIFE_DAYS = 30;
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1_000;
+
+export type InitialSuggestionStrategy =
+    | "frecency"
+    | "recent"
+    | "frequent"
+    | "alphabetical"
+    | "sourceOrder";
+
+export type InitialSuggestions = {
+    readonly strategy: InitialSuggestionStrategy;
+    readonly pinned: readonly string[];
+};
+
+export type Selection = {
+    readonly count: number;
+    readonly lastSelectedAt: number;
+};
+
+export type SelectionHistory = {
+    load(): Promise<ReadonlyMap<string, Selection>>;
+    recordSelection(name: string): void;
+    flush(): Promise<void>;
+};
+
+export type SelectionHistoryOptions = {
+    readonly stateFileName: string;
+    readonly errorMessage: string;
+    readonly filePath?: string;
+    readonly now?: () => number;
+    readonly onError?: (message: string) => void;
+};
+
+function compareNames(left: string, right: string): number {
+    return left.localeCompare(right, undefined, { sensitivity: "base" });
+}
+
+function historyRankingNeeded(strategy: InitialSuggestionStrategy): boolean {
+    return strategy === "frecency" || strategy === "recent" || strategy === "frequent";
+}
+
+function frecencyScore(selection: Selection | undefined, now: number): number {
+    if (selection === undefined) return 0;
+
+    const ageDays = Math.max(0, now - selection.lastSelectedAt) / MILLISECONDS_PER_DAY;
+    return selection.count / (1 + ageDays / FRECENCY_HALF_LIFE_DAYS);
+}
+
+export function rankInitialSuggestions<T>(
+    items: readonly T[],
+    nameOf: (item: T) => string,
+    settings: InitialSuggestions,
+    selections: ReadonlyMap<string, Selection>,
+    now = Date.now(),
+    priorityOf?: (item: T) => number,
+): T[] {
+    const pinnedIndexes = new Map(settings.pinned.map((name, index) => [name, index]));
+    const ranked = items.map((item, sourceIndex) => {
+        let priority = 0;
+        if (priorityOf !== undefined) priority = priorityOf(item);
+
+        return { item, name: nameOf(item), priority, sourceIndex };
+    });
+
+    ranked.sort((left, right) => {
+        const leftPin = pinnedIndexes.get(left.name);
+        const rightPin = pinnedIndexes.get(right.name);
+        if (leftPin !== undefined || rightPin !== undefined) {
+            if (leftPin === undefined) return 1;
+            if (rightPin === undefined) return -1;
+            return leftPin - rightPin;
+        }
+
+        const priorityComparison = left.priority - right.priority;
+        if (priorityComparison !== 0) return priorityComparison;
+
+        const leftSelection = selections.get(left.name);
+        const rightSelection = selections.get(right.name);
+        switch (settings.strategy) {
+            case "alphabetical": {
+                const comparison = compareNames(left.name, right.name);
+                if (comparison !== 0) return comparison;
+                break;
+            }
+            case "recent": {
+                const comparison =
+                    (rightSelection?.lastSelectedAt ?? -1) - (leftSelection?.lastSelectedAt ?? -1);
+                if (comparison !== 0) return comparison;
+                break;
+            }
+            case "frequent": {
+                const comparison = (rightSelection?.count ?? 0) - (leftSelection?.count ?? 0);
+                if (comparison !== 0) return comparison;
+
+                const recencyComparison =
+                    (rightSelection?.lastSelectedAt ?? -1) - (leftSelection?.lastSelectedAt ?? -1);
+                if (recencyComparison !== 0) return recencyComparison;
+                break;
+            }
+            case "frecency": {
+                const comparison =
+                    frecencyScore(rightSelection, now) - frecencyScore(leftSelection, now);
+                if (comparison !== 0) return comparison;
+
+                const recencyComparison =
+                    (rightSelection?.lastSelectedAt ?? -1) - (leftSelection?.lastSelectedAt ?? -1);
+                if (recencyComparison !== 0) return recencyComparison;
+                break;
+            }
+            case "sourceOrder":
+                break;
+        }
+
+        return left.sourceIndex - right.sourceIndex;
+    });
+
+    return ranked.map(({ item }) => item);
+}
+
+export async function rankWithSelectionHistory<T>(
+    items: readonly T[],
+    nameOf: (item: T) => string,
+    settings: InitialSuggestions,
+    history: SelectionHistory | undefined,
+    priorityOf?: (item: T) => number,
+): Promise<T[]> {
+    let selections: ReadonlyMap<string, Selection> = new Map();
+    if (history !== undefined && historyRankingNeeded(settings.strategy)) {
+        selections = await history.load();
+    }
+
+    return rankInitialSuggestions(items, nameOf, settings, selections, Date.now(), priorityOf);
+}
+
+export function createLazySelectionHistory(options: SelectionHistoryOptions): SelectionHistory {
+    let historyTask: Promise<SelectionHistory> | undefined;
+    let pendingRecords = Promise.resolve();
+    let errorReported = false;
+
+    const reportError = (): void => {
+        if (errorReported) return;
+
+        errorReported = true;
+        options.onError?.(options.errorMessage);
+    };
+
+    const unavailableHistory: SelectionHistory = {
+        async load() {
+            return new Map();
+        },
+        recordSelection() {
+            return;
+        },
+        async flush() {
+            return;
+        },
+    };
+    const getHistory = async (): Promise<SelectionHistory> => {
+        if (historyTask !== undefined) return historyTask;
+
+        historyTask = import("./selection-history.ts")
+            .then(({ createSelectionHistory }) => createSelectionHistory(options))
+            .catch(() => {
+                reportError();
+                return unavailableHistory;
+            });
+
+        return historyTask;
+    };
+
+    return {
+        async load() {
+            return (await getHistory()).load();
+        },
+        recordSelection(name) {
+            pendingRecords = pendingRecords.then(async () => {
+                const history = await getHistory();
+                history.recordSelection(name);
+            });
+        },
+        async flush() {
+            await pendingRecords;
+
+            if (historyTask === undefined) return;
+
+            await (await historyTask).flush();
+        },
+    };
+}

package/node_modules/@zigai/pi-mention-anything/src/list-provider.ts

@@ -0,0 +1,71 @@
+import type { Candidate, DiscoveryRequest, Provider } from "./source-contract.ts";
+
+/** Adapt a bounded enumerable source. Large remote sources should implement exact resolution directly. */
+export function createListProvider(
+    loadItems: (request: DiscoveryRequest) => Promise<readonly Candidate[]>,
+): Provider {
+    return {
+        filtering: "local",
+        async discover(request) {
+            request.signal.throwIfAborted();
+            const items = await loadItems(request);
+            if (items.length > 10000)
+                throw new Error(
+                    "Enumerable mention sources are limited to 10000 items per parent.",
+                );
+
+            request.signal.throwIfAborted();
+            return { items: items.slice(0, request.limit) };
+        },
+        async resolve(request) {
+            request.signal.throwIfAborted();
+            const path: Candidate[] = [];
+            for (const [index, segment] of request.segments.entries()) {
+                const items = await loadItems({
+                    sourceId: request.sourceId,
+                    cwd: request.cwd,
+                    trusted: request.trusted,
+                    query: "",
+                    path,
+                    limit: 10000,
+                    signal: request.signal,
+                });
+
+                request.signal.throwIfAborted();
+
+                if (items.length > 10000)
+                    throw new Error(
+                        "Enumerable mention sources are limited to 10000 items per parent.",
+                    );
+
+                const matches = items.filter((item) => item.segment === segment);
+                if (matches.length === 0) {
+                    return { status: "unresolved", reason: "missing" };
+                }
+
+                if (matches.length > 1) {
+                    return { status: "unresolved", reason: "ambiguous" };
+                }
+
+                const candidate = matches.at(0);
+                if (candidate === undefined) {
+                    return { status: "unresolved", reason: "missing" };
+                }
+
+                const finalSegment = index === request.segments.length - 1;
+                if (!finalSegment && !candidate.navigable) {
+                    return { status: "unresolved", reason: "not-navigable" };
+                }
+
+                path.push(candidate);
+            }
+
+            if (path.length === 0) return { status: "unresolved", reason: "empty" };
+
+            const target = path.at(-1);
+            if (target?.replacement === undefined) return { status: "resolved", path };
+
+            return { status: "resolved", path, replacement: target.replacement };
+        },
+    };
+}