@dev-sergeev/datalab-kit 0.1.2 → 0.1.3

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

@@ -0,0 +1,105 @@
+const TRAILING_PUNCTUATION = new Set([".", ",", ";", ":", "!", "?", ")", "}", "]"]);
+
+export type ParsedMention = {
+    readonly name: string;
+    readonly suffix: string;
+};
+
+export type MentionPrefix = {
+    readonly prefix: string;
+    readonly query: string;
+};
+
+export function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function autocompleteTriggerCharacter(trigger: string): string {
+    return Array.from(trigger)[0] ?? trigger;
+}
+
+export function mentionPattern(trigger: string): RegExp {
+    return new RegExp(`(^|\\s)${escapeRegExp(trigger)}(?:"((?:\\\\.|[^"\\\\])*)"|([^\\s]+))`, "g");
+}
+
+function unescapeQuotedName(value: string): string {
+    return value.replace(/\\(["\\])/g, "$1");
+}
+
+function escapeQuotedName(value: string): string {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function isBareName(name: string, trigger: string): boolean {
+    if (name.length === 0 || name.includes(trigger)) return false;
+    return /^[^\s"'/]+$/.test(name);
+}
+
+export function formatMention(name: string, trigger: string): string {
+    if (isBareName(name, trigger)) return `${trigger}${name}`;
+    return `${trigger}"${escapeQuotedName(name)}"`;
+}
+
+function parseUnquotedName(
+    rawName: string,
+    knownNames: ReadonlySet<string>,
+): ParsedMention | undefined {
+    if (knownNames.has(rawName)) return { name: rawName, suffix: "" };
+
+    let end = rawName.length;
+    while (end > 0) {
+        const last = rawName.at(end - 1);
+        if (last === undefined || !TRAILING_PUNCTUATION.has(last)) break;
+
+        end -= 1;
+
+        const candidate = rawName.slice(0, end);
+        if (knownNames.has(candidate)) {
+            return { name: candidate, suffix: rawName.slice(end) };
+        }
+    }
+
+    return undefined;
+}
+
+export function parseMentionName(
+    quotedName: string | undefined,
+    unquotedName: string | undefined,
+    knownNames: ReadonlySet<string>,
+): ParsedMention | undefined {
+    if (quotedName !== undefined) {
+        const name = unescapeQuotedName(quotedName);
+        if (!knownNames.has(name)) return undefined;
+
+        return { name, suffix: "" };
+    }
+
+    if (unquotedName === undefined) return undefined;
+    return parseUnquotedName(unquotedName, knownNames);
+}
+
+export function extractMentionPrefix(
+    textBeforeCursor: string,
+    trigger: string,
+): MentionPrefix | undefined {
+    const escapedTrigger = escapeRegExp(trigger);
+    const quotedMatch = new RegExp(`(?:^|\\s)(${escapedTrigger}"([^"]*)$)`).exec(textBeforeCursor);
+    const quotedPrefix = quotedMatch?.at(1);
+    const quotedQuery = quotedMatch?.at(2);
+    if (quotedPrefix !== undefined && quotedQuery !== undefined) {
+        return { prefix: quotedPrefix, query: quotedQuery };
+    }
+
+    const match = new RegExp(`(?:^|\\s)(${escapedTrigger}([^\\s"]*)$)`).exec(textBeforeCursor);
+    const prefix = match?.at(1);
+    const query = match?.at(2);
+    if (prefix !== undefined && query !== undefined) {
+        return { prefix, query };
+    }
+
+    return undefined;
+}
+
+export function isMentionContext(text: string, trigger: string): boolean {
+    return extractMentionPrefix(text, trigger) !== undefined;
+}

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

@@ -0,0 +1,89 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { InitialSuggestions } from "./initial-suggestions.ts";
+import type { SourceControllerOptions } from "./source-controller.ts";
+import type { Candidate, Provider } from "./source-contract.ts";
+import { sharedHub, type MentionHub } from "./mention-hub.ts";
+
+export type MentionProviderContext = Pick<ExtensionContext, "cwd" | "isProjectTrusted">;
+export type MentionContext = MentionProviderContext;
+export type MentionExtensionApi = Pick<ExtensionAPI, "on">;
+
+type ControllerConfiguration<T> = T extends SourceControllerOptions
+    ? Omit<T, "sourceId" | "cwd" | "trusted" | "onError">
+    : never;
+
+export type MentionConfiguration = ControllerConfiguration<SourceControllerOptions> & {
+    readonly trigger: string;
+    readonly separator?: string;
+    readonly completionSuffix?: string;
+    readonly initialSuggestions?: InitialSuggestions;
+    readonly expansionPolicy?: "selected-only" | "selected-or-resolved";
+    readonly replacementTemplate?: string;
+};
+
+export type MentionRegistration = {
+    readonly id: string;
+    readonly configuration: (ctx: MentionProviderContext) => MentionConfiguration;
+    readonly provider: (ctx: MentionProviderContext) => Provider;
+
+    readonly replacement?: (
+        path: readonly Candidate[],
+        ctx: MentionProviderContext,
+        options: { readonly signal?: AbortSignal },
+    ) => string | Promise<string>;
+};
+
+/** Composition seam used by settings to construct the same registrations as TypeScript providers. */
+export function registerMentionSources(
+    pi: Pick<ExtensionAPI, "on">,
+    load: (ctx: MentionProviderContext) => readonly MentionRegistration[],
+): void {
+    let hub: MentionHub | undefined;
+    let owned: symbol[] = [];
+
+    pi.on("session_start", async (_event, ctx) => {
+        if (hub !== undefined) for (const handle of owned) await hub.remove(handle);
+
+        owned = [];
+
+        const registrations = load(ctx);
+
+        hub = undefined;
+
+        if (registrations.length === 0) return;
+
+        hub = sharedHub(ctx);
+        for (const registration of registrations) owned.push(hub.add(registration));
+    });
+
+    pi.on("input", (event) => {
+        hub?.input(event.text);
+        return { action: "continue" };
+    });
+
+    pi.on("context", async (event, ctx) => {
+        if (hub === undefined) return undefined;
+
+        const messages = await hub.context(event.messages, ctx.signal);
+        if (messages !== event.messages) return { messages };
+        return undefined;
+    });
+
+    pi.on("session_shutdown", async () => {
+        const previous = hub;
+        hub = undefined;
+
+        const handles = owned;
+        owned = [];
+
+        if (previous !== undefined) for (const handle of handles) await previous.remove(handle);
+    });
+}
+
+/** Register a domain provider; the shared hub owns editor, cache and expansion lifetimes. */
+export function registerMention(
+    pi: Pick<ExtensionAPI, "on">,
+    registration: MentionRegistration,
+): void {
+    registerMentionSources(pi, () => [registration]);
+}

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

@@ -0,0 +1,53 @@
+import { mentionPattern, parseMentionName } from "./mention-syntax.ts";
+
+export type MentionColorContext = {
+    readonly ui: {
+        readonly theme: {
+            fg(role: string, text: string): string;
+        };
+    };
+};
+
+export function colorMentions(
+    line: string,
+    ctx: MentionColorContext,
+    trigger: string,
+    knownNames: ReadonlySet<string>,
+): string {
+    if (!line.includes(trigger) || knownNames.size === 0) return line;
+
+    return line.replace(
+        mentionPattern(trigger),
+        (
+            match: string,
+            leading: string,
+            quotedName: string | undefined,
+            unquotedName: string | undefined,
+        ) => {
+            const parsed = parseMentionName(quotedName, unquotedName, knownNames);
+            if (parsed === undefined) return match;
+
+            const mentionEnd = match.length - parsed.suffix.length;
+            const mentionText = match.slice(leading.length, mentionEnd);
+            return `${leading}${ctx.ui.theme.fg("accent", mentionText)}${parsed.suffix}`;
+        },
+    );
+}
+
+const ANSI_ESCAPE_PATTERN = new RegExp(
+    `${String.fromCharCode(27)}(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])`,
+    "g",
+);
+
+function stripAnsi(value: string): string {
+    return value.replace(ANSI_ESCAPE_PATTERN, "");
+}
+
+export function autocompleteStartIndex(renderedLines: string[]): number {
+    for (let index = renderedLines.length - 1; index >= 0; index -= 1) {
+        const line = renderedLines.at(index);
+        if (line !== undefined && stripAnsi(line).startsWith("─")) return index + 1;
+    }
+
+    return renderedLines.length;
+}

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

@@ -0,0 +1,21 @@
+export function includeSelectedItems<T>(
+    currentItems: readonly T[],
+    selectedItems: ReadonlyMap<string, T>,
+    nameOf: (item: T) => string,
+): T[] {
+    const items = [...currentItems];
+    const currentNames = new Set(items.map(nameOf));
+    for (const selectedItem of selectedItems.values()) {
+        if (!currentNames.has(nameOf(selectedItem))) items.push(selectedItem);
+    }
+
+    return items;
+}
+
+export function selectedOrCurrentItem<T>(
+    currentItem: T,
+    selectedItems: ReadonlyMap<string, T>,
+    nameOf: (item: T) => string,
+): T {
+    return selectedItems.get(nameOf(currentItem)) ?? currentItem;
+}

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

@@ -0,0 +1,135 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Type, type Static } from "typebox";
+import { Value } from "typebox/value";
+
+import type {
+    Selection,
+    SelectionHistory,
+    SelectionHistoryOptions,
+} from "./initial-suggestions.ts";
+
+const HISTORY_VERSION = 1;
+const MAX_HISTORY_ENTRIES = 1_000;
+
+const selectionSchema = Type.Object(
+    {
+        count: Type.Integer({ minimum: 1 }),
+        lastSelectedAt: Type.Integer({ minimum: 0 }),
+    },
+    { additionalProperties: false },
+);
+
+const selectionHistorySchema = Type.Object(
+    {
+        version: Type.Literal(HISTORY_VERSION),
+        selections: Type.Record(Type.String({ minLength: 1 }), selectionSchema),
+    },
+    { additionalProperties: false },
+);
+
+type SelectionHistoryFile = Static<typeof selectionHistorySchema>;
+
+function isNodeErrorWithCode(cause: unknown): cause is Error & { readonly code: string } {
+    return cause instanceof Error && "code" in cause && typeof cause.code === "string";
+}
+
+function parseHistory(text: string): Map<string, Selection> {
+    const parsed: unknown = JSON.parse(text);
+    if (!Value.Check(selectionHistorySchema, parsed)) {
+        throw new Error("selection history has an invalid structure");
+    }
+
+    const history = Value.Parse(selectionHistorySchema, parsed);
+    return new Map(Object.entries(history.selections));
+}
+
+function historyFile(selections: ReadonlyMap<string, Selection>): SelectionHistoryFile {
+    const recentSelections = [...selections.entries()]
+        .sort((left, right) => right[1].lastSelectedAt - left[1].lastSelectedAt)
+        .slice(0, MAX_HISTORY_ENTRIES);
+
+    return {
+        version: HISTORY_VERSION,
+        selections: Object.fromEntries(recentSelections),
+    };
+}
+
+async function atomicWrite(filePath: string, content: string): Promise<void> {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+    const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+
+    try {
+        await fs.writeFile(temporaryPath, content, { encoding: "utf8", flag: "wx" });
+        await fs.rename(temporaryPath, filePath);
+    } catch (cause) {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+
+        throw cause;
+    }
+}
+
+export function createSelectionHistory(options: SelectionHistoryOptions): SelectionHistory {
+    const filePath = options.filePath ?? path.join(getAgentDir(), "state", options.stateFileName);
+    const now = options.now ?? Date.now;
+    let selections = new Map<string, Selection>();
+    let loadTask: Promise<void> | undefined;
+    let pendingWrites = Promise.resolve();
+    let errorReported = false;
+
+    const reportError = (): void => {
+        if (errorReported) return;
+
+        errorReported = true;
+        options.onError?.(options.errorMessage);
+    };
+
+    const ensureLoaded = async (): Promise<void> => {
+        if (loadTask !== undefined) return loadTask;
+
+        loadTask = fs
+            .readFile(filePath, "utf8")
+            .then((text) => {
+                selections = parseHistory(text);
+            })
+            .catch((cause: unknown) => {
+                if (!isNodeErrorWithCode(cause) || cause.code !== "ENOENT") reportError();
+                selections = new Map();
+            });
+
+        return loadTask;
+    };
+
+    const persist = async (): Promise<void> => {
+        const content = `${JSON.stringify(historyFile(selections), null, 2)}\n`;
+        await atomicWrite(filePath, content);
+    };
+
+    return {
+        async load() {
+            await ensureLoaded();
+            return new Map(selections);
+        },
+        recordSelection(name) {
+            pendingWrites = pendingWrites
+                .then(async () => {
+                    await ensureLoaded();
+
+                    const previous = selections.get(name);
+                    selections.set(name, {
+                        count: (previous?.count ?? 0) + 1,
+                        lastSelectedAt: now(),
+                    });
+                    await persist();
+                })
+                .catch(() => {
+                    reportError();
+                });
+        },
+        async flush() {
+            await pendingWrites;
+        },
+    };
+}