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

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

@@ -0,0 +1,12 @@
+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 { runSelectedInteractiveRuntime, selectInteractiveRuntime } from "./runtime-selection.js";
+export type { InteractiveRuntimeRunners, InteractiveRuntimeSelection, OwnedUiProfileId } from "./runtime-selection.js";

package/dist/features/launch/index.js

@@ -0,0 +1,6 @@
+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 { 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/owned-ui/index.d.ts

@@ -0,0 +1,6 @@
+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";

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

@@ -0,0 +1,4 @@
+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";

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}  ↑/↓ to navigate · Enter to select · Esc 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/run.d.ts

@@ -0,0 +1,17 @@
+import type { OwnedUiApplicationPort } from "../../contracts/presentation/index.js";
+import type { OwnedSettingsManager } from "../../ui/settings/index.js";
+export interface OwnedUiRunOptions {
+    readonly application: OwnedUiApplicationPort;
+    /**
+     * Resolved once before the application starts, so every surface reads the same
+     * values for the life of the session. Omitted when the caller runs without settings.
+     */
+    readonly settings?: OwnedSettingsManager;
+}
+/**
+ * Completes the interactive executable only after runOwnedUi has restored its terminal.
+ * Extensions are untrusted process guests and can retain servers or timers after session
+ * shutdown, so assigning exitCode alone cannot guarantee return to the invoking shell.
+ */
+export declare function terminateOwnedUiProcess(code: number): Promise<never>;
+export declare function runOwnedUi(options: OwnedUiRunOptions): Promise<number>;

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

@@ -0,0 +1,64 @@
+import { markStartupPhase } from "../../foundation/startup/startup-runtime.js";
+import { boundedCleanup } from "../../foundation/terminal-cleanup/terminal-reset.js";
+const PROCESS_OUTPUT_FLUSH_TIMEOUT_MS = 250;
+/**
+ * Completes the interactive executable only after runOwnedUi has restored its terminal.
+ * Extensions are untrusted process guests and can retain servers or timers after session
+ * shutdown, so assigning exitCode alone cannot guarantee return to the invoking shell.
+ */
+export async function terminateOwnedUiProcess(code) {
+    process.exitCode = code;
+    await Promise.all([flushProcessOutput(process.stdout), flushProcessOutput(process.stderr)]);
+    return process.exit(code);
+}
+export async function runOwnedUi(options) {
+    const { application, settings } = options;
+    let failed = false;
+    let originalFailure;
+    try {
+        if (settings)
+            await settings.load();
+        application.start();
+        await application.flush();
+        await markStartupPhase(process.env, "first-input-ready-render");
+        if (!application.disposed)
+            await application.waitUntilStopped();
+        return 0;
+    }
+    catch (error) {
+        failed = true;
+        originalFailure = error;
+        throw error;
+    }
+    finally {
+        try {
+            await boundedCleanup(() => application.dispose(), 2500);
+        }
+        catch (error) {
+            if (failed)
+                throw new AggregateError([originalFailure, error], "Owned UI run and cleanup failed", { cause: originalFailure });
+            throw error;
+        }
+    }
+}
+async function flushProcessOutput(stream) {
+    if (stream.destroyed || !stream.writable)
+        return;
+    await new Promise(resolve => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(finish, PROCESS_OUTPUT_FLUSH_TIMEOUT_MS);
+        try {
+            stream.write("", finish);
+        }
+        catch {
+            finish();
+        }
+    });
+}

package/dist/features/owned-ui/session-fork-prompt.d.ts

@@ -0,0 +1,8 @@
+import type { Readable, Writable } from "node:stream";
+/** Pre-resource, line-mode confirmation matching Pi's cross-project CLI fork decision. */
+export declare function createConsoleSessionForkPrompt(options?: {
+    readonly input?: Readable;
+    readonly output?: Writable;
+}): (request: {
+    readonly sourceCwd: string;
+}) => Promise<boolean>;

package/dist/features/owned-ui/session-fork-prompt.js

@@ -0,0 +1,34 @@
+import { createInterface } from "node:readline";
+/** Pre-resource, line-mode confirmation matching Pi's cross-project CLI fork decision. */
+export function createConsoleSessionForkPrompt(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    return async ({ sourceCwd }) => {
+        output.write(`Session found in different project: ${sourceCwd}\n`);
+        const wasFlowing = input.readableFlowing;
+        const readline = createInterface({ input, output });
+        try {
+            return await new Promise((resolve, reject) => {
+                const finish = (accepted) => { cleanup(); resolve(accepted); };
+                const cancel = () => finish(false);
+                const fail = (error) => { cleanup(); reject(error); };
+                const cleanup = () => {
+                    readline.off("close", cancel);
+                    readline.off("SIGINT", cancel);
+                    input.off("error", fail);
+                };
+                readline.once("close", cancel);
+                readline.once("SIGINT", cancel);
+                input.once("error", fail);
+                readline.question("Fork this session into current directory? [y/N] ", answer => {
+                    finish(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+                });
+            });
+        }
+        finally {
+            readline.close();
+            if (wasFlowing !== true)
+                input.pause();
+        }
+    };
+}

package/dist/features/owned-ui/settings-app.d.ts

@@ -0,0 +1,21 @@
+import type { AppHostServices, UiApp } from "../../ui/apps/index.js";
+import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../ui/components/index.js";
+import type { OwnedSettingsManager } from "../../ui/settings/index.js";
+export { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
+type Action = "move-up" | "move-down" | "block-up" | "block-down" | "first" | "last" | "page-up" | "page-down" | "previous-value" | "next-value" | "activate" | "open-filter" | "close" | "part-previous" | "part-next" | "part-change";
+export declare const SETTINGS_SHORTCUTS: ShortcutRegistry<Action>;
+/**
+ * The settings screen. Rows, sticky headers, scrolling, and the keymap come from
+ * the shared component layer; what belongs to settings is which sections exist,
+ * how a value is shown, and where an accepted change is routed.
+ */
+export declare class SettingsApp implements UiApp {
+    #private;
+    readonly id = "settings";
+    constructor(session: OwnedSettingsManager);
+    onActivate(host: AppHostServices): void;
+    onClose(_host: AppHostServices): void;
+    render(rect: PaneRect, host: AppHostServices): readonly string[];
+    onInput(data: string, host: AppHostServices): PaneInputResult;
+    onMouse(event: PaneMouseEvent, _host: AppHostServices): PaneInputResult;
+}