@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/app/session-shell/paste-protocol.d.ts

@@ -0,0 +1,78 @@
+import type { PiShellClipboardContent } from "../../integrations/pi/components/index.js";
+import type { PreparedPasteText, ClipboardPath } from "./paste-text-preparation.js";
+import type { PreparedImage } from "./image-preparation.js";
+export declare const PASTE_READ_MS = 5000;
+export declare const PASTE_TOTAL_MS = 15000;
+export declare const PASTE_STOP_MS = 250;
+export declare const PASTE_TEXT_BYTES: number;
+export declare const PASTE_CHUNK_UNITS = 16384;
+export declare const PASTE_REQUESTS = 8;
+export type PreparedPaste = PreparedPasteText | ({
+    readonly kind: "image";
+} & PreparedImage) | null;
+/** The predecessor is captured at admission; a later copy cannot change what this paste waits for. */
+export type PasteSource = {
+    readonly kind: "native";
+    readonly before?: (signal: AbortSignal) => Promise<boolean>;
+} | {
+    readonly kind: "provided";
+    readonly read: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>;
+    readonly before?: (signal: AbortSignal) => Promise<boolean>;
+} | {
+    readonly kind: "text";
+    readonly text: string;
+};
+export interface PasteEvent {
+    readonly request: number;
+    readonly phase: "receipt" | "shortcut-received" | "shortcut-matched" | "shortcut-admitted" | "pointer-admitted" | "framing" | "admitted" | "predecessor" | "acquiring" | "acquired-text" | "acquired-image" | "classifying" | "path-fallback" | "prepared" | "inserting" | "settled" | "cleanup";
+    readonly atMs: number;
+    readonly elapsedMs?: number;
+    readonly pending: number;
+    readonly transport?: "native" | "terminal" | "provided";
+    readonly bytes?: number;
+    readonly outcome?: "ready" | "failed" | "canceled" | "timed-out";
+}
+export type PasteHelperInput = {
+    readonly kind: "begin";
+    readonly source: "native" | "text" | "image";
+    readonly mimeType?: string;
+} | {
+    readonly kind: "data";
+    readonly data: string;
+} | {
+    readonly kind: "finish";
+} | {
+    readonly kind: "convert";
+} | {
+    readonly kind: "next";
+} | {
+    readonly kind: "cancel";
+};
+export type PasteHelperOutput = {
+    readonly kind: "ready";
+} | {
+    readonly kind: "phase";
+    readonly phase: "acquired-text" | "acquired-image" | "classifying" | "path-fallback" | "prepared";
+    readonly bytes?: number;
+} | {
+    readonly kind: "output";
+    readonly type: "text" | "url" | "paths" | "image" | "empty";
+    readonly label?: string;
+    readonly mimeType?: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly transformed?: boolean;
+} | {
+    readonly kind: "data";
+    readonly data: string;
+} | {
+    readonly kind: "path";
+    readonly path: ClipboardPath;
+} | {
+    readonly kind: "done";
+} | {
+    readonly kind: "error";
+    readonly code: string;
+};
+/** Split without breaking UTF-16 surrogate pairs, so per-fragment UTF-8 accounting is exact. */
+export declare function pasteFragments(text: string): Generator<string>;

package/dist/app/session-shell/paste-protocol.js

@@ -0,0 +1,18 @@
+import { MAX_CLIPBOARD_TEXT_BYTES } from "../../contracts/owned-ui/index.js";
+export const PASTE_READ_MS = 5_000;
+export const PASTE_TOTAL_MS = 15_000;
+export const PASTE_STOP_MS = 250;
+export const PASTE_TEXT_BYTES = MAX_CLIPBOARD_TEXT_BYTES;
+export const PASTE_CHUNK_UNITS = 16_384;
+export const PASTE_REQUESTS = 8;
+/** Split without breaking UTF-16 surrogate pairs, so per-fragment UTF-8 accounting is exact. */
+export function* pasteFragments(text) {
+    for (let offset = 0; offset < text.length;) {
+        let end = Math.min(text.length, offset + PASTE_CHUNK_UNITS);
+        const last = text.charCodeAt(end - 1);
+        if (end < text.length && last >= 0xd800 && last <= 0xdbff)
+            end--;
+        yield text.slice(offset, end);
+        offset = end;
+    }
+}

