@timurproko/a1 0.2.7-dev.806 → 0.2.7-dev.809

package/dist/app/session-shell/workflow-output.js

@@ -0,0 +1,174 @@
+import { createPiShellArmin, createPiShellEarendilAnnouncement, } from "../../integrations/pi/components/shell-selectors-dialogs.js";
+import { createPiShellChangelog, createPiShellHotkeys, createPiShellSessionInfo, renderPiShellCommandMessage, renderPiShellStatusText, } from "../../integrations/pi/components/shell-presenters-info.js";
+import { piShellHyperlink } from "../../integrations/pi/components/shell-shared-facade.js";
+/**
+ * Presents workflow results: bare A1 answers in the dock notice, the pinned profile appends
+ * transcript-anchored output, and consecutive status lines at the same anchor replace each other.
+ */
+export class WorkflowOutput {
+    #ports;
+    #sequence = 0;
+    #statusMessages = new Map();
+    #lastStatusId;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    appendStatus(message) {
+        // Rationale: bare A1 acknowledges commands in one dock notice above the editor, where the
+        // reader's eye already is, instead of a transcript row that opens an empty session at the
+        // top-left or sinks into a long feed. The pinned route keeps Pi's chat placement.
+        if (this.#ports.customViewport) {
+            this.#ports.dock.setNotice({ kind: "status", message });
+            return;
+        }
+        const { document } = this.#ports;
+        const previousId = this.#lastStatusId;
+        if (previousId !== undefined
+            && document.lastId === previousId
+            && document.anchorOf(previousId) === this.#ports.transcriptLength()) {
+            this.#statusMessages.set(previousId, message);
+            document.invalidate("workflow-status");
+            this.#ports.invalidate();
+            return;
+        }
+        const id = this.#appendAnchored(width => [
+            "",
+            ...renderPiShellStatusText(this.#statusMessages.get(id) ?? message, width),
+        ]);
+        this.#statusMessages.set(id, message);
+        this.#lastStatusId = id;
+    }
+    appendMessage(message, errorCode) {
+        if (message.kind === "status") {
+            this.appendStatus(message.message);
+            return;
+        }
+        if (this.#ports.customViewport && (message.kind === "warning" || message.kind === "error")) {
+            this.#ports.dock.setNotice({
+                kind: errorCode === "image-count" ? "warning" : message.kind,
+                message: message.message,
+                ...(errorCode === undefined ? {} : { errorCode }),
+            });
+            return;
+        }
+        this.#lastStatusId = undefined;
+        const presentation = { kind: message.kind, message: message.message };
+        this.#appendAnchored(width => renderPiShellCommandMessage(presentation, width, this.#ports.outputPad()));
+    }
+    appendResult(result, errorCode) {
+        if (result.messages !== undefined) {
+            for (const message of result.messages)
+                this.appendMessage(message, errorCode);
+            return;
+        }
+        if (result.messageKind === "silent" || (result.outcome === "cancelled" && result.messageKind === undefined))
+            return;
+        if (result.command === "reload" && result.outcome === "completed") {
+            this.appendStatus(result.message);
+            return;
+        }
+        if (result.outcome === "completed" && this.#appendPresentation(result))
+            return;
+        if (result.outcome === "failed") {
+            this.appendMessage({
+                kind: result.messageKind === "warning" ? "warning" : "error",
+                message: result.message,
+            }, errorCode);
+            return;
+        }
+        if (result.outcome === "completed" && (result.command === "quit" || result.command === "compact"))
+            return;
+        if (result.outcome === "completed" && result.command === "new" && this.#ports.customViewport) {
+            // Rationale: bare A1 keeps the replacement session visually empty while preserving Pi's accent notice shape.
+            this.#ports.dock.setNotice({ kind: "new-session", message: result.message });
+            return;
+        }
+        if (result.outcome === "completed" && (result.command === "new" || result.command === "name" || result.command === "debug")) {
+            this.#lastStatusId = undefined;
+            const presentation = { kind: result.command, message: result.message, ...(result.detail === undefined ? {} : { detail: result.detail }) };
+            this.#appendAnchored(width => renderPiShellCommandMessage(presentation, width, this.#ports.outputPad()));
+            return;
+        }
+        if (result.outcome === "completed" && this.#appendAnnouncement(result.command))
+            return;
+        // Rationale: the pinned engine links both share URLs; the workflow result carries the plain URLs.
+        const message = result.command !== "share" ? result.message
+            : result.detail ? `${linkShareUrl(result.message)}\nGist: ${piShellHyperlink(result.detail)}`
+                // Protocol: Radius shares carry only the artifact URL.
+                : linkShareUrl(result.message);
+        this.appendStatus(message);
+    }
+    /** Drops every anchored output and the status-replacement chain. */
+    reset() {
+        this.#ports.document.removeAnchored();
+        this.#statusMessages.clear();
+        this.#lastStatusId = undefined;
+    }
+    // Invariant: session info, hotkeys, and changelog draw their own components; false for any other completed command.
+    #appendPresentation(result) {
+        if (result.command === "session" && result.presentation?.kind === "session-info") {
+            this.#lastStatusId = undefined;
+            const sessionInfo = createPiShellSessionInfo(result.presentation);
+            this.#appendAnchored(width => sessionInfo.render(width), () => sessionInfo.dispose?.());
+            return true;
+        }
+        if (result.command === "hotkeys") {
+            this.#lastStatusId = undefined;
+            const presentation = this.#ports.hotkeysPresentation();
+            const hotkeys = createPiShellHotkeys(presentation.bindings, presentation.getShortcuts, presentation.profile, presentation.residentTabs);
+            this.#appendAnchored(width => hotkeys.render(width), () => hotkeys.dispose?.());
+            return true;
+        }
+        if (result.command === "changelog") {
+            this.#lastStatusId = undefined;
+            const changelog = createPiShellChangelog(result.detail ?? "No changelog entries found.");
+            this.#appendAnchored(width => changelog.render(width), () => changelog.dispose?.());
+            return true;
+        }
+        return false;
+    }
+    // Invariant: the two easter-egg announcements; false for any other command.
+    #appendAnnouncement(command) {
+        if (command === "arminsayshi") {
+            this.#lastStatusId = undefined;
+            const armin = createPiShellArmin(this.#ports.componentRuntime);
+            this.#appendAnchored(width => ["", ...armin.render(width)], () => armin.dispose?.());
+            return true;
+        }
+        if (command === "dementedelves") {
+            this.#lastStatusId = undefined;
+            const announcement = createPiShellEarendilAnnouncement();
+            this.#appendAnchored(width => ["", ...announcement.render(width)], () => announcement.dispose?.());
+            return true;
+        }
+        return false;
+    }
+    #appendAnchored(render, dispose) {
+        // Invariant: transcript-bound workflow output supersedes a pending acknowledgement.
+        this.#ports.dock.dismissNotice();
+        this.#sequence += 1;
+        const id = `workflow-status-${this.#sequence}`;
+        const component = {
+            id,
+            revision: 1,
+            render,
+            handleInput() { },
+            invalidate() { },
+            update() { },
+            setExpanded() { },
+            setOutputPad() { },
+            setHideThinkingBlock() { },
+            setMermaidRenderingMode() { },
+            setImagePresentation() { },
+            ...(dispose === undefined ? {} : { dispose }),
+        };
+        this.#ports.document.appendAnchored(id, component, this.#ports.transcriptLength());
+        this.#ports.invalidate();
+        return id;
+    }
+}
+/** "Share URL: <url>" with the URL made clickable; other share wordings pass through unchanged. */
+function linkShareUrl(message) {
+    const match = /^Share URL: (\S+)$/.exec(message);
+    return match === null ? message : `Share URL: ${piShellHyperlink(match[1])}`;
+}

