@dev-sergeev/datalab-kit 0.1.2 → 0.1.3

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

@@ -0,0 +1,345 @@
+const TRAILING_PUNCTUATION = new Set([".", ",", ";", ":", "!", "?", ")", "}", "]"]);
+
+export type ChainDefinition = {
+    readonly id: string;
+    readonly trigger: string;
+    readonly separator?: string;
+};
+
+export type ParsedChain = {
+    readonly sourceId: string;
+    readonly trigger: string;
+    readonly start: number;
+    readonly end: number;
+    readonly segments: readonly string[];
+    readonly complete: boolean;
+};
+
+export type ChainSegmentSpan = {
+    readonly index: number;
+    readonly start: number;
+    readonly end: number;
+    readonly contentStart: number;
+    readonly contentEnd: number;
+    readonly value: string;
+    readonly quoted: boolean;
+    readonly complete: boolean;
+};
+
+export type ActiveChainSegment = {
+    readonly chain: ParsedChain;
+    readonly separator: string;
+    readonly index: number;
+    readonly query: string;
+    readonly path: readonly string[];
+    readonly start: number;
+    readonly end: number;
+    readonly ownedEnd: number;
+    readonly span: ChainSegmentSpan;
+};
+
+type ParsedChainWithSpans = {
+    readonly chain: ParsedChain;
+    readonly separator: string;
+    readonly spans: readonly ChainSegmentSpan[];
+};
+
+function separatorOf(definition: ChainDefinition): string {
+    return definition.separator ?? ":";
+}
+
+function assertDefinitions(definitions: readonly ChainDefinition[]): void {
+    const triggers = new Set<string>();
+    for (const definition of definitions) {
+        if (definition.id.length === 0) throw new Error("Mention source id must not be empty.");
+        if (definition.trigger.length === 0) throw new Error("Mention trigger must not be empty.");
+
+        if (separatorOf(definition).length === 0) {
+            throw new Error(`Mention separator for ${definition.id} must not be empty.`);
+        }
+
+        if (triggers.has(definition.trigger)) {
+            throw new Error(`Duplicate mention trigger: ${definition.trigger}`);
+        }
+
+        triggers.add(definition.trigger);
+    }
+}
+
+export function isTriggerBoundary(text: string, start: number): boolean {
+    if (start <= 0) return true;
+
+    const previous = text.at(start - 1);
+    if (previous === undefined) return true;
+    return !/[\p{L}\p{N}_\\]/u.test(previous);
+}
+
+function decodeEscapes(value: string): string {
+    let decoded = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value.at(index);
+        if (character === "\\" && index + 1 < value.length) {
+            decoded += value[index + 1];
+            index += 1;
+        } else if (character !== undefined) {
+            decoded += character;
+        }
+    }
+
+    return decoded;
+}
+
+function parseChainAt(
+    text: string,
+    start: number,
+    definition: ChainDefinition,
+): ParsedChainWithSpans {
+    const separator = separatorOf(definition);
+    const bodyStart = start + definition.trigger.length;
+    const spans: ChainSegmentSpan[] = [];
+    const segments: string[] = [];
+    let cursor = bodyStart;
+    let expectsSegment = true;
+    let syntaxComplete = true;
+
+    while (cursor < text.length) {
+        const first = text.at(cursor);
+        if (first === undefined || /\s/u.test(first)) break;
+
+        const segmentStart = cursor;
+        let contentStart = cursor;
+        let contentEnd = cursor;
+        let segmentEnd = cursor;
+        let value = "";
+        let quoted = false;
+        let segmentComplete = true;
+
+        if (first === '"') {
+            quoted = true;
+            contentStart = cursor + 1;
+            cursor += 1;
+
+            let closed = false;
+            while (cursor < text.length) {
+                const character = text.at(cursor);
+                if (character === "\\" && cursor + 1 < text.length) {
+                    const escaped = text.at(cursor + 1);
+                    if (escaped !== undefined) value += escaped;
+                    cursor += 2;
+                    continue;
+                }
+
+                if (character === '"') {
+                    contentEnd = cursor;
+                    cursor += 1;
+                    closed = true;
+                    break;
+                }
+
+                if (character === undefined || character === "\n" || character === "\r") break;
+
+                value += character;
+                cursor += 1;
+            }
+
+            if (!closed) {
+                contentEnd = cursor;
+                segmentComplete = false;
+                syntaxComplete = false;
+            }
+
+            segmentEnd = cursor;
+        } else {
+            while (cursor < text.length) {
+                const character = text.at(cursor);
+                if (character === undefined || /\s/u.test(character)) break;
+                if (text.startsWith(separator, cursor)) break;
+
+                if (character === "\\" && cursor + 1 < text.length) {
+                    cursor += 2;
+                    continue;
+                }
+
+                cursor += 1;
+            }
+
+            segmentEnd = cursor;
+            contentEnd = cursor;
+
+            let raw = text.slice(contentStart, contentEnd);
+            while (raw.length > 0) {
+                const last = raw.at(-1);
+                let precedingBackslashes = 0;
+                for (let index = raw.length - 2; index >= 0 && raw[index] === "\\"; index -= 1) {
+                    precedingBackslashes += 1;
+                }
+
+                const escaped = precedingBackslashes % 2 === 1;
+                if (last === undefined || escaped || !TRAILING_PUNCTUATION.has(last)) break;
+
+                raw = raw.slice(0, -1);
+                cursor -= 1;
+                segmentEnd -= 1;
+                contentEnd -= 1;
+            }
+
+            value = decodeEscapes(raw);
+        }
+
+        if (segmentEnd === segmentStart && !quoted) break;
+
+        spans.push({
+            index: spans.length,
+            start: segmentStart,
+            end: segmentEnd,
+            contentStart,
+            contentEnd,
+            value,
+            quoted,
+            complete: segmentComplete,
+        });
+
+        segments.push(value);
+        expectsSegment = false;
+
+        if (!segmentComplete || !text.startsWith(separator, cursor)) break;
+
+        cursor += separator.length;
+        expectsSegment = true;
+    }
+
+    const end = cursor;
+    const complete = segments.length > 0 && !expectsSegment && syntaxComplete;
+
+    return {
+        chain: {
+            sourceId: definition.id,
+            trigger: definition.trigger,
+            start,
+            end,
+            segments,
+            complete,
+        },
+        separator,
+        spans,
+    };
+}
+
+function parseMentionsWithSpans(
+    text: string,
+    definitions: readonly ChainDefinition[],
+): readonly ParsedChainWithSpans[] {
+    assertDefinitions(definitions);
+
+    const ordered = [...definitions].sort(
+        (left, right) => right.trigger.length - left.trigger.length,
+    );
+    const parsed: ParsedChainWithSpans[] = [];
+
+    for (let index = 0; index < text.length; ) {
+        let definition: ChainDefinition | undefined;
+        for (const candidate of ordered) {
+            if (text.startsWith(candidate.trigger, index) && isTriggerBoundary(text, index)) {
+                definition = candidate;
+                break;
+            }
+        }
+
+        if (definition === undefined) {
+            index += 1;
+            continue;
+        }
+
+        const mention = parseChainAt(text, index, definition);
+        parsed.push(mention);
+        index = Math.max(index + definition.trigger.length, mention.chain.end);
+    }
+
+    return parsed;
+}
+
+/** Parses registered mention chains without resolving their provider-owned segment values. */
+export function parseMentions(
+    text: string,
+    definitions: readonly ChainDefinition[],
+): readonly ParsedChain[] {
+    return parseMentionsWithSpans(text, definitions).map((parsed) => parsed.chain);
+}
+
+function queryThroughCursor(text: string, span: ChainSegmentSpan, cursor: number): string {
+    const through = Math.min(Math.max(cursor, span.contentStart), span.contentEnd);
+    return decodeEscapes(text.slice(span.contentStart, through));
+}
+
+/** Finds the segment edited at an absolute cursor and the chain suffix that completion owns. */
+export function activeChainSegment(
+    text: string,
+    definitions: readonly ChainDefinition[],
+    cursor: number,
+): ActiveChainSegment | undefined {
+    for (const parsed of parseMentionsWithSpans(text, definitions)) {
+        const bodyStart = parsed.chain.start + parsed.chain.trigger.length;
+        if (cursor < bodyStart || cursor > parsed.chain.end) continue;
+
+        for (const span of parsed.spans) {
+            if (cursor < span.start || cursor > span.end) continue;
+            return {
+                chain: parsed.chain,
+                separator: parsed.separator,
+                index: span.index,
+                query: queryThroughCursor(text, span, cursor),
+                path: parsed.chain.segments.slice(0, span.index),
+                start: span.start,
+                end: span.end,
+                ownedEnd: parsed.chain.end,
+                span,
+            };
+        }
+
+        const index = parsed.spans.length;
+        const emptySpan: ChainSegmentSpan = {
+            index,
+            start: cursor,
+            end: cursor,
+            contentStart: cursor,
+            contentEnd: cursor,
+            value: "",
+            quoted: false,
+            complete: false,
+        };
+
+        return {
+            chain: parsed.chain,
+            separator: parsed.separator,
+            index,
+            query: "",
+            path: parsed.chain.segments,
+            start: cursor,
+            end: cursor,
+            ownedEnd: parsed.chain.end,
+            span: emptySpan,
+        };
+    }
+
+    return undefined;
+}
+
+function formatSegment(segment: string, separator: string): string {
+    if (
+        segment.length > 0 &&
+        !segment.includes(separator) &&
+        !/[\s"\\]/u.test(segment) &&
+        !TRAILING_PUNCTUATION.has(segment[segment.length - 1] ?? "")
+    ) {
+        return segment;
+    }
+
+    return `"${segment.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+/** Formats independently quoted chain segments using the same grammar as parseMentions. */
+export function formatChain(segments: readonly string[], trigger: string, separator = ":"): string {
+    if (trigger.length === 0) throw new Error("Mention trigger must not be empty.");
+    if (separator.length === 0) throw new Error("Mention separator must not be empty.");
+    return `${trigger}${segments.map((segment) => formatSegment(segment, separator)).join(separator)}`;
+}

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

@@ -0,0 +1,291 @@
+import { spawn } from "node:child_process";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+
+import {
+    discoveryResponseSchema,
+    resolutionSchema,
+    type Candidate,
+    type DiscoveryResponse,
+    type Provider,
+    type Resolution,
+} from "./source-contract.ts";
+
+export const COMMAND_PROVIDER_PROTOCOL_VERSION = 1 as const;
+const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 5_000;
+
+export type CommandProcessOptions = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly timeoutMs?: number;
+    readonly maxOutputBytes?: number;
+};
+
+export type CommandProviderOptions = CommandProcessOptions & {
+    readonly filtering?: "local" | "provider";
+};
+
+export type CommandDiscoveryRequestV1 = {
+    readonly version: typeof COMMAND_PROVIDER_PROTOCOL_VERSION;
+    readonly method: "discover";
+    readonly sourceId: string;
+    readonly cwd: string;
+    readonly trusted: boolean;
+    readonly query: string;
+    readonly path: readonly Candidate[];
+    readonly limit: number;
+    readonly cursor?: string;
+};
+
+export type CommandResolveRequestV1 = {
+    readonly version: typeof COMMAND_PROVIDER_PROTOCOL_VERSION;
+    readonly method: "resolve";
+    readonly sourceId: string;
+    readonly cwd: string;
+    readonly trusted: boolean;
+    readonly segments: readonly string[];
+};
+
+export type CommandRequestV1 = CommandDiscoveryRequestV1 | CommandResolveRequestV1;
+
+export type CommandDiscoveryResponseV1 = {
+    readonly version: typeof COMMAND_PROVIDER_PROTOCOL_VERSION;
+    readonly method: "discover";
+    readonly result: DiscoveryResponse;
+};
+
+export type CommandResolveResponseV1 = {
+    readonly version: typeof COMMAND_PROVIDER_PROTOCOL_VERSION;
+    readonly method: "resolve";
+    readonly result: Resolution;
+};
+
+export type CommandResponseV1 = CommandDiscoveryResponseV1 | CommandResolveResponseV1;
+
+const commandDiscoveryResponseSchema = Type.Object(
+    {
+        version: Type.Literal(COMMAND_PROVIDER_PROTOCOL_VERSION),
+        method: Type.Literal("discover"),
+        result: discoveryResponseSchema,
+    },
+    { additionalProperties: false },
+);
+
+const commandResolveResponseSchema = Type.Object(
+    {
+        version: Type.Literal(COMMAND_PROVIDER_PROTOCOL_VERSION),
+        method: Type.Literal("resolve"),
+        result: resolutionSchema,
+    },
+    { additionalProperties: false },
+);
+
+function validateProcessOptions(options: CommandProcessOptions): void {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        throw new Error("timeoutMs must be positive");
+
+    if (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes <= 0) {
+        throw new Error("maxOutputBytes must be a positive integer");
+    }
+}
+
+function killProcessTree(child: ReturnType<typeof spawn>): void {
+    const pid = child.pid;
+    if (pid !== undefined && process.platform !== "win32") {
+        try {
+            process.kill(-pid, "SIGKILL");
+            return;
+        } catch {
+            // The process may have exited between the event and termination attempt.
+        }
+    }
+
+    child.kill("SIGKILL");
+}
+
+/**
+ * Executes a JSON-producing command without a shell. An undefined request closes stdin without
+ * writing bytes, which is the explicit adapter for commands that only return a JSON array.
+ */
+/* oxlint-disable antislop/no-unknown-returns, typescript/no-redundant-type-constituents -- The requested low-level JSON adapter intentionally leaves parsing to its caller. */
+export async function executeJsonCommand(
+    options: CommandProcessOptions,
+    request: unknown | undefined,
+    signal: AbortSignal,
+): Promise<unknown> {
+    validateProcessOptions(options);
+    signal.throwIfAborted();
+    let input: string | undefined;
+    if (request !== undefined) {
+        try {
+            // JSON.stringify returns undefined for unsupported top-level values.
+            const stringify: (...args: Parameters<typeof JSON.stringify>) => string | undefined =
+                JSON.stringify;
+            input = stringify(request);
+        } catch {
+            return Promise.reject(new Error("command request must be JSON serializable"));
+        }
+
+        if (input === undefined) {
+            return Promise.reject(new Error("command request must be JSON serializable"));
+        }
+    }
+
+    const child = spawn(options.command, [...options.args], {
+        cwd: options.cwd,
+        detached: process.platform !== "win32",
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    return new Promise<unknown>((resolve, reject) => {
+        const stdout: Buffer[] = [];
+        const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+        let outputBytes = 0;
+        let failure: Error | undefined;
+        let settled = false;
+        let timeout: ReturnType<typeof setTimeout> | undefined;
+        let abortListener: (() => void) | undefined;
+
+        const finishFailure = (cause: Error): void => {
+            if (settled) return;
+
+            settled = true;
+            clearTimeout(timeout);
+
+            if (abortListener !== undefined) signal.removeEventListener("abort", abortListener);
+            killProcessTree(child);
+            reject(cause);
+        };
+
+        abortListener = (): void => {
+            let cause: Error = new DOMException("The operation was aborted", "AbortError");
+            if (signal.reason instanceof Error) cause = signal.reason;
+            finishFailure(cause);
+        };
+        timeout = setTimeout(
+            () => finishFailure(new Error("command timed out")),
+            options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        );
+
+        signal.addEventListener("abort", abortListener, { once: true });
+        child.once("error", () => {
+            finishFailure(new Error("command could not be started"));
+        });
+
+        child.stdin.once("error", () => {
+            if (!settled) failure = new Error("command stdin failed");
+        });
+
+        child.stdout.on("data", (chunk: Buffer) => {
+            outputBytes += chunk.byteLength;
+            if (outputBytes > maxOutputBytes) {
+                failure = new Error("command output exceeded maxOutputBytes");
+                killProcessTree(child);
+                return;
+            }
+
+            stdout.push(chunk);
+        });
+
+        child.stderr.on("data", (chunk: Buffer) => {
+            outputBytes += chunk.byteLength;
+            if (outputBytes > maxOutputBytes) {
+                failure = new Error("command output exceeded maxOutputBytes");
+                killProcessTree(child);
+            }
+        });
+
+        child.once("close", (code, closeSignal) => {
+            if (settled) return;
+
+            settled = true;
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", abortListener);
+
+            if (failure !== undefined) {
+                reject(failure);
+                return;
+            }
+
+            if (code !== 0 || closeSignal !== null) {
+                reject(new Error("command failed"));
+                return;
+            }
+
+            try {
+                resolve(JSON.parse(Buffer.concat(stdout).toString("utf8")));
+            } catch {
+                reject(new Error("command stdout must contain one JSON value"));
+            }
+        });
+
+        if (input === undefined) child.stdin.end();
+        else child.stdin.end(`${input}\n`);
+    });
+}
+/* oxlint-enable antislop/no-unknown-returns, typescript/no-redundant-type-constituents */
+
+/** Adapts the explicit version-1 stdin/stdout protocol to the shared provider contract. */
+export function createCommandProvider(options: CommandProviderOptions): Provider {
+    validateProcessOptions(options);
+
+    return {
+        filtering: options.filtering ?? "provider",
+        async discover(request) {
+            let commandRequest: CommandDiscoveryRequestV1;
+            if (request.cursor === undefined) {
+                commandRequest = {
+                    version: COMMAND_PROVIDER_PROTOCOL_VERSION,
+                    method: "discover",
+                    sourceId: request.sourceId,
+                    cwd: request.cwd,
+                    trusted: request.trusted,
+                    query: request.query,
+                    path: request.path,
+                    limit: request.limit,
+                };
+            } else {
+                commandRequest = {
+                    version: COMMAND_PROVIDER_PROTOCOL_VERSION,
+                    method: "discover",
+                    sourceId: request.sourceId,
+                    cwd: request.cwd,
+                    trusted: request.trusted,
+                    query: request.query,
+                    path: request.path,
+                    limit: request.limit,
+                    cursor: request.cursor,
+                };
+            }
+
+            const response = await executeJsonCommand(options, commandRequest, request.signal);
+            try {
+                return Value.Parse(commandDiscoveryResponseSchema, response).result;
+            } catch {
+                throw new Error("command returned an invalid protocol v1 response");
+            }
+        },
+        async resolve(request) {
+            const commandRequest: CommandResolveRequestV1 = {
+                version: COMMAND_PROVIDER_PROTOCOL_VERSION,
+                method: "resolve",
+                sourceId: request.sourceId,
+                cwd: request.cwd,
+                trusted: request.trusted,
+                segments: request.segments,
+            };
+            const response = await executeJsonCommand(options, commandRequest, request.signal);
+            try {
+                return Value.Parse(commandResolveResponseSchema, response).result;
+            } catch {
+                throw new Error("command returned an invalid protocol v1 response");
+            }
+        },
+    };
+}

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

@@ -0,0 +1,66 @@
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { createCommandProvider, executeJsonCommand } from "./command-provider.ts";
+import { createListProvider } from "./list-provider.ts";
+import {
+    mentionItemSchema,
+    type ConfiguredMention,
+    type ConfiguredMentionItem,
+} from "./settings-input.ts";
+import type { Candidate, DiscoveryRequest, Provider } from "./source-contract.ts";
+
+const itemsSchema = Type.Array(mentionItemSchema, { maxItems: 10000 });
+
+function candidateOf(item: ConfiguredMentionItem): Candidate {
+    return {
+        id: item.id ?? item.name,
+        label: item.name,
+        segment: item.segment ?? item.name,
+        description: item.description,
+        searchText: item.searchText,
+        insertionText: item.insertionText,
+        selectable: item.selectable ?? item.navigable !== true,
+        navigable: item.navigable ?? false,
+        replacement: item.replacement,
+    };
+}
+
+function children(
+    items: readonly ConfiguredMentionItem[],
+    request: DiscoveryRequest,
+): readonly Candidate[] {
+    const ids = request.path.map((candidate) => candidate.id);
+
+    return items
+        .filter((item) => {
+            const parent = item.parentPath ?? [];
+
+            return parent.length === ids.length && parent.every((id, index) => id === ids[index]);
+        })
+        .map(candidateOf);
+}
+
+/** Settings and commands adapt to the same contract; cache policy belongs to the source controller. */
+export function createConfiguredProvider(mention: ConfiguredMention, cwd: string): Provider {
+    const source = mention.source;
+    if (source.type === "static")
+        return createListProvider(async (request) => children(source.items, request));
+
+    const options = {
+        command: source.command,
+        args: source.args,
+        cwd,
+        timeoutMs: source.timeoutMs,
+        maxOutputBytes: source.maxOutputBytes,
+    };
+    if (source.mode === "protocol")
+        return createCommandProvider({ ...options, filtering: source.filtering ?? "provider" });
+
+    return createListProvider(async (request) => {
+        const raw = await executeJsonCommand(options, undefined, request.signal);
+        if (!Value.Check(itemsSchema, raw))
+            throw new Error("Mention array command returned invalid candidates.");
+
+        return children(raw, request);
+    });
+}