pi-ui-extend 0.1.1

package/dist/app/update.js

@@ -0,0 +1,315 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
+const DEFAULT_UPDATE_TIMEOUT_MS = 10_000;
+const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+export function pixUpdateUsage() {
+    return `Usage: pix update [--check] [--force]
+
+Check for or install the latest published Pix package.
+
+Options:
+  --check    Only check for an available update
+  --force    Reinstall even when Pix appears up to date
+  -h, --help Show this help
+
+Inside the TUI, /update performs the same non-mutating check.
+The bundled skills payload under skills/ is copied into ~/.agents/skills on startup.
+The pi-tools-suite payload under external/pi-tools-suite is updated with Pix and linked into ~/.pi/agent/extensions on startup.`;
+}
+export function parsePixUpdateArgs(argv) {
+    let checkOnly = false;
+    let force = false;
+    let help = false;
+    for (const arg of argv) {
+        if (arg === "--check") {
+            checkOnly = true;
+            continue;
+        }
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+            continue;
+        }
+        throw new Error(`Unknown pix update argument: ${arg}\n\n${pixUpdateUsage()}`);
+    }
+    return { checkOnly, force, help };
+}
+export async function checkPixUpdate(options = {}) {
+    const packageInfo = readPixPackageInfo(options.packageRoot);
+    const base = {
+        packageName: packageInfo.name,
+        currentVersion: packageInfo.version,
+        packageRoot: packageInfo.packageRoot,
+    };
+    if (packageInfo.private) {
+        return {
+            ...base,
+            status: "unavailable",
+            reason: "this checkout is marked private in package.json, so it cannot be updated from npm",
+        };
+    }
+    const disabledReason = versionCheckDisabledReason();
+    if (disabledReason) {
+        return { ...base, status: "skipped", reason: disabledReason };
+    }
+    try {
+        const latestVersion = await (options.fetchLatestVersion ?? fetchLatestNpmVersion)(packageInfo.name, packageInfo.version, options.timeoutMs ?? DEFAULT_UPDATE_TIMEOUT_MS);
+        if (!latestVersion) {
+            return { ...base, status: "unknown", reason: "npm registry did not return a latest version" };
+        }
+        return {
+            ...base,
+            status: isNewerPackageVersion(latestVersion, packageInfo.version) ? "newer" : "current",
+            latestVersion,
+        };
+    }
+    catch (error) {
+        return {
+            ...base,
+            status: "unknown",
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function formatPixUpdateCheck(result) {
+    const lines = [
+        "Pix update",
+        `current: ${result.packageName} v${result.currentVersion}`,
+        ...(result.latestVersion ? [`latest: ${result.latestVersion}`] : []),
+    ];
+    switch (result.status) {
+        case "current":
+            lines.push("status: up to date");
+            break;
+        case "newer":
+            lines.push("status: update available");
+            lines.push("run: pix update");
+            lines.push("restart Pix after the command completes");
+            break;
+        case "skipped":
+            lines.push(`status: check skipped (${result.reason ?? "disabled"})`);
+            break;
+        case "unavailable":
+            lines.push(`status: update unavailable (${result.reason ?? "unsupported install"})`);
+            lines.push(`source checkout: ${sourceCheckoutUpdateHint()}`);
+            break;
+        case "unknown":
+            lines.push(`status: unable to check${result.reason ? ` (${result.reason})` : ""}`);
+            lines.push("run: pix update --force to try reinstalling anyway");
+            break;
+    }
+    lines.push("scope: Pix package, renderer extensions, bundled skills copied into ~/.agents/skills, and the pi-tools-suite payload linked into ~/.pi/agent/extensions");
+    return lines.join("\n");
+}
+export function getPixSelfUpdateCommand(packageName, latestVersion, packageRoot = readPixPackageInfo().packageRoot) {
+    if (!packageRootLooksPackageManaged(packageRoot))
+        return undefined;
+    const installSpec = latestVersion ? `${packageName}@${latestVersion}` : packageName;
+    const method = detectInstallMethod(packageRoot);
+    const commandParts = method === "npm" ? configuredNpmCommand() ?? ["npm"] : undefined;
+    switch (method) {
+        case "npm": {
+            const [command = "npm", ...npmArgs] = commandParts ?? ["npm"];
+            return makeCommand(command, [...npmArgs, "install", "-g", "--ignore-scripts", "--min-release-age=0", installSpec]);
+        }
+        case "pnpm":
+            return makeCommand("pnpm", ["install", "-g", "--ignore-scripts", "--config.minimumReleaseAge=0", installSpec]);
+        case "yarn":
+            return makeCommand("yarn", ["global", "add", "--ignore-scripts", installSpec]);
+        case "bun":
+            return makeCommand("bun", ["install", "-g", "--ignore-scripts", "--minimum-release-age=0", installSpec]);
+        case "source":
+            return undefined;
+    }
+}
+export async function runPixUpdateCli(argv = process.argv.slice(2)) {
+    let options;
+    try {
+        options = parsePixUpdateArgs(argv);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    if (options.help) {
+        console.log(pixUpdateUsage());
+        return 0;
+    }
+    const check = await checkPixUpdate();
+    console.log(formatPixUpdateCheck(check));
+    if (options.checkOnly)
+        return check.status === "unavailable" ? 1 : 0;
+    if (check.status === "current" && !options.force)
+        return 0;
+    if ((check.status === "skipped" || check.status === "unavailable") && !options.force)
+        return 1;
+    const command = getPixSelfUpdateCommand(check.packageName, check.latestVersion);
+    if (!command) {
+        console.error(`pix cannot self-update this installation. ${sourceCheckoutUpdateHint()}`);
+        return 1;
+    }
+    console.log(`Updating Pix with ${command.display}...`);
+    try {
+        await runCommand(command);
+        console.log("Updated Pix. Restart any running pix sessions.");
+        return 0;
+    }
+    catch (error) {
+        console.error(`Pix update failed: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`Try running manually: ${command.display}`);
+        return 1;
+    }
+}
+function readPixPackageInfo(packageRoot = findPixPackageRoot()) {
+    const packageJsonPath = join(packageRoot, "package.json");
+    const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const name = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : "pi-ui-extend";
+    const version = typeof raw.version === "string" && raw.version.trim() ? raw.version.trim() : "0.0.0";
+    return {
+        name,
+        version,
+        private: raw.private === true,
+        packageRoot,
+    };
+}
+function findPixPackageRoot() {
+    let currentDir = dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        const packageJsonPath = join(currentDir, "package.json");
+        if (existsSync(packageJsonPath))
+            return currentDir;
+        const nextDir = dirname(currentDir);
+        if (nextDir === currentDir)
+            throw new Error("Could not find pix package.json");
+        currentDir = nextDir;
+    }
+}
+async function fetchLatestNpmVersion(packageName, currentVersion, timeoutMs) {
+    const response = await fetch(`${NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/latest`, {
+        headers: {
+            accept: "application/json",
+            "User-Agent": `pix/${currentVersion}`,
+        },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (response.status === 404)
+        return undefined;
+    if (!response.ok)
+        throw new Error(`npm registry returned ${response.status}`);
+    const data = await response.json();
+    return typeof data.version === "string" && data.version.trim() ? data.version.trim() : undefined;
+}
+function versionCheckDisabledReason() {
+    if (truthyEnv(process.env.PI_OFFLINE))
+        return "PI_OFFLINE is set";
+    if (truthyEnv(process.env.PI_SKIP_VERSION_CHECK))
+        return "PI_SKIP_VERSION_CHECK is set";
+    if (truthyEnv(process.env.PIX_SKIP_VERSION_CHECK))
+        return "PIX_SKIP_VERSION_CHECK is set";
+    return undefined;
+}
+function truthyEnv(value) {
+    if (!value)
+        return false;
+    return !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function packageRootLooksPackageManaged(packageRoot) {
+    return normalizePath(packageRoot).includes("/node_modules/");
+}
+function detectInstallMethod(packageRoot) {
+    const normalized = normalizePath(`${packageRoot}\0${process.execPath || ""}`);
+    if (!packageRootLooksPackageManaged(packageRoot))
+        return "source";
+    if (normalized.includes("/.pnpm/") || normalized.includes("/pnpm/"))
+        return "pnpm";
+    if (normalized.includes("/.yarn/") || normalized.includes("/yarn/"))
+        return "yarn";
+    if (process.versions.bun || normalized.includes("/.bun/") || normalized.includes("/install/global/node_modules/"))
+        return "bun";
+    return "npm";
+}
+function configuredNpmCommand() {
+    try {
+        return SettingsManager.create(process.cwd(), getAgentDir()).getNpmCommand();
+    }
+    catch {
+        return undefined;
+    }
+}
+function makeCommand(command, args) {
+    return {
+        command,
+        args,
+        display: [command, ...args].map(shellDisplayQuote).join(" "),
+    };
+}
+function shellDisplayQuote(value) {
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value))
+        return value;
+    return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function normalizePath(pathValue) {
+    return resolve(pathValue).toLowerCase().replace(/\\/g, "/");
+}
+function sourceCheckoutUpdateHint() {
+    return "from a source checkout, run `git pull && npm install --ignore-scripts && npm run build:pix && npm run link:pix`";
+}
+function isNewerPackageVersion(candidateVersion, currentVersion) {
+    const comparison = comparePackageVersions(candidateVersion, currentVersion);
+    if (comparison !== undefined)
+        return comparison > 0;
+    return candidateVersion.trim() !== currentVersion.trim();
+}
+function comparePackageVersions(leftVersion, rightVersion) {
+    const left = parsePackageVersion(leftVersion);
+    const right = parsePackageVersion(rightVersion);
+    if (!left || !right)
+        return undefined;
+    if (left.major !== right.major)
+        return left.major - right.major;
+    if (left.minor !== right.minor)
+        return left.minor - right.minor;
+    if (left.patch !== right.patch)
+        return left.patch - right.patch;
+    if (left.prerelease === right.prerelease)
+        return 0;
+    if (!left.prerelease)
+        return 1;
+    if (!right.prerelease)
+        return -1;
+    return left.prerelease.localeCompare(right.prerelease);
+}
+function parsePackageVersion(version) {
+    const match = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/u);
+    if (!match)
+        return undefined;
+    return {
+        major: Number.parseInt(match[1] ?? "0", 10),
+        minor: Number.parseInt(match[2] ?? "0", 10),
+        patch: Number.parseInt(match[3] ?? "0", 10),
+        ...(match[4] === undefined ? {} : { prerelease: match[4] }),
+    };
+}
+async function runCommand(command) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(command.command, command.args, { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (code, signal) => {
+            if (code === 0) {
+                resolvePromise();
+            }
+            else if (signal) {
+                reject(new Error(`${command.display} terminated by signal ${signal}`));
+            }
+            else {
+                reject(new Error(`${command.display} exited with code ${code ?? "unknown"}`));
+            }
+        });
+    });
+}

package/dist/app/voice-controller.d.ts

@@ -0,0 +1,52 @@
+import { type DictationConfig } from "../config.js";
+export type VoiceLanguage = string;
+export type VoiceInputState = "idle" | "installing" | "downloading" | "loading" | "listening";
+export type AppVoiceControllerHost = {
+    insertTranscript(text: string): void;
+    setPartialTranscript(text: string | undefined): void;
+    addSystemMessage(message: string): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    render(): void;
+};
+export declare class AppVoiceController {
+    private readonly host;
+    private readonly modelDefinitions;
+    private readonly languages;
+    private language;
+    private state;
+    private readonly modelCache;
+    private audioProcess;
+    private recognizer;
+    private progressMessage;
+    private progressFrame;
+    private progressTimer;
+    private lastSystemProgressMessage;
+    private partialTranscript;
+    private startGeneration;
+    constructor(host: AppVoiceControllerHost, dictationConfig: DictationConfig);
+    statusWidgetText(): string;
+    showLanguageSwitcher(): boolean;
+    statusWidgetActive(): boolean;
+    progressOverlayText(): string | undefined;
+    toggleRecording(): Promise<void>;
+    toggleLanguage(): Promise<void>;
+    stopRecording(): Promise<void>;
+    dispose(): Promise<void>;
+    private startRecording;
+    private cachedModel;
+    private nextLanguage;
+    private initialLanguage;
+    private saveLanguageSelection;
+    private modelDefinition;
+    private installAndLoadVosk;
+    private bindAudioProcess;
+    private cleanupRecognizer;
+    private setProgressMessage;
+    private clearProgressMessage;
+    private addProgressSystemMessage;
+    private emitTranscript;
+    private emitPartialTranscript;
+    private clearPartialTranscript;
+    private isCurrentStart;
+    private isCurrentAudioProcess;
+}