@timurproko/a1 0.1.8-dev.ece8cef → 0.2.0

package/dist/contracts/presentation/index.d.ts

@@ -0,0 +1,117 @@
+export type PresentationRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
+export interface SemanticShortcutHint {
+    readonly key?: string;
+    readonly action: string;
+    readonly actionFirst?: boolean;
+}
+export interface ShortcutHintRoles {
+    key(label: string): string;
+    action(name: string): string;
+}
+/** Applies the common display casing to each named key and letter in a shortcut label. */
+export declare function displayShortcutKeyLabel(label: string): string;
+/** Renders the canonical semantic shortcut row independently of either presentation framework. */
+export declare function renderSemanticShortcutHints(entries: readonly SemanticShortcutHint[], roles: ShortcutHintRoles, indent?: number): string;
+export interface PresentationComponentPort {
+    render(width: number): readonly string[];
+    invalidate(): void;
+    handleInput?(data: string): void;
+    setFocused?(focused: boolean): void;
+    dispose?(): void;
+}
+/** A painted input surface in terminal coordinates (one-based, inclusive bounds). */
+export interface PresentationPointerSurface {
+    readonly component: PresentationComponentPort;
+    readonly columnStart: number;
+    readonly columnEnd: number;
+    readonly rowStart: number;
+    readonly rowEnd: number;
+}
+export interface PresentationEditorPort extends PresentationComponentPort {
+    getText(): string;
+    setText(text: string): void;
+    submit(): Promise<void> | void;
+}
+export interface PresentationSelectorItem {
+    readonly id: string;
+    readonly label: string;
+    readonly detail?: string;
+}
+export interface PresentationSelectorPort extends PresentationComponentPort {
+    setItems(items: readonly PresentationSelectorItem[]): void;
+    readonly selectedId: string | null;
+}
+export interface PresentationDialogPort extends PresentationComponentPort {
+    readonly dialogId: string;
+    close(outcome: "accepted" | "cancelled"): void;
+}
+export interface PresentationExtensionUiPort {
+    mount(slot: PresentationContributionSlot, component: PresentationComponentPort): () => void;
+}
+export type PresentationContributionSlot = "transcript" | "tool" | "editor" | "status" | "dialog" | "overlay";
+export type PresentationFocusTarget = "transcript" | "editor" | "dialog" | "overlay" | "status";
+export interface PresentationFocusPort {
+    readonly focused: PresentationFocusTarget;
+    focus(target: PresentationFocusTarget): void;
+}
+export interface PresentationTerminalPort {
+    readonly columns: number;
+    readonly rows: number;
+    readonly enhancedKeyboard: boolean;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    write(data: string): void;
+    moveBy(lines: number): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+    setProgress(active: boolean): void;
+    showCursor(): void;
+    hideCursor(): void;
+}
+export type PresentationLayoutNode = {
+    readonly type: "component";
+    readonly component: PresentationComponentPort;
+} | {
+    readonly type: "stack";
+    readonly direction: "vertical" | "horizontal";
+    readonly children: readonly PresentationLayoutNode[];
+    readonly gap?: number;
+} | {
+    readonly type: "scroll";
+    readonly id: string;
+    readonly child: PresentationLayoutNode;
+    readonly follow: "none" | "end";
+};
+export interface PresentationOverlayOptions {
+    readonly anchor: "center" | "top" | "bottom";
+    readonly width?: number | `${number}%`;
+    readonly modal: boolean;
+}
+export interface PresentationOverlayHandle {
+    readonly visible: boolean;
+    hide(): void;
+    show(): void;
+    focus(): void;
+    dispose(): void;
+}
+export interface OwnedUiApplicationPort {
+    readonly disposed: boolean;
+    start(): void;
+    flush(): Promise<void>;
+    waitUntilStopped(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface PresentationRuntimePort {
+    readonly state: PresentationRuntimeState;
+    readonly terminal: PresentationTerminalPort;
+    start(): void;
+    render(force?: boolean): void;
+    showOverlay(component: PresentationComponentPort, options: PresentationOverlayOptions): PresentationOverlayHandle;
+    stop(): Promise<void>;
+}
+export declare function assertPresentationComponent(component: PresentationComponentPort): void;
+export declare function assertPresentationRuntime(runtime: PresentationRuntimePort): void;
+export declare function probePresentationLifecycle(runtime: PresentationRuntimePort): Promise<void>;

package/dist/contracts/presentation/index.js

@@ -0,0 +1,68 @@
+const SHORTCUT_KEY_NAMES = Object.freeze({
+    alt: "Alt", backspace: "Backspace", cmd: "Cmd", ctrl: "Ctrl", delete: "Delete", down: "Down", end: "End",
+    enter: "Enter", esc: "Esc", escape: "Escape", home: "Home", insert: "Insert", left: "Left", meta: "Meta",
+    option: "Option", pagedown: "PageDown", pageup: "PageUp", pgdn: "PgDn", pgup: "PgUp", return: "Return",
+    right: "Right", shift: "Shift", space: "Space", tab: "Tab", up: "Up",
+});
+/** Applies the common display casing to each named key and letter in a shortcut label. */
+export function displayShortcutKeyLabel(label) {
+    if (label === "/")
+        return label;
+    return label.split("/").map(chord => chord.split("+").map(part => {
+        const named = SHORTCUT_KEY_NAMES[part.toLowerCase()];
+        if (named !== undefined)
+            return named;
+        return /^\p{L}$/u.test(part) ? part.toUpperCase() : part;
+    }).join("+")).join("/");
+}
+/** Renders the canonical semantic shortcut row independently of either presentation framework. */
+export function renderSemanticShortcutHints(entries, roles, indent = 0) {
+    const rendered = entries.flatMap(entry => {
+        if (entry.key === "" || (entry.key !== undefined && entry.key.trim().length === 0))
+            return [];
+        if (entry.key === undefined)
+            return entry.action.length === 0 ? [] : [roles.action(entry.action)];
+        const key = roles.key(displayShortcutKeyLabel(entry.key));
+        const action = roles.action(entry.action);
+        return [entry.actionFirst ? `${action} ${key}` : `${key} ${action}`];
+    });
+    return `${" ".repeat(Math.max(0, indent))}${rendered.join("  ")}`;
+}
+export function assertPresentationComponent(component) {
+    requiredFunctions(component, ["render", "invalidate"], "presentation component");
+    const lines = component.render(80);
+    if (!Array.isArray(lines) || lines.some(line => typeof line !== "string" || line.includes("\n") || line.includes("\r"))) {
+        throw new TypeError("presentation component render must return newline-free string rows");
+    }
+}
+export function assertPresentationRuntime(runtime) {
+    requiredFunctions(runtime, ["start", "render", "showOverlay", "stop"], "presentation runtime");
+    if (!new Set(["idle", "running", "stopping", "stopped", "failed"]).has(runtime.state))
+        throw new TypeError("presentation runtime state is invalid");
+    const terminal = runtime.terminal;
+    requiredFunctions(terminal, ["start", "stop", "drainInput", "write", "moveBy", "clearLine", "clearFromCursor", "clearScreen", "setTitle", "setProgress", "showCursor", "hideCursor"], "presentation terminal");
+    if (!Number.isSafeInteger(terminal.columns) || terminal.columns < 1 || !Number.isSafeInteger(terminal.rows) || terminal.rows < 1)
+        throw new TypeError("presentation terminal geometry is invalid");
+}
+export async function probePresentationLifecycle(runtime) {
+    assertPresentationRuntime(runtime);
+    if (runtime.state !== "idle")
+        throw new TypeError("presentation runtime must begin idle");
+    runtime.start();
+    if (runtime.state !== "running")
+        throw new TypeError("presentation runtime did not enter running state");
+    runtime.render(true);
+    await runtime.stop();
+    if (runtime.state !== "stopped")
+        throw new TypeError("presentation runtime did not enter stopped state");
+    await runtime.stop();
+    if (runtime.state !== "stopped")
+        throw new TypeError("presentation runtime stop is not idempotent");
+}
+function requiredFunctions(value, names, label) {
+    if (!value)
+        throw new TypeError(`${label} is required`);
+    for (const name of names)
+        if (typeof value[name] !== "function")
+            throw new TypeError(`${label} requires ${name}`);
+}

package/dist/features/launch/development-launch.js

@@ -0,0 +1,36 @@
+import { createHash, randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releaseId, source = process.env, temporaryDirectory = tmpdir()) {
+    const checkoutId = createHash("sha256").update(resolve(canonicalPackageRoot).toLowerCase()).digest("hex").slice(0, 16);
+    const selectedInstanceId = source[PRODUCT_IDENTITY.environment.developmentInstanceId];
+    const instanceId = selectedInstanceId
+        ? createHash("sha256").update(selectedInstanceId).digest("hex").slice(0, 16)
+        : randomUUID().replaceAll("-", "").slice(0, 16);
+    const checkoutRoot = resolve(temporaryDirectory, PRODUCT_IDENTITY.state.developmentDirectory, checkoutId);
+    const selectedDevelopmentRoot = source[PRODUCT_IDENTITY.environment.developmentRoot];
+    const developmentRoot = resolve(selectedDevelopmentRoot
+        ?? join(checkoutRoot, releaseId, "instances", instanceId));
+    // Rationale: runtime/data remain instance-isolated, but product settings are user
+    // preferences and must survive a fresh local launch (and a rebuilt candidate).
+    // An explicit development root retains its historical self-contained policy.
+    const persistentConfigDir = selectedDevelopmentRoot
+        ? join(developmentRoot, "config")
+        : join(checkoutRoot, "config");
+    const dataDir = resolve(source[PRODUCT_IDENTITY.environment.dataDir] ?? join(developmentRoot, "data"));
+    return {
+        checkoutId,
+        releaseId,
+        instanceId,
+        developmentRoot,
+        environment: {
+            ...source,
+            [PRODUCT_IDENTITY.environment.developmentInstanceId]: instanceId,
+            [PRODUCT_IDENTITY.environment.configDir]: resolve(source[PRODUCT_IDENTITY.environment.configDir] ?? persistentConfigDir),
+            [PRODUCT_IDENTITY.environment.dataDir]: dataDir,
+            [PRODUCT_IDENTITY.environment.runtimeDir]: resolve(source[PRODUCT_IDENTITY.environment.runtimeDir] ?? join(developmentRoot, "runtime")),
+            [PRODUCT_IDENTITY.environment.databasePath]: resolve(source[PRODUCT_IDENTITY.environment.databasePath] ?? join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
+        },
+    };
+}

package/dist/features/launch/index.d.ts

@@ -0,0 +1,14 @@
+export { resolveDevelopmentLaunchEnvironment } from "./development-launch.js";
+export type { DevelopmentLaunchEnvironment } from "./development-launch.js";
+export { PI_PROFILE_RESOURCE_DIRECTORIES, initializeProductProfile } from "./initialize-profile.js";
+export type { InitializedProfile } from "./initialize-profile.js";
+export { interactiveLaunchIntent, parseSessionSelection } from "./intent.js";
+export type { InteractiveLaunchIntent, LaunchIntent, LaunchProfileId, SessionSelection } from "./intent.js";
+export { configurationRootForProfile, resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "./profile-paths.js";
+export type { LaunchProfilePathOptions, LaunchProfilePaths } from "./profile-paths.js";
+export { prepareInteractiveLaunch } from "./prepare-launch.js";
+export type { PrepareInteractiveLaunchOptions, PreparedInteractiveLaunch } from "./prepare-launch.js";
+export { updateSessionRepositoryContext } from "./session-context.js";
+export type { SessionContextRequest } from "./session-context.js";
+export { runSelectedInteractiveRuntime, selectInteractiveRuntime } from "./runtime-selection.js";
+export type { InteractiveRuntimeRunners, InteractiveRuntimeSelection, OwnedUiProfileId } from "./runtime-selection.js";

package/dist/features/launch/index.js

@@ -0,0 +1,7 @@
+export { resolveDevelopmentLaunchEnvironment } from "./development-launch.js";
+export { PI_PROFILE_RESOURCE_DIRECTORIES, initializeProductProfile } from "./initialize-profile.js";
+export { interactiveLaunchIntent, parseSessionSelection } from "./intent.js";
+export { configurationRootForProfile, resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "./profile-paths.js";
+export { prepareInteractiveLaunch } from "./prepare-launch.js";
+export { updateSessionRepositoryContext } from "./session-context.js";
+export { runSelectedInteractiveRuntime, selectInteractiveRuntime } from "./runtime-selection.js";

package/dist/features/launch/intent.d.ts

@@ -0,0 +1,12 @@
+import { type SessionSelection } from "../../foundation/lifecycle/index.js";
+import type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
+export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
+export type { SessionSelection } from "../../foundation/lifecycle/index.js";
+export type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
+export interface InteractiveLaunchIntent {
+    readonly kind: "interactive";
+    readonly profileId: LaunchProfileId;
+    readonly sessionSelection?: SessionSelection;
+}
+export type LaunchIntent = InteractiveLaunchIntent;
+export declare function interactiveLaunchIntent(profileId: LaunchProfileId, sessionSelection?: SessionSelection): InteractiveLaunchIntent;

package/dist/features/launch/intent.js

@@ -0,0 +1,8 @@
+import { sessionSelectionArguments } from "../../foundation/lifecycle/index.js";
+export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
+export function interactiveLaunchIntent(profileId, sessionSelection) {
+    if (sessionSelection !== undefined && profileId !== "a1")
+        throw new Error("session selection requires the normal A1 profile");
+    sessionSelectionArguments(sessionSelection);
+    return Object.freeze({ kind: "interactive", profileId, ...(sessionSelection === undefined ? {} : { sessionSelection }) });
+}

package/dist/features/launch/prepare-launch.d.ts

@@ -0,0 +1,11 @@
+import { type LaunchProfilePathOptions } from "./profile-paths.js";
+import { initializeProductProfile } from "./initialize-profile.js";
+import type { InteractiveLaunchIntent } from "./intent.js";
+export interface PreparedInteractiveLaunch {
+    readonly environment: NodeJS.ProcessEnv;
+    readonly configurationRoot: string | null;
+}
+export interface PrepareInteractiveLaunchOptions extends LaunchProfilePathOptions {
+    readonly initializeProfile?: typeof initializeProductProfile;
+}
+export declare function prepareInteractiveLaunch(intent: InteractiveLaunchIntent, environment?: NodeJS.ProcessEnv, options?: PrepareInteractiveLaunchOptions): Promise<PreparedInteractiveLaunch>;

package/dist/features/launch/prepare-launch.js

@@ -0,0 +1,14 @@
+import { configurationRootForProfile, resolveLaunchProfilePaths } from "./profile-paths.js";
+import { initializeProductProfile } from "./initialize-profile.js";
+export async function prepareInteractiveLaunch(intent, environment = process.env, options = {}) {
+    const paths = resolveLaunchProfilePaths({ ...options, environment });
+    const configurationRoot = configurationRootForProfile(intent.profileId, paths);
+    if (configurationRoot !== null)
+        await (options.initializeProfile ?? initializeProductProfile)(configurationRoot);
+    const childEnvironment = { ...environment };
+    if (configurationRoot === null)
+        delete childEnvironment.PI_CODING_AGENT_DIR;
+    else
+        childEnvironment.PI_CODING_AGENT_DIR = configurationRoot;
+    return Object.freeze({ environment: childEnvironment, configurationRoot });
+}

package/dist/features/launch/profile-paths.d.ts

@@ -0,0 +1,16 @@
+import type { LaunchProfileId } from "./intent.js";
+export interface LaunchProfilePaths {
+    readonly home: string;
+    readonly managedStateRoot: string;
+    readonly agentProfile: string;
+}
+export interface LaunchProfilePathOptions {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly home?: string;
+    readonly readHome?: () => string;
+    readonly platform?: NodeJS.Platform;
+}
+export declare function resolveLaunchProfilePaths(options?: LaunchProfilePathOptions): LaunchProfilePaths;
+/** Select history storage without relocating control state or probing former stores. */
+export declare function resolvePromptHistoryDataDir(options?: LaunchProfilePathOptions): string;
+export declare function configurationRootForProfile(profileId: LaunchProfileId, paths: LaunchProfilePaths): string | null;

package/dist/features/launch/profile-paths.js

@@ -0,0 +1,36 @@
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { resolveProductPaths } from "../../foundation/lifecycle/paths.js";
+export function resolveLaunchProfilePaths(options = {}) {
+    const environment = options.environment ?? process.env;
+    const path = options.platform === "win32" || (options.platform === undefined && process.platform === "win32") ? win32 : posix;
+    const selectedHome = options.home ?? environment[PRODUCT_IDENTITY.environment.profileHome] ?? options.readHome?.() ?? homedir();
+    const home = validateAbsolutePath(selectedHome, "effective user home", path);
+    const agentProfile = path.resolve(home, PRODUCT_IDENTITY.state.piAgentProfile);
+    return Object.freeze({
+        home,
+        managedStateRoot: path.dirname(agentProfile),
+        agentProfile,
+    });
+}
+/** Select history storage without relocating control state or probing former stores. */
+export function resolvePromptHistoryDataDir(options = {}) {
+    const environment = options.environment ?? process.env;
+    const platform = options.platform ?? process.platform;
+    if (environment[PRODUCT_IDENTITY.environment.dataDir] !== undefined) {
+        return resolveProductPaths(environment, platform).dataDir;
+    }
+    const path = platform === "win32" ? win32 : posix;
+    return path.join(resolveLaunchProfilePaths(options).managedStateRoot, "data");
+}
+export function configurationRootForProfile(profileId, paths) {
+    return profileId === "a1" ? paths.agentProfile : null;
+}
+function validateAbsolutePath(value, name, path) {
+    if (value.length === 0 || value.includes("\0"))
+        throw new TypeError(`${name} is invalid`);
+    if (!path.isAbsolute(value))
+        throw new TypeError(`${name} must be absolute`);
+    return path.resolve(value);
+}

package/dist/features/launch/runtime-selection.d.ts

@@ -0,0 +1,16 @@
+import { type LaunchProfileId } from "../../foundation/lifecycle/model.js";
+/**
+ * Both interactive commands use the owned composition. Bare A1 enables product
+ * surfaces; the Pi comparison command withholds them and reads Pi's own profile.
+ */
+export type OwnedUiProfileId = LaunchProfileId;
+export interface InteractiveRuntimeSelection {
+    readonly kind: "owned-ui";
+    readonly profileId: OwnedUiProfileId;
+    readonly ownedSurfaces: "on" | "off";
+}
+export interface InteractiveRuntimeRunners {
+    readonly ownedUi: (profileId: OwnedUiProfileId, ownedSurfaces: "on" | "off") => Promise<number>;
+}
+export declare function selectInteractiveRuntime(profileId: string): InteractiveRuntimeSelection;
+export declare function runSelectedInteractiveRuntime(profileId: string, runners: InteractiveRuntimeRunners): Promise<number>;

package/dist/features/launch/runtime-selection.js

@@ -0,0 +1,13 @@
+import { assertLaunchProfileId } from "../../foundation/lifecycle/model.js";
+export function selectInteractiveRuntime(profileId) {
+    assertLaunchProfileId(profileId);
+    return Object.freeze({
+        kind: "owned-ui",
+        profileId,
+        ownedSurfaces: profileId === "a1" ? "on" : "off",
+    });
+}
+export async function runSelectedInteractiveRuntime(profileId, runners) {
+    const selection = selectInteractiveRuntime(profileId);
+    return await runners.ownedUi(selection.profileId, selection.ownedSurfaces);
+}

package/dist/features/launch/session-context.d.ts

@@ -0,0 +1,8 @@
+import { type SessionRepositoryIdentity } from "../../foundation/lifecycle/index.js";
+export type SessionContextRequest = {
+    readonly action: "link-worktree";
+    readonly path: string;
+} | {
+    readonly action: "unlink-worktree";
+};
+export declare function updateSessionRepositoryContext(identity: SessionRepositoryIdentity, request: SessionContextRequest): Promise<string | null>;

package/dist/features/launch/session-context.js

@@ -0,0 +1,8 @@
+import { clearSessionRepositoryContext, setSessionRepositoryContext, } from "../../foundation/lifecycle/index.js";
+export async function updateSessionRepositoryContext(identity, request) {
+    if (request.action === "unlink-worktree") {
+        await clearSessionRepositoryContext(identity);
+        return null;
+    }
+    return (await setSessionRepositoryContext(identity, request.path)).cwd;
+}

package/dist/features/owned-ui/index.d.ts

@@ -0,0 +1,9 @@
+export { runOwnedUi, terminateOwnedUiProcess } from "./run.js";
+export type { OwnedUiRunOptions } from "./run.js";
+export { createConsoleProjectTrustPrompt } from "./project-trust-prompt.js";
+export type { ConsoleProjectTrustPromptOptions, OwnedProjectTrustPrompt, OwnedProjectTrustPromptRequest } from "./project-trust-prompt.js";
+export { createConsoleSessionForkPrompt } from "./session-fork-prompt.js";
+export { SETTINGS_APP_ID, SETTINGS_ROUTE, SETTINGS_SHORTCUTS, SettingsApp } from "./settings-app.js";
+export { REFERENCE_SCREEN_SHORTCUTS, ReferenceScreenApp } from "./reference-screen-app.js";
+export type { ReferenceDocumentProvider, ReferenceDocumentSection, ReferenceScreenOptions } from "./reference-screen-app.js";
+export { CHANGELOG_APP_ID, CHANGELOG_ROUTE, CHANGELOG_TITLE, HOTKEYS_APP_ID, HOTKEYS_ROUTE, HOTKEYS_TITLE, } from "./reference-routes.js";

package/dist/features/owned-ui/index.js

@@ -0,0 +1,6 @@
+export { runOwnedUi, terminateOwnedUiProcess } from "./run.js";
+export { createConsoleProjectTrustPrompt } from "./project-trust-prompt.js";
+export { createConsoleSessionForkPrompt } from "./session-fork-prompt.js";
+export { SETTINGS_APP_ID, SETTINGS_ROUTE, SETTINGS_SHORTCUTS, SettingsApp } from "./settings-app.js";
+export { REFERENCE_SCREEN_SHORTCUTS, ReferenceScreenApp } from "./reference-screen-app.js";
+export { CHANGELOG_APP_ID, CHANGELOG_ROUTE, CHANGELOG_TITLE, HOTKEYS_APP_ID, HOTKEYS_ROUTE, HOTKEYS_TITLE, } from "./reference-routes.js";

package/dist/features/owned-ui/project-trust-prompt.d.ts

@@ -0,0 +1,25 @@
+import type { Readable, Writable } from "node:stream";
+export interface OwnedProjectTrustPromptRequest {
+    readonly cwd: string;
+    readonly defaultDecision: "ask" | "always" | "never";
+}
+export type OwnedProjectTrustPrompt = (request: OwnedProjectTrustPromptRequest) => Promise<boolean | null>;
+interface RawTtyInput extends Readable {
+    readonly isTTY?: boolean;
+    readonly isRaw?: boolean;
+    setRawMode?(enabled: boolean): this;
+}
+export interface ConsoleProjectTrustPromptOptions {
+    readonly input?: RawTtyInput;
+    readonly output?: Writable & {
+        readonly isTTY?: boolean;
+        readonly columns?: number;
+    };
+}
+/**
+ * Pre-resource startup selector. It uses only fixed product wording and terminal
+ * controls: no project setting, theme, extension, prompt, package, or skill is
+ * consulted before the trust result exists.
+ */
+export declare function createConsoleProjectTrustPrompt(options?: ConsoleProjectTrustPromptOptions): OwnedProjectTrustPrompt;
+export {};

package/dist/features/owned-ui/project-trust-prompt.js

@@ -0,0 +1,149 @@
+const ENTER_ALTERNATE_SCREEN = "\u001b[?1049h";
+const LEAVE_ALTERNATE_SCREEN = "\u001b[?1049l";
+const HIDE_CURSOR = "\u001b[?25l";
+const SHOW_CURSOR = "\u001b[?25h";
+const CLEAR_HOME = "\u001b[2J\u001b[H";
+const ACCENT = "\u001b[38;2;138;190;183m";
+const MUTED = "\u001b[38;2;128;128;128m";
+const DIM = "\u001b[38;2;102;102;102m";
+const RESET_FG = "\u001b[39m";
+const BOLD = "\u001b[1m";
+const RESET_BOLD = "\u001b[22m";
+/**
+ * Pre-resource startup selector. It uses only fixed product wording and terminal
+ * controls: no project setting, theme, extension, prompt, package, or skill is
+ * consulted before the trust result exists.
+ */
+export function createConsoleProjectTrustPrompt(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    return async ({ cwd }) => {
+        if (input.isTTY !== true || output.isTTY !== true) {
+            throw new Error("an interactive terminal is unavailable");
+        }
+        const wasRaw = input.isRaw === true;
+        let selected = 0;
+        let restored = false;
+        const restore = () => {
+            if (restored)
+                return;
+            restored = true;
+            input.setRawMode?.(wasRaw);
+            output.write(`${CLEAR_HOME}${SHOW_CURSOR}${LEAVE_ALTERNATE_SCREEN}`);
+        };
+        const render = () => {
+            const width = Math.max(20, output.columns ?? 80);
+            const lines = [
+                `${BOLD}${ACCENT}Trust project folder?${RESET_FG}${RESET_BOLD}`,
+                cwd,
+                "",
+                "This allows a1 to load project settings and resources, install missing project packages, and execute project extensions.",
+                "",
+                optionRow("Trust", selected === 0),
+                optionRow("Do not trust", selected === 1),
+                "",
+                `${DIM}↑/↓${MUTED} to navigate  ${DIM}Enter${MUTED} to select  ${DIM}Esc${MUTED} to cancel${RESET_FG}`,
+            ];
+            output.write(`${CLEAR_HOME}${lines.map(line => clipAnsiSafe(line, width)).join("\n")}`);
+        };
+        try {
+            output.write(`${ENTER_ALTERNATE_SCREEN}${HIDE_CURSOR}`);
+            input.setRawMode?.(true);
+            render();
+            return await new Promise((resolve, reject) => {
+                let settled = false;
+                const finish = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    restore();
+                    resolve(value);
+                };
+                const fail = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    restore();
+                    reject(error);
+                };
+                const onData = (chunk) => {
+                    const data = chunk.toString();
+                    for (let index = 0; index < data.length;) {
+                        if (data.startsWith("\u001b[A", index)) {
+                            selected = 0;
+                            index += 3;
+                            render();
+                            continue;
+                        }
+                        if (data.startsWith("\u001b[B", index) || data[index] === "\t") {
+                            selected = selected === 0 ? 1 : 0;
+                            index += data[index] === "\t" ? 1 : 3;
+                            render();
+                            continue;
+                        }
+                        const key = data[index] ?? "";
+                        index += 1;
+                        if (key === "\r" || key === "\n") {
+                            finish(selected === 0);
+                            return;
+                        }
+                        if (key === "\u001b" || key === "\u0003") {
+                            finish(null);
+                            return;
+                        }
+                        // Compatibility: retain y/n aliases for terminals or automation that cannot send
+                        // navigation keys; the visible interaction remains selector-first.
+                        if (key === "y" || key === "Y") {
+                            finish(true);
+                            return;
+                        }
+                        if (key === "n" || key === "N") {
+                            finish(false);
+                            return;
+                        }
+                    }
+                };
+                const onEnd = () => finish(null);
+                const onError = (error) => fail(error);
+                const cleanup = () => {
+                    input.off("data", onData);
+                    input.off("end", onEnd);
+                    input.off("error", onError);
+                };
+                input.on("data", onData);
+                input.once("end", onEnd);
+                input.once("error", onError);
+                input.resume();
+            });
+        }
+        finally {
+            restore();
+        }
+    };
+}
+function optionRow(label, selected) {
+    return selected
+        ? `${ACCENT}→ ${label}${RESET_FG}`
+        : `  ${label}`;
+}
+/** Avoid replaying or manufacturing control payloads while keeping fixed SGR. */
+function clipAnsiSafe(line, width) {
+    let visible = 0;
+    let output = "";
+    for (let index = 0; index < line.length && visible < width;) {
+        if (line[index] === "\u001b") {
+            const match = line.slice(index).match(/^\u001b\[[0-9;:]*m/);
+            if (match !== null) {
+                output += match[0];
+                index += match[0].length;
+                continue;
+            }
+        }
+        output += line[index];
+        index += 1;
+        visible += 1;
+    }
+    return `${output}${RESET_FG}${RESET_BOLD}`;
+}

package/dist/features/owned-ui/reference-routes.d.ts

@@ -0,0 +1,6 @@
+export declare const CHANGELOG_APP_ID = "changelog";
+export declare const CHANGELOG_ROUTE = "changelog";
+export declare const CHANGELOG_TITLE = "What's New";
+export declare const HOTKEYS_APP_ID = "hotkeys";
+export declare const HOTKEYS_ROUTE = "hotkeys";
+export declare const HOTKEYS_TITLE = "Keyboard Shortcuts";

package/dist/features/owned-ui/reference-routes.js

@@ -0,0 +1,6 @@
+export const CHANGELOG_APP_ID = "changelog";
+export const CHANGELOG_ROUTE = "changelog";
+export const CHANGELOG_TITLE = "What's New";
+export const HOTKEYS_APP_ID = "hotkeys";
+export const HOTKEYS_ROUTE = "hotkeys";
+export const HOTKEYS_TITLE = "Keyboard Shortcuts";