@timurproko/a1 0.1.8-dev.235df0e → 0.1.8-dev.260

package/dist/integrations/pi/session-ui/prompt-chips.js

@@ -0,0 +1,246 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { canonicalizeClipboardImage } from "./clipboard-image.js";
+const CHIP_PATTERN = /\[(?:📷 [^\]]+|📁 [^\]]+|📄 [^\]]+|🖼 {1,2}[^\]]+|🔗 [^\]]+)\]/gu;
+const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
+const URL_PATTERN = /^https?:\/\/[^\s\u0000-\u001f\u007f]+$/iu;
+const URL_DISPLAY_LENGTH = 40;
+/** Owns semantic clipboard records while the prompt displays compact chips. */
+export class PromptChipStore {
+    #chips = new Map();
+    transformPastedContent(content) {
+        if (content.kind === "image") {
+            const image = canonicalizeClipboardImage(content);
+            if (image === null)
+                return "";
+            const id = randomBytes(5).toString("hex");
+            const tag = `[📷 screenshot-${id}.png]`;
+            this.#chips.set(tag, {
+                kind: "image",
+                tag,
+                image: { type: "image", data: image.data, mimeType: image.mimeType },
+            });
+            return tag;
+        }
+        const text = content.text;
+        if (this.#chips.has(text.trim()))
+            return text.trim();
+        const url = text.trim();
+        if (URL_PATTERN.test(url)) {
+            const label = url.length <= URL_DISPLAY_LENGTH ? url : `${url.slice(0, URL_DISPLAY_LENGTH)}…`;
+            return this.#recordUnique({ kind: "url", tag: `[🔗 ${label}]`, label, url });
+        }
+        const paths = pathsFromClipboard(text);
+        if (paths.length === 0)
+            return text;
+        return paths.map(item => {
+            const label = pathLabel(item.fullPath);
+            if (item.kind === "folder") {
+                return this.#recordUnique({ kind: "folder", tag: `[📁 ${label}]`, path: item.fullPath });
+            }
+            const icon = IMAGE_EXTENSION.test(item.fullPath) ? "🖼 " : "📄";
+            return this.#recordUnique({ kind: "file", tag: `[${icon} ${label}]`, path: item.fullPath });
+        }).join("");
+    }
+    atomicRanges(line) {
+        return [...line.matchAll(CHIP_PATTERN)].map(match => ({
+            start: match.index,
+            end: match.index + match[0].length,
+        }));
+    }
+    hyperlinkRanges(text) {
+        const ranges = [];
+        for (const chip of this.#chips.values()) {
+            if (chip.kind !== "url")
+                continue;
+            const labelOffset = chip.tag.indexOf(chip.label);
+            if (labelOffset < 0)
+                continue;
+            let searchFrom = 0;
+            while (searchFrom <= text.length - chip.tag.length) {
+                const tagStart = text.indexOf(chip.tag, searchFrom);
+                if (tagStart < 0)
+                    break;
+                const start = tagStart + labelOffset;
+                ranges.push({ start, end: start + chip.label.length, target: chip.url });
+                searchFrom = tagStart + chip.tag.length;
+            }
+        }
+        return ranges.sort((left, right) => right.start - left.start);
+    }
+    expandCopiedText(text) {
+        return this.#replaceResolvable(text, false).text;
+    }
+    prepareSubmission(text) {
+        const expanded = this.#replaceResolvable(text, true);
+        return { text: expanded.text, images: expanded.images };
+    }
+    #replaceResolvable(text, includeImages) {
+        let expanded = text;
+        const images = [];
+        const seenImages = new Set();
+        for (const [tag, chip] of this.#chips) {
+            if (!expanded.includes(tag))
+                continue;
+            if (chip.kind === "image") {
+                if (includeImages && !seenImages.has(tag)) {
+                    images.push(chip.image);
+                    seenImages.add(tag);
+                }
+                continue;
+            }
+            const value = chip.kind === "url" ? chip.url : chip.path;
+            expanded = expanded.replaceAll(tag, value);
+        }
+        return { text: expanded, images };
+    }
+    #recordUnique(chip) {
+        const existing = this.#chips.get(chip.tag);
+        if (existing === undefined || sameChipValue(existing, chip)) {
+            this.#chips.set(chip.tag, chip);
+            return chip.tag;
+        }
+        const suffix = randomBytes(2).toString("hex");
+        const uniqueTag = `${chip.tag.slice(0, -1)} #${suffix}]`;
+        const unique = { ...chip, tag: uniqueTag };
+        this.#chips.set(uniqueTag, unique);
+        return uniqueTag;
+    }
+}
+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 += 1;
+                continue;
+            }
+            if (normalizePath(token.text) === null)
+                return [];
+            let runEnd = index;
+            while (runEnd < tokens.length && tokens[runEnd]?.quoted !== true)
+                runEnd += 1;
+            let matched = null;
+            let matchedEnd = index;
+            for (let end = runEnd; end > index; end -= 1) {
+                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: clipboard path probing is best-effort.
+    }
+    return null;
+}
+function tokenizePathLine(line) {
+    const tokens = [];
+    let index = 0;
+    while (index < line.length) {
+        while (index < line.length && /\s/u.test(line[index] ?? ""))
+            index += 1;
+        if (index >= line.length)
+            break;
+        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
+        if (quote !== undefined) {
+            index += 1;
+            const start = index;
+            while (index < line.length && line[index] !== quote)
+                index += 1;
+            if (index >= line.length)
+                return undefined;
+            tokens.push({ text: line.slice(start, index), quoted: true });
+            index += 1;
+            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 += 1;
+        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;
+}
+function pathLabel(fullPath) {
+    const basename = path.basename(fullPath);
+    if (basename.length > 0)
+        return basename;
+    return path.parse(fullPath).root.replace(/[\\/]+$/u, "") || fullPath;
+}
+function sameChipValue(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === "url" && right.kind === "url")
+        return left.url === right.url;
+    if ((left.kind === "file" || left.kind === "folder") && (right.kind === "file" || right.kind === "folder")) {
+        return path.normalize(left.path) === path.normalize(right.path);
+    }
+    if (left.kind === "image" && right.kind === "image")
+        return left.image.data === right.image.data;
+    return false;
+}

package/dist/integrations/pi/session-ui/route-host.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compatibility export. Owned application route lifecycle belongs to the
+ * vendor-neutral UI app owner; the Pi shell only hosts that contract.
+ */
+export type { UiRouteHost, UiRouteSurface } from "../../../ui/apps/index.js";

package/dist/integrations/pi/session-ui/session-shell-root.d.ts

@@ -0,0 +1,141 @@
+import type { OwnedUiSessionViewModel, OwnedUiViewportSettings, OwnedUiViewportSettingsPort } from "../../../contracts/owned-ui/index.js";
+import type { UiRouteHost } from "../../../ui/apps/index.js";
+import { type TranscriptViewportFrame, type TranscriptViewportFrameDescriptor } from "../../../ui/components/index.js";
+import { type PiEngineAdapter, type PiWorkflowMessage, type PiWorkflowResult } from "../engine/index.js";
+import { type PiShellClipboardContent, type PiShellComponentPort, type PiShellEditorPort, type PiShellExtensionRendererResolver, type PiShellHeaderOptions, type PiShellHeaderPort, type PiShellImageAssetResolver, type PiShellLoadedResourcesPort, type PiShellResourceEntry, type PiShellTranscriptComponentPort } from "../components/index.js";
+import { type PiTuiComponentPort, type PiTuiInputSurfaceKind, type PiTuiInputCoordinationScheduler, type PiTuiInputDiagnosticsEvent, type PiTuiLayoutNode, type PiTuiTerminalPort } from "../tui-runtime/index.js";
+import { type PreparedPrompt } from "./prompt-chips.js";
+import type { StreamPresentationScheduler } from "./stream-presentation-coalescer.js";
+export type OwnedUiBackendPort = PiEngineAdapter;
+export type OwnedUiTerminalPort = PiTuiTerminalPort;
+type OwnedUiStartupOptions = PiShellHeaderOptions;
+export interface OwnedUiClipboardPort {
+    readText(): Promise<string | null>;
+    readImage?(): Promise<{
+        readonly data: string;
+        readonly mimeType: string;
+    } | null>;
+    writeText?(text: string): Promise<void>;
+}
+export interface OwnedUiSessionShellOptions {
+    readonly backend: OwnedUiBackendPort;
+    readonly cwd: string;
+    readonly terminal?: OwnedUiTerminalPort;
+    readonly startup?: OwnedUiStartupOptions;
+    /**
+     * Declared A1-owned routes. A route this host claims resolves to its app;
+     * every other route continues to the pinned workflow table unchanged.
+     */
+    readonly routeHost?: UiRouteHost;
+    /** Bare A1 selects the owned bounded viewport; comparison profiles stay pinned. */
+    readonly sessionLayout?: "pinned" | "custom-viewport";
+    /** Live profile-local settings, supplied only to the bare-A1 composition. */
+    readonly viewportSettings?: OwnedUiViewportSettingsPort;
+    /** Optional platform seam; production uses A1's system clipboard adapter. */
+    readonly clipboard?: OwnedUiClipboardPort;
+    /** Deterministic scheduling seam for presentation-cadence tests. */
+    readonly streamPresentation?: {
+        readonly intervalMs?: number;
+        readonly scheduler?: StreamPresentationScheduler;
+    };
+    /** Optional deterministic seam for keyboard scheduling and phase evidence. */
+    readonly inputPresentation?: {
+        readonly scheduler?: PiTuiInputCoordinationScheduler;
+        readonly onEvent?: (event: PiTuiInputDiagnosticsEvent) => void;
+        readonly now?: () => number;
+        /** Evidence-only baseline seam; production leaves coordination enabled. */
+        readonly coordination?: boolean;
+        /** Evidence-only baseline seam; production leaves dock reuse enabled. */
+        readonly viewportReuse?: boolean;
+    };
+}
+/** Composes backend session state into the owned transcript, viewport, editor, and dock presentation. */
+export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
+    #private;
+    readonly editor: PiShellEditorPort;
+    readonly header: PiShellHeaderPort;
+    readonly resources: PiShellLoadedResourcesPort;
+    constructor(view: OwnedUiSessionViewModel, cwd: string, handlers: {
+        readonly getColumns: () => number;
+        readonly getRows: () => number;
+        readonly requestRender: (force?: boolean) => void;
+        readonly onViewportFrame?: (frame: TranscriptViewportFrame) => void;
+        readonly requestHyperlinkCleanup?: () => void;
+        readonly enableDockInputReuse?: boolean;
+        readonly onSubmit: (text: string) => void;
+        readonly onInterrupt: () => void;
+        readonly onClear?: () => void;
+        readonly onExit: () => void;
+        readonly onModelSelect: () => void;
+        readonly onModelCycle?: (direction: "forward" | "backward") => void;
+        readonly onThinkingCycle: () => void;
+        readonly onThinkingToggle?: () => void;
+        readonly onMessageCopy?: () => void;
+        readonly onFollowUp?: () => void;
+        readonly onDequeue?: () => void;
+        readonly onCopyText?: (text: string) => void;
+        readonly readClipboardContent?: () => Promise<PiShellClipboardContent | null>;
+    }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: PiShellExtensionRendererResolver, sessionLayout?: "pinned" | "custom-viewport", imageAssets?: PiShellImageAssetResolver);
+    setEditorPaddingX(padding: number): void;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setOutputPad(padding: 0 | 1): void;
+    setHideThinkingBlock(hidden: boolean): void;
+    setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
+    setImagePresentation(showImages: boolean, imageWidthCells: number): void;
+    preparePromptSubmission(text: string): PreparedPrompt;
+    update(view: OwnedUiSessionViewModel): void;
+    /**
+     * Applies one block: its component is created or updated in place and the order grows
+     * only when the block is new. A streamed chunk costs one component update rather than a
+     * walk of the whole transcript.
+     */
+    applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
+    render(width: number): readonly string[];
+    viewportFrameDescriptor(): TranscriptViewportFrameDescriptor | null;
+    /** Visible rows of the transient working-status tail, for rendering evidence. */
+    viewportTransientTailRowCount(): number;
+    hasActiveSelection(): boolean;
+    setViewportConfig(config: OwnedUiViewportSettings): void;
+    resumeViewportFollowing(): void;
+    noteCompletedAssistantMessage(): void;
+    resetViewport(): void;
+    clearViewportPointerState(): void;
+    handleViewportPreInput(data: string, allowWheel?: boolean, now?: number): {
+        readonly data: string;
+        readonly consumed: boolean;
+        readonly copyText?: string;
+    };
+    layoutRoot(): PiTuiLayoutNode;
+    transcriptComponent(id: string): PiShellTranscriptComponentPort | undefined;
+    exitTranscript(width: number): string;
+    appendWorkflowStatus(message: string): void;
+    appendWorkflowMessage(message: PiWorkflowMessage): void;
+    appendWorkflowResult(result: PiWorkflowResult): void;
+    appendDaxnuts(): void;
+    toggleThinkingVisibility(): void;
+    get toolsExpanded(): boolean;
+    setToolsExpanded(expanded: boolean): void;
+    setExtensionWidget(key: string, component: PiShellComponentPort | null, placement: "aboveEditor" | "belowEditor"): void;
+    setExtensionHeader(component: PiShellComponentPort | null): void;
+    setExtensionFooter(component: PiShellComponentPort | null): void;
+    setExtensionStatus(key: string, text: string | undefined): void;
+    setExtensionWorking(message: string | undefined, visible?: boolean): void;
+    resetWorkflowPresentation(): void;
+    resetExtensionUi(): void;
+    addExtensionNotification(message: string, type: "info" | "warning" | "error"): void;
+    extensionFooterData(): unknown;
+    usesDefaultInputSurface(): boolean;
+    inputCoordinationSurface(): PiTuiInputSurfaceKind;
+    viewportCompositionEvidence(): {
+        readonly full: number;
+        readonly dockOnly: number;
+    };
+    transcriptRenderCount(): number;
+    setInputSurface(component: PiShellComponentPort | null, disposePrevious?: boolean, coordination?: Exclude<PiTuiInputSurfaceKind, "editor">): void;
+    handleInput(data: string): void;
+    invalidate(): void;
+    setFocused(focused: boolean): void;
+    dispose(): void;
+}
+export declare function shellResourceEntries(backend: OwnedUiBackendPort): readonly PiShellResourceEntry[];
+export {};