package/dist/app/session-shell/paste-text-preparation.d.ts

@@ -0,0 +1,6 @@
+import type { PreparedPasteText } from "./paste-types.js";
+export type { ClipboardPath, PreparedPasteText } from "./paste-types.js";
+/** Small non-path text has a fixed CPU bound and cannot enter filesystem probing. */
+export declare function canPreparePasteInline(text: string): boolean;
+/** The shared chip classifier; interactive callers run path/filesystem probing in an isolated executor. */
+export declare function preparePasteText(text: string, skipPaths?: boolean, compactPaths?: boolean): PreparedPasteText;

package/dist/app/session-shell/paste-text-preparation.js

@@ -0,0 +1,134 @@
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { prepareTextPaste } from "./text-paste.js";
+import { preparePathPresentation } from "./path-chip-presentation.js";
+const URL_PATTERN = /^https?:\/\/[^\s\u0000-\u001f\u007f]+$/iu;
+/** Small non-path text has a fixed CPU bound and cannot enter filesystem probing. */
+export function canPreparePasteInline(text) {
+    return text.length <= 1000 && !/^(?:[A-Za-z]:\\|\/|file:\/\/|["'&])/iu.test(text.trimStart());
+}
+/** The shared chip classifier; interactive callers run path/filesystem probing in an isolated executor. */
+export function preparePasteText(text, skipPaths = false, compactPaths = false) {
+    const url = text.trim();
+    if (URL_PATTERN.test(url))
+        return { kind: "url", url, label: url.length <= 40 ? url : `${url.slice(0, 40)}…` };
+    const paths = skipPaths ? [] : pathsFromClipboard(text);
+    if (paths.length > 0)
+        return compactPaths ? preparePathPresentation(paths) : { kind: "paths", paths };
+    return { kind: "text", ...prepareTextPaste(text) };
+}
+function pathsFromClipboard(text) {
+    const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+    if (normalized.length === 0)
+        return [];
+    const paths = [];
+    for (const line of normalized.split("\n").filter(value => value.trim().length > 0)) {
+        const wholeLine = existingClipboardPath(line);
+        if (wholeLine !== null) {
+            paths.push(wholeLine);
+            continue;
+        }
+        const tokens = tokenizePathLine(line)?.filter(token => token.quoted || token.text !== "&");
+        if (tokens === undefined || tokens.length === 0)
+            return [];
+        for (let index = 0; index < tokens.length;) {
+            const token = tokens[index];
+            if (token === undefined)
+                return [];
+            if (token.quoted) {
+                const quoted = existingClipboardPath(token.text);
+                if (quoted === null)
+                    return [];
+                paths.push(quoted);
+                index++;
+                continue;
+            }
+            if (normalizePath(token.text) === null)
+                return [];
+            let runEnd = index;
+            while (runEnd < tokens.length && tokens[runEnd]?.quoted !== true)
+                runEnd++;
+            let matched = null;
+            let matchedEnd = index;
+            for (let end = runEnd; end > index; end--) {
+                matched = existingClipboardPath(tokens.slice(index, end).map(candidate => candidate.text).join(" "));
+                if (matched !== null) {
+                    matchedEnd = end;
+                    break;
+                }
+            }
+            if (matched === null)
+                return [];
+            paths.push(matched);
+            index = matchedEnd;
+        }
+    }
+    return paths;
+}
+function existingClipboardPath(value) {
+    const fullPath = normalizePath(unquote(value.trim()));
+    if (fullPath === null || !existsSync(fullPath))
+        return null;
+    try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory())
+            return { fullPath, kind: "folder" };
+        if (stat.isFile())
+            return { fullPath, kind: "file" };
+    }
+    catch { /* Compatibility: unavailable paths remain ordinary text. */ }
+    return null;
+}
+function tokenizePathLine(line) {
+    const tokens = [];
+    let index = 0;
+    while (index < line.length) {
+        while (index < line.length && /\s/u.test(line[index] ?? ""))
+            index++;
+        if (index >= line.length)
+            break;
+        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
+        if (quote !== undefined) {
+            index++;
+            const start = index;
+            while (index < line.length && line[index] !== quote)
+                index++;
+            if (index >= line.length)
+                return undefined;
+            tokens.push({ text: line.slice(start, index), quoted: true });
+            index++;
+            if (index < line.length && !/\s/u.test(line[index] ?? ""))
+                return undefined;
+            continue;
+        }
+        const start = index;
+        while (index < line.length && !/\s/u.test(line[index] ?? ""))
+            index++;
+        tokens.push({ text: line.slice(start, index), quoted: false });
+    }
+    return tokens;
+}
+function normalizePath(value) {
+    let candidate = value;
+    if (/^file:\/\//iu.test(candidate)) {
+        try {
+            candidate = fileURLToPath(candidate);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (process.platform === "win32") {
+        const msys = /^\/([A-Za-z])\/(.*)$/u.exec(candidate);
+        if (msys !== null)
+            candidate = `${msys[1]}:\\${msys[2]?.replaceAll("/", "\\") ?? ""}`;
+    }
+    return /^(?:[A-Za-z]:\\|\/)/u.test(candidate) ? path.normalize(candidate) : null;
+}
+function unquote(value) {
+    let result = value.startsWith("& ") ? value.slice(2).trim() : value;
+    if ((result.startsWith('"') && result.endsWith('"')) || (result.startsWith("'") && result.endsWith("'")))
+        result = result.slice(1, -1).trim();
+    return result;
+}

package/dist/app/session-shell/paste-text-worker.js

@@ -0,0 +1,12 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { preparePasteText } from "./paste-text-preparation.js";
+// Concurrency: the containing paste process can exit even if a filesystem probe blocks this worker.
+try {
+    parentPort?.postMessage({ ok: true, value: preparePasteText(workerData, false, true) });
+}
+catch {
+    parentPort?.postMessage({ ok: false });
+}
+finally {
+    parentPort?.close();
+}

package/dist/app/session-shell/paste-types.d.ts

@@ -0,0 +1,17 @@
+/** Paste classification results shared by text preparation and path chip presentation. */
+export interface ClipboardPath {
+    readonly fullPath: string;
+    readonly kind: "folder" | "file";
+}
+export type PreparedPasteText = {
+    readonly kind: "text";
+    readonly text: string;
+    readonly label?: string;
+} | {
+    readonly kind: "url";
+    readonly url: string;
+    readonly label: string;
+} | {
+    readonly kind: "paths";
+    readonly paths: readonly ClipboardPath[];
+};

package/dist/app/session-shell/path-chip-presentation.d.ts

@@ -0,0 +1,7 @@
+import type { ClipboardPath, PreparedPasteText } from "./paste-types.js";
+export declare const PATH_CHIP_PRESENTATION_UNITS = 4096;
+export declare const PATH_CHIP_SUFFIX_UNITS = 20;
+/** Shared base tag for presentation budgeting and actual chip adoption, including image-file spacing. */
+export declare function pathChipTag(item: ClipboardPath): string;
+/** Run in the isolated preparer: compact before path arrays become an oversized editor presentation. */
+export declare function preparePathPresentation(paths: readonly ClipboardPath[]): PreparedPasteText;

package/dist/app/session-shell/path-chip-presentation.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+export const PATH_CHIP_PRESENTATION_UNITS = 4096;
+// Invariant: a collision suffix containing any safe-integer index fits this per-occurrence reserve.
+export const PATH_CHIP_SUFFIX_UNITS = 20;
+const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
+/** Shared base tag for presentation budgeting and actual chip adoption, including image-file spacing. */
+export function pathChipTag(item) {
+    const label = path.basename(item.fullPath) || path.parse(item.fullPath).root.replace(/[\\/]+$/u, "") || item.fullPath;
+    const icon = item.kind === "folder" ? "📁" : IMAGE_EXTENSION.test(item.fullPath) ? "🖼 " : "📄";
+    return `[${icon} ${label}]`;
+}
+/** Run in the isolated preparer: compact before path arrays become an oversized editor presentation. */
+export function preparePathPresentation(paths) {
+    let units = 0;
+    for (const item of paths) {
+        units += pathChipTag(item).length + PATH_CHIP_SUFFIX_UNITS;
+        if (units > PATH_CHIP_PRESENTATION_UNITS) {
+            // Compatibility: individual adjacent chips expand without inserted separators or text re-normalization.
+            const text = paths.map(value => value.fullPath).join("");
+            return { kind: "text", text, label: `${text.length} chars` };
+        }
+    }
+    return { kind: "paths", paths };
+}

package/dist/app/session-shell/prompt-chips.d.ts

@@ -0,0 +1,76 @@
+import type { PiShellClipboardContent, PiShellEditorTextRange } from "../../integrations/pi/components/shell-shared-facade.js";
+import { type PastePreparationClientOptions } from "./paste-preparation-client.js";
+import type { PasteEvent, PasteSource } from "./paste-protocol.js";
+export interface PromptImageAttachment {
+    readonly type: "image";
+    readonly data: string;
+    readonly mimeType: string;
+}
+export interface PreparedPrompt {
+    readonly text: string;
+    readonly images: readonly PromptImageAttachment[];
+}
+/** Owns semantic chips and bounded pending paste references; cancels background work on reset or disposal. */
+export declare class PromptChipStore {
+    #private;
+    constructor(options?: {
+        readonly isolated?: boolean;
+        readonly onEvent?: (event: PasteEvent) => void;
+        readonly preparation?: Omit<PastePreparationClientOptions, "onEvent">;
+    });
+    /** Forks the spare paste helper so the session's first paste does not pay for helper startup. */
+    warm(): void;
+    beginPaste(currentText: string, read: ((signal: AbortSignal) => Promise<PiShellClipboardContent | null>) | PasteSource, onError: (error: unknown) => void, onImage?: () => void): {
+        marker: string;
+        result: Promise<string>;
+        complete?(): void;
+        isCurrent?(): boolean;
+    };
+    hasPending(text: string): boolean;
+    waitForPastes(text: string, signal: AbortSignal, readDraft?: () => string): Promise<PreparedPrompt>;
+    reconcileDraft(text: string): void;
+    resetPastes(text: string): string;
+    dispose(): Promise<void>;
+    transformPastedContent(content: PiShellClipboardContent, currentText?: string): string;
+    /** Hide provisional clipboard identities until the read identifies an actual image. */
+    hiddenRanges(line: string): readonly PiShellEditorTextRange[];
+    atomicRanges(line: string): readonly PiShellEditorTextRange[];
+    hyperlinkRanges(text: string): readonly {
+        start: number;
+        end: number;
+        target: string;
+    }[];
+    expandCopiedText(text: string): string;
+    /**
+     * Recall-safe history text. Text / URL / file / folder chips expand to their resolved value
+     * so a restart can reuse them without the originating chip cache. Image chip tags are
+     * preserved verbatim so the sidecar-backed rehydration path can re-render them into live
+     * chips carrying the original attachment bytes.
+     */
+    prepareHistoryText(text: string): string;
+    /**
+     * Extract the image chip attachments referenced by an editor draft in occurrence order,
+     * paired with their sidecar identifier. Callers use this to persist image sidecars before a
+     * history row commits, so a fresh process can rehydrate the same chip layout. Unresolved
+     * pending pastes and non-image chips are skipped; caller is responsible for waiting on
+     * pending readiness before this point.
+     */
+    imageChipAttachments(text: string): {
+        readonly id: string;
+        readonly tag: string;
+        readonly image: PromptImageAttachment;
+    }[];
+    /**
+     * Rehydrate a durable recall value into an editor-ready draft: image chip tags are looked up
+     * against a caller-supplied sidecar resolver, and detectable URL / file / folder / large text
+     * substrings are re-registered as atomic chips through the same identity rules the paste path
+     * uses. Image chips whose sidecar returns null are silently stripped without a placeholder.
+     *
+     * Every chip returned is registered in the session `#chips` map so atomic-range,
+     * hyperlink-range, and submission-expansion paths behave identically to a freshly typed draft.
+     * Callers should treat the returned string as programmatic editor text, not another draft to
+     * scan.
+     */
+    rehydrateHistoryText(text: string, resolveImage: (id: string) => PromptImageAttachment | null): string;
+    prepareSubmission(text: string): PreparedPrompt;
+}