package/dist/app/session-shell/workflow-router.d.ts

@@ -0,0 +1,25 @@
+import type { OwnedUiCommandResult, OwnedUiWorkflowRequest } from "../../contracts/owned-ui/index.js";
+/** The owned selectors a workflow can open in place of asking the engine to choose. */
+export interface WorkflowSelectors {
+    showScopedModelsSelector(): void;
+    showModelsDialog(initialQuery?: string): void;
+    showModelSelector(initialSearchInput?: string): void;
+    showForkSelector(): void;
+    showThinkingSelector(): Promise<void>;
+    showTrustSelector(): void;
+    showSettingsSelector(): void;
+    showSessionSelector(): Promise<void>;
+    showLoginAuthTypeSelector(): void;
+    showLoginMethodSelector(providerReference: string): void;
+    showLogoutSelector(): Promise<void>;
+    showTreeSelector(): Promise<void>;
+}
+/**
+ * Opens the owned selector a workflow request asks for when the user has not chosen yet. Returns
+ * the command result when a selector handled the request, settling once an asynchronous selector
+ * has opened, or undefined when the request goes to the engine. The decision itself is synchronous,
+ * so a request that goes to the engine reaches it in the same turn.
+ */
+export declare function openWorkflowSelector(request: OwnedUiWorkflowRequest, selectors: WorkflowSelectors, options: {
+    readonly residentTab: boolean;
+}): OwnedUiCommandResult | Promise<OwnedUiCommandResult> | undefined;

package/dist/app/session-shell/workflow-router.js

@@ -0,0 +1,39 @@
+const unchosen = (request) => request.selection === undefined && request.confirmed === undefined;
+const unchosenBare = (request) => unchosen(request) && request.argument.trim().length === 0;
+// Invariant: the routes are checked in this order, matching the order the workflows were introduced.
+const SELECTOR_ROUTES = [
+    { command: "scoped-models", pending: unchosen, open: selectors => selectors.showScopedModelsSelector() },
+    { command: "models", pending: request => request.selection === undefined, open: (selectors, request) => selectors.showModelsDialog(request.argument.trim() || undefined) },
+    { command: "model", pending: unchosenBare, open: selectors => selectors.showModelSelector() },
+    { command: "fork", pending: unchosen, open: selectors => selectors.showForkSelector() },
+    { command: "thinking", pending: request => request.selection === undefined && request.argument.trim().length === 0, open: selectors => selectors.showThinkingSelector() },
+    { command: "trust", pending: unchosen, open: selectors => selectors.showTrustSelector() },
+    { command: "settings", pending: unchosen, open: selectors => selectors.showSettingsSelector() },
+    { command: "resume", pending: unchosenBare, open: selectors => selectors.showSessionSelector() },
+    {
+        command: "login",
+        pending: unchosen,
+        open: (selectors, request) => request.argument.trim().length === 0
+            ? selectors.showLoginAuthTypeSelector()
+            : selectors.showLoginMethodSelector(request.argument),
+    },
+    { command: "logout", pending: unchosen, open: selectors => selectors.showLogoutSelector() },
+    { command: "tree", pending: unchosenBare, open: selectors => selectors.showTreeSelector() },
+];
+/**
+ * Opens the owned selector a workflow request asks for when the user has not chosen yet. Returns
+ * the command result when a selector handled the request, settling once an asynchronous selector
+ * has opened, or undefined when the request goes to the engine. The decision itself is synchronous,
+ * so a request that goes to the engine reaches it in the same turn.
+ */
+export function openWorkflowSelector(request, selectors, options) {
+    const route = SELECTOR_ROUTES.find(candidate => candidate.command === request.command && candidate.pending(request));
+    if (route === undefined)
+        return undefined;
+    if (route.command === "settings" && options.residentTab) {
+        return { outcome: "rejected", diagnostic: "Settings is available from the global Settings tab." };
+    }
+    const completed = { outcome: "completed", diagnostic: null };
+    const opened = route.open(selectors, request);
+    return opened instanceof Promise ? opened.then(() => completed) : completed;
+}

package/dist/composition/owned-ui.d.ts

@@ -1,32 +1,16 @@
 import type { AvailableRelease, StartupReleaseCheckOptions } from "../foundation/release/latest-release.js";
 import type { NativeProcessIdentity } from "../foundation/lifecycle/model.js";
 import type { SessionSelection } from "../foundation/lifecycle/session-selection.js";
-import { type PiEngineHostOptions, type PiEngineSessionRequest } from "../integrations/pi/engine/host.js";
-import { type PiSessionPresenterBackend } from "../integrations/pi/session-presenters/index.js";
+import { type PiEngineHostOptions } from "../integrations/pi/engine/host.js";
 import type { PiProjectTrustPreflightPrompt } from "../integrations/pi/engine/project-trust-preflight.js";
 import type { PiSessionForkPrompt } from "../integrations/pi/engine/session-selection.js";
 import { OwnedSettingsManager } from "../ui/settings/manager.js";
 import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
-import type { AgentSettingsPort } from "../contracts/agent-engine/index.js";
-import type { OwnedUiPromptSuggestionGeneratorPort, UiAccentColor } from "../contracts/owned-ui/index.js";
 import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
 import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
-import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
-/**
- * The session backend composition wires: the owned-UI port, the prompt-suggestion generator, and
- * the agent settings port. `settingsPort` stays outside the owned-UI contract because its type
- * belongs to the agent-engine contracts, which the owned-UI contract may not import.
- */
-export interface ComposedSessionBackend extends PiSessionPresenterBackend, OwnedUiPromptSuggestionGeneratorPort {
-    settingsPort(): AgentSettingsPort | null;
-    generateResidentTabName(instruction: string, maxTokens: number, signal: AbortSignal): Promise<string | null>;
-}
-/** The process-level engine host as composition drives it: sessions, the live accent, and disposal. */
-export interface ComposedEngineHost {
-    create(request: PiEngineSessionRequest): Promise<ComposedSessionBackend>;
-    setAccentColor(color: UiAccentColor): void;
-    dispose(): Promise<void>;
-}
+import type { ComposedEngineHost } from "./session-backend.js";
+export type { ComposedEngineHost, ComposedSessionBackend } from "./session-backend.js";
+export { bindResidentTabBridge, correlateResidentTabSubmission } from "./resident-tab-bridge.js";
 export interface OwnedUiCompositionOptions {
     readonly cwd?: string;
     readonly terminal?: PresentationTerminalPort;
@@ -85,8 +69,5 @@ export declare function residentStartupPresentation(resident: boolean, fallbackN
 };
 export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
 export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;
-export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session" | "workflows" | "generateResidentTabName">, recovery?: Pick<ResidentTabRecovery, "settled"> | null, options?: {
-    readonly autoName?: boolean;
-    readonly openRoute?: (route: "settings") => void;
-}): Promise<() => void>;
-export declare function correlateResidentTabSubmission(recovery: Pick<ResidentTabRecovery, "correlated" | "settled">, backend: Pick<ComposedSessionBackend, "identity" | "session">, submissionId: string, entryId: string): Promise<void>;
+/** Rereads the shared settings document whenever its stat changes; returns the stop. */
+export declare function watchSharedSettings(settings: Pick<OwnedSettingsManager, "file" | "refresh">): () => void;