pi-ui-extend 0.1.1

package/dist/app/shell-command.js

@@ -0,0 +1,176 @@
+import { spawn } from "node:child_process";
+export function bangShellCommandFromInput(text) {
+    const trimmed = text.trimStart();
+    if (!trimmed.startsWith("!"))
+        return undefined;
+    const interactive = trimmed.startsWith("!!");
+    return { command: trimmed.slice(interactive ? 2 : 1).trim(), interactive };
+}
+export function shellCommandFromBangInput(text) {
+    return bangShellCommandFromInput(text)?.command;
+}
+export function runChatShellCommand(command, cwd, handlers = {}) {
+    let child;
+    try {
+        child = spawn(command, {
+            cwd,
+            env: process.env,
+            shell: shellOption(),
+            stdio: "pipe",
+            ...(process.platform === "win32" ? {} : { detached: true }),
+        });
+    }
+    catch (error) {
+        return failedChatShellCommand(error, handlers);
+    }
+    let settled = false;
+    let resolveDone = () => { };
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
+    const settle = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        handlers.onSettled?.(result);
+        resolveDone(result);
+    };
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => handlers.onOutput?.(chunk, "stdout"));
+    child.stderr.on("data", (chunk) => handlers.onOutput?.(chunk, "stderr"));
+    child.once("error", (error) => {
+        settle({ exitCode: null, signal: null, error: error instanceof Error ? error.message : String(error) });
+    });
+    child.once("close", (exitCode, signal) => {
+        settle({ exitCode, signal });
+    });
+    return {
+        ...(child.pid === undefined ? {} : { pid: child.pid }),
+        done,
+        writeInput: (input) => {
+            if (child.stdin.destroyed || !child.stdin.writable)
+                return false;
+            try {
+                child.stdin.write(input);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        interrupt: () => signalChildProcess(child, "SIGINT"),
+        kill: (signal = "SIGTERM") => signalChildProcess(child, signal),
+        endInput: () => {
+            try {
+                if (!child.stdin.destroyed && child.stdin.writable)
+                    child.stdin.end();
+            }
+            catch {
+                // Closing stdin is best-effort during shell teardown.
+            }
+        },
+    };
+}
+export async function runInteractiveShellCommand(command, cwd) {
+    const ignoreSigint = () => { };
+    process.on("SIGINT", ignoreSigint);
+    process.stdout.write(`\n$ ${command}\n\n`);
+    try {
+        const result = await spawnShellCommand(command, cwd);
+        process.stdout.write(`\n[pix] ${formatInteractiveShellResult(result)}\n`);
+        await waitForReturnToPix();
+        return result;
+    }
+    finally {
+        process.off("SIGINT", ignoreSigint);
+    }
+}
+export function formatShellCommandEntry(command, result, prefix = "!") {
+    if (result.error)
+        return `Shell command failed to start: ${prefix}${command}\n${result.error}`;
+    return `Shell command finished (${formatInteractiveShellResult(result)}): ${prefix}${command}`;
+}
+async function spawnShellCommand(command, cwd) {
+    try {
+        const child = spawn(command, {
+            cwd,
+            env: process.env,
+            shell: shellOption(),
+            stdio: "inherit",
+        });
+        return await new Promise((resolve) => {
+            let settled = false;
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(result);
+            };
+            child.once("error", (error) => {
+                settle({ exitCode: null, signal: null, error: error instanceof Error ? error.message : String(error) });
+            });
+            child.once("close", (exitCode, signal) => {
+                settle({ exitCode, signal });
+            });
+        });
+    }
+    catch (error) {
+        return { exitCode: null, signal: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function failedChatShellCommand(error, handlers) {
+    const result = { exitCode: null, signal: null, error: error instanceof Error ? error.message : String(error) };
+    const done = Promise.resolve(result);
+    queueMicrotask(() => handlers.onSettled?.(result));
+    return {
+        done,
+        writeInput: () => false,
+        interrupt: () => false,
+        kill: () => false,
+        endInput: () => { },
+    };
+}
+function signalChildProcess(child, signal) {
+    if (child.killed)
+        return false;
+    try {
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            process.kill(-child.pid, signal);
+            return true;
+        }
+        return child.kill(signal);
+    }
+    catch {
+        try {
+            return child.kill(signal);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function shellOption() {
+    return process.platform === "win32" ? true : process.env.SHELL || true;
+}
+function formatInteractiveShellResult(result) {
+    if (result.error)
+        return `failed to start: ${result.error}`;
+    if (result.signal)
+        return `terminated by ${result.signal}`;
+    return `exit ${result.exitCode ?? 0}`;
+}
+async function waitForReturnToPix() {
+    if (!process.stdin.isTTY || !process.stdin.readable)
+        return;
+    process.stdout.write("[pix] Press Enter to return to pix…");
+    await new Promise((resolve) => {
+        const cleanup = () => {
+            process.stdin.off("data", onData);
+            resolve();
+        };
+        const onData = () => cleanup();
+        process.stdin.once("data", onData);
+        process.stdin.resume();
+    });
+}

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

@@ -0,0 +1,28 @@
+import { type InteractiveShellCommandResult } from "./shell-command.js";
+import type { Entry, SessionActivity } from "./types.js";
+export type AppShellControllerHost = {
+    readonly cwd: string;
+    isRunning(): boolean;
+    addEntry(entry: Entry): void;
+    touchEntry(entry: Entry): void;
+    setStatus(status: string): void;
+    setSessionActivity(activity: SessionActivity): void;
+    restoreSessionStatus(): void;
+    render(): void;
+};
+export declare class AppShellController {
+    private readonly host;
+    private activeRun;
+    private renderTimer;
+    constructor(host: AppShellControllerHost);
+    isRunning(): boolean;
+    run(command: string): Promise<InteractiveShellCommandResult>;
+    sendInput(text: string): boolean;
+    interrupt(): boolean;
+    dispose(): void;
+    private appendOutput;
+    private appendInputEcho;
+    private finishEntry;
+    private touchAndScheduleRender;
+    private flushRender;
+}

package/dist/app/shell-controller.js

@@ -0,0 +1,124 @@
+import { createId } from "./id.js";
+import { runChatShellCommand } from "./shell-command.js";
+const SHELL_RENDER_THROTTLE_MS = 33;
+export class AppShellController {
+    host;
+    activeRun;
+    renderTimer;
+    constructor(host) {
+        this.host = host;
+    }
+    isRunning() {
+        return this.activeRun !== undefined;
+    }
+    async run(command) {
+        if (this.activeRun)
+            throw new Error("A shell command is already running");
+        const entry = {
+            id: createId("shell"),
+            kind: "shell",
+            command,
+            output: "",
+            expanded: true,
+            status: "running",
+        };
+        this.host.addEntry(entry);
+        this.host.setStatus(`shell: ${command}`);
+        this.host.setSessionActivity("running");
+        this.host.render();
+        const runningCommand = runChatShellCommand(command, this.host.cwd, {
+            onOutput: (chunk) => this.appendOutput(entry, chunk),
+            onSettled: (result) => this.finishEntry(entry, result),
+        });
+        this.activeRun = { entry, command: runningCommand };
+        try {
+            return await runningCommand.done;
+        }
+        finally {
+            if (this.activeRun?.entry === entry)
+                this.activeRun = undefined;
+            this.flushRender();
+            this.host.restoreSessionStatus();
+            if (this.host.isRunning())
+                this.host.render();
+        }
+    }
+    sendInput(text) {
+        const activeRun = this.activeRun;
+        if (!activeRun)
+            return false;
+        const input = text.endsWith("\n") ? text : `${text}\n`;
+        this.appendInputEcho(activeRun.entry, input);
+        return activeRun.command.writeInput(input);
+    }
+    interrupt() {
+        const activeRun = this.activeRun;
+        if (!activeRun)
+            return false;
+        this.appendOutput(activeRun.entry, "\n^C\n");
+        return activeRun.command.interrupt();
+    }
+    dispose() {
+        if (this.renderTimer)
+            clearTimeout(this.renderTimer);
+        this.renderTimer = undefined;
+        const activeRun = this.activeRun;
+        this.activeRun = undefined;
+        activeRun?.command.kill("SIGTERM");
+    }
+    appendOutput(entry, chunk) {
+        entry.output = appendTerminalChunk(entry.output, chunk);
+        this.touchAndScheduleRender(entry);
+    }
+    appendInputEcho(entry, input) {
+        entry.output = appendTerminalChunk(entry.output, formatInputEcho(input));
+        this.touchAndScheduleRender(entry);
+    }
+    finishEntry(entry, result) {
+        entry.status = "done";
+        entry.exitCode = result.exitCode;
+        entry.signal = result.signal;
+        if (result.error)
+            entry.error = result.error;
+        this.touchAndScheduleRender(entry);
+    }
+    touchAndScheduleRender(entry) {
+        this.host.touchEntry(entry);
+        if (!this.host.isRunning() || this.renderTimer)
+            return;
+        this.renderTimer = setTimeout(() => {
+            this.renderTimer = undefined;
+            if (this.host.isRunning())
+                this.host.render();
+        }, SHELL_RENDER_THROTTLE_MS);
+        this.renderTimer.unref?.();
+    }
+    flushRender() {
+        if (!this.renderTimer)
+            return;
+        clearTimeout(this.renderTimer);
+        this.renderTimer = undefined;
+    }
+}
+function appendTerminalChunk(current, chunk) {
+    let next = current;
+    for (let index = 0; index < chunk.length;) {
+        const codePoint = chunk.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        index += codePoint > 0xffff ? 2 : 1;
+        if (char === "\r") {
+            const lineStart = next.lastIndexOf("\n") + 1;
+            next = next.slice(0, lineStart);
+            continue;
+        }
+        next += char;
+    }
+    return next;
+}
+function formatInputEcho(input) {
+    const text = input.endsWith("\n") ? input.slice(0, -1) : input;
+    const lines = text.split("\n");
+    if (lines.length === 1 && lines[0] === "")
+        return "\x1b[90m› Enter\x1b[0m\n";
+    return `${lines.map((line, index) => `\x1b[90m${index === 0 ? "› " : "  "}${line}\x1b[0m`).join("\n")}\n`;
+}

package/dist/app/slash-commands.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import { type FuzzyMatch } from "../fuzzy.js";
+import type { ParsedSlashInput, SlashCommand } from "./types.js";
+export declare function parseSlashInput(text: string): ParsedSlashInput | undefined;
+export declare function getResourceSlashCommands(runtime: AgentSessionRuntime | undefined, builtInCommands: readonly SlashCommand[]): SlashCommand[];
+export declare function getSlashCommandMatches(commands: readonly SlashCommand[], query: string, limit?: number): FuzzyMatch<SlashCommand>[];

package/dist/app/slash-commands.js

@@ -0,0 +1,75 @@
+import { fuzzySearch } from "../fuzzy.js";
+export function parseSlashInput(text) {
+    if (!text.startsWith("/"))
+        return undefined;
+    const body = text.slice(1);
+    const match = /^(\S*)(?:\s+(.*))?$/.exec(body);
+    const commandArguments = match?.[2];
+    return {
+        commandName: match?.[1] ?? body,
+        hasArguments: commandArguments !== undefined,
+        arguments: commandArguments ?? "",
+    };
+}
+export function getResourceSlashCommands(runtime, builtInCommands) {
+    if (!runtime)
+        return [];
+    const commands = [];
+    const seen = new Set(builtInCommands.map((command) => command.name));
+    const addResourceCommand = (command) => {
+        if (!command.name || seen.has(command.name))
+            return;
+        seen.add(command.name);
+        commands.push({
+            ...command,
+            kind: "resource",
+            allowArguments: true,
+        });
+    };
+    for (const command of runtime.session.extensionRunner.getRegisteredCommands()) {
+        addResourceCommand({
+            name: command.invocationName,
+            description: formatResourceDescription(command.description, "extension", command.sourceInfo),
+            source: "extension",
+            sourceInfo: command.sourceInfo,
+            keywords: [command.name, "extension"],
+        });
+    }
+    for (const template of runtime.session.promptTemplates) {
+        addResourceCommand({
+            name: template.name,
+            description: formatResourceDescription(template.description, "prompt", template.sourceInfo),
+            source: "prompt",
+            sourceInfo: template.sourceInfo,
+            keywords: ["prompt", "template", template.argumentHint ?? ""].filter(Boolean),
+        });
+    }
+    if (runtime.services.settingsManager.getEnableSkillCommands()) {
+        for (const skill of runtime.session.resourceLoader.getSkills().skills) {
+            addResourceCommand({
+                name: `skill:${skill.name}`,
+                description: formatResourceDescription(skill.description, "skill", skill.sourceInfo),
+                source: "skill",
+                sourceInfo: skill.sourceInfo,
+                keywords: ["skill", skill.name],
+            });
+        }
+    }
+    return commands;
+}
+export function getSlashCommandMatches(commands, query, limit) {
+    const items = commands.map((command) => ({
+        value: command,
+        label: command.name,
+    }));
+    return fuzzySearch(items, query, limit === undefined ? {} : { limit });
+}
+function formatResourceDescription(description, source, sourceInfo) {
+    const tag = resourceSourceTag(source, sourceInfo);
+    return description ? `[${tag}] ${description}` : `[${tag}]`;
+}
+function resourceSourceTag(source, sourceInfo) {
+    if (!sourceInfo)
+        return source;
+    return `${source}:${sourceInfo.scope}`;
+}

package/dist/app/startup-checks.d.ts

@@ -0,0 +1,8 @@
+import type { AgentSessionRuntime, LoadExtensionsResult } from "@earendil-works/pi-coding-agent";
+export type StartupAvailabilityIssue = {
+    kind: "warning" | "error";
+    message: string;
+};
+export declare function collectStartupAvailabilityIssues(runtime: AgentSessionRuntime): Promise<StartupAvailabilityIssue[]>;
+export declare function checkPiCliAvailability(pathValue?: string): Promise<StartupAvailabilityIssue[]>;
+export declare function checkPiToolsSuiteExtensionAvailability(extensionsResult: LoadExtensionsResult): StartupAvailabilityIssue[];

package/dist/app/startup-checks.js

@@ -0,0 +1,59 @@
+import { access } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { constants as fsConstants } from "node:fs";
+const PI_CLI_COMMAND = "pi";
+const PI_TOOLS_SUITE_EXTENSION_ID = "pi-tools-suite";
+export async function collectStartupAvailabilityIssues(runtime) {
+    return [
+        ...(await checkPiCliAvailability()),
+        ...checkPiToolsSuiteExtensionAvailability(runtime.services.resourceLoader.getExtensions()),
+    ];
+}
+export async function checkPiCliAvailability(pathValue = process.env.PATH ?? "") {
+    if (await executableExistsOnPath(PI_CLI_COMMAND, pathValue))
+        return [];
+    return [{
+            kind: "error",
+            message: "pi CLI is not available on PATH. Install pi or add it to PATH before starting pix.",
+        }];
+}
+export function checkPiToolsSuiteExtensionAvailability(extensionsResult) {
+    if (extensionsResult.extensions.some(isPiToolsSuiteExtension))
+        return [];
+    const matchingErrors = extensionsResult.errors.filter((error) => pathLooksLikePiToolsSuite(error.path));
+    if (matchingErrors.length > 0) {
+        return matchingErrors.map((error) => ({
+            kind: "error",
+            message: `Pix bundled pi-tools-suite failed to load: ${error.error}. Check write access to ~/.pi/agent/extensions and the bundled external/pi-tools-suite payload.`,
+        }));
+    }
+    return [{
+            kind: "error",
+            message: "Pix bundled pi-tools-suite is not loaded from ~/.pi/agent/extensions/pi-tools-suite. Check write access to ~/.pi/agent/extensions and the bundled external/pi-tools-suite payload.",
+        }];
+}
+async function executableExistsOnPath(command, pathValue) {
+    const dirs = pathValue.split(delimiter).filter((part) => part.length > 0);
+    for (const dir of dirs) {
+        try {
+            await access(join(dir, command), fsConstants.X_OK);
+            return true;
+        }
+        catch {
+            // Keep scanning PATH entries.
+        }
+    }
+    return false;
+}
+function isPiToolsSuiteExtension(extension) {
+    return [
+        extension.path,
+        extension.resolvedPath,
+        extension.sourceInfo.path,
+        extension.sourceInfo.source,
+        extension.sourceInfo.baseDir,
+    ].some((value) => value !== undefined && pathLooksLikePiToolsSuite(value));
+}
+function pathLooksLikePiToolsSuite(value) {
+    return value.toLowerCase().includes(PI_TOOLS_SUITE_EXTENSION_ID);
+}

package/dist/app/startup-info.d.ts

@@ -0,0 +1,3 @@
+import { type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+export declare function createStartupInfoMessage(runtime: AgentSessionRuntime): string;
+export declare function isEmptyStartupSession(runtime: AgentSessionRuntime): boolean;

package/dist/app/startup-info.js

@@ -0,0 +1,176 @@
+import { homedir } from "node:os";
+import { basename, isAbsolute, relative, sep } from "node:path";
+import { VERSION } from "@earendil-works/pi-coding-agent";
+export function createStartupInfoMessage(runtime) {
+    const sections = startupSections(runtime);
+    return [
+        formatModelLine(runtime),
+        `pix · pi-sdk v${VERSION}`,
+        "escape interrupt · ctrl+c/ctrl+d clear/exit · / commands",
+        "",
+        ...sections.flatMap(formatSection),
+    ].join("\n").trimEnd();
+}
+export function isEmptyStartupSession(runtime) {
+    return Array.isArray(runtime.session.messages) && runtime.session.messages.length === 0;
+}
+function startupSections(runtime) {
+    const loader = runtime.session.resourceLoader;
+    const context = loader.getAgentsFiles();
+    const skills = loader.getSkills();
+    const prompts = loader.getPrompts();
+    const extensions = loader.getExtensions();
+    const themes = loader.getThemes();
+    const diagnostics = [
+        ...diagnosticLines("skills", skills.diagnostics),
+        ...diagnosticLines("prompts", prompts.diagnostics),
+        ...diagnosticLines("themes", themes.diagnostics),
+        ...extensions.errors.map((error) => `extensions: ${formatPath(error.path, runtime.cwd)} — ${error.error}`),
+    ];
+    return [
+        section("Context", context.agentsFiles.map((file) => formatPath(file.path, runtime.cwd))),
+        section("Skills", skills.skills.map((skill) => skill.name)),
+        section("Prompts", unique(runtime.session.promptTemplates.map((prompt) => prompt.name), prompts.prompts.map((prompt) => prompt.name))),
+        section("Extensions", extensionLabels(extensions.extensions, runtime.cwd)),
+        section("Themes", themes.themes.map((theme) => theme.name ?? sourcePathLabel(theme.sourcePath, theme.sourceInfo, runtime.cwd))),
+        section("Diagnostics", diagnostics),
+    ].filter((item) => item !== undefined);
+}
+function section(title, items) {
+    const filtered = items.map((item) => item.trim()).filter(Boolean);
+    return filtered.length > 0 ? { title, items: filtered } : undefined;
+}
+function formatSection(sectionValue) {
+    return [`[${sectionValue.title}]`, `  ${sectionValue.items.join(", ")}`, ""];
+}
+function formatModelLine(runtime) {
+    const scopedModels = runtime.session.scopedModels;
+    if (scopedModels.length > 0) {
+        return `Model scope: ${scopedModels.map((item) => modelLabel(item.model.id, item.thinkingLevel)).join(", ")}`;
+    }
+    const model = runtime.session.model;
+    return model ? `Model: ${model.provider}/${modelLabel(model.id, runtime.session.thinkingLevel)}` : "Model: unavailable";
+}
+function modelLabel(modelId, thinkingLevel) {
+    return thinkingLevel === undefined || thinkingLevel === "off" ? modelId : `${modelId}:${thinkingLevel}`;
+}
+function diagnosticLines(kind, diagnostics) {
+    return diagnostics.map((diag) => `${kind}: [${diag.type}] ${diag.message}${diag.path ? ` (${diag.path})` : ""}`);
+}
+function sourcePathLabel(pathValue, sourceInfo, cwd) {
+    if (pathValue)
+        return formatPath(pathValue, cwd);
+    return sourceInfo ? formatPath(sourceInfo.path, cwd) : "unknown";
+}
+function extensionLabels(extensions, cwd) {
+    const localExtensions = extensions
+        .map((extension) => ({
+        ...extension,
+        segments: compactDisplayPathSegments(extension.path, cwd),
+    }))
+        .filter((extension) => !isPackageSource(extension.sourceInfo));
+    return extensions.map((extension) => {
+        if (isPackageSource(extension.sourceInfo)) {
+            return packageExtensionLabel(extension.path, extension.sourceInfo, cwd);
+        }
+        const localIndex = localExtensions.findIndex((candidate) => candidate.path === extension.path);
+        if (localIndex === -1)
+            return compactPathLabel(extension.path, cwd);
+        return compactNonPackageExtensionLabel(extension.path, localIndex, localExtensions, cwd);
+    });
+}
+function isPackageSource(sourceInfo) {
+    const source = sourceInfo?.source ?? "";
+    return source.startsWith("npm:") || source.startsWith("git:");
+}
+function packageExtensionLabel(pathValue, sourceInfo, cwd) {
+    const sourceLabel = packageSourceLabel(sourceInfo);
+    if (!sourceLabel)
+        return compactPathLabel(pathValue, cwd);
+    const shortPath = shortPathForSource(pathValue, sourceInfo, cwd).replace(/\\/g, "/");
+    const packagePath = shortPath.startsWith("extensions/") ? shortPath.slice("extensions/".length) : shortPath;
+    const trimmedPath = packagePath.replace(/\/(index\.[cm]?[jt]s)$/u, "");
+    if (!trimmedPath || trimmedPath === "." || /^index\.[cm]?[jt]s$/u.test(trimmedPath))
+        return sourceLabel;
+    return `${sourceLabel}:${trimmedPath}`;
+}
+function packageSourceLabel(sourceInfo) {
+    const source = sourceInfo?.source ?? "";
+    if (source.startsWith("npm:"))
+        return source.slice("npm:".length) || source;
+    if (source.startsWith("git:")) {
+        const normalized = source.slice("git:".length).replace(/\.git$/u, "");
+        const match = normalized.match(/([^/:]+\/[^/]+)$/u);
+        return match?.[1] ?? normalized ?? source;
+    }
+    return "";
+}
+function compactNonPackageExtensionLabel(pathValue, index, allPaths, cwd) {
+    const segments = allPaths[index]?.segments;
+    if (!segments || segments.length === 0)
+        return compactPathLabel(pathValue, cwd);
+    for (let segmentCount = 1; segmentCount <= segments.length; segmentCount += 1) {
+        const candidate = segments.slice(-segmentCount).join("/");
+        const unique = allPaths.every((item, itemIndex) => {
+            if (itemIndex === index)
+                return true;
+            return item.segments.slice(-segmentCount).join("/") !== candidate;
+        });
+        if (unique)
+            return candidate;
+    }
+    return segments.join("/");
+}
+function compactDisplayPathSegments(pathValue, cwd) {
+    const segments = displayPath(pathValue, cwd)
+        .replace(/\\/g, "/")
+        .split("/")
+        .filter((segment) => segment.length > 0 && segment !== "~");
+    const lastSegment = segments.at(-1);
+    if (segments.length > 1 && (lastSegment === "index.ts" || lastSegment === "index.js")) {
+        segments.pop();
+    }
+    return segments;
+}
+function compactPathLabel(pathValue, cwd) {
+    const segments = compactDisplayPathSegments(pathValue, cwd);
+    return segments.at(-1) ?? formatPath(pathValue, cwd);
+}
+function shortPathForSource(pathValue, sourceInfo, cwd) {
+    const baseDir = sourceInfo?.baseDir;
+    if (baseDir && isPackageSource(sourceInfo)) {
+        const rel = relative(baseDir, pathValue);
+        if (rel && rel !== "." && !rel.startsWith("..") && !isAbsolute(rel))
+            return rel;
+    }
+    return displayPath(pathValue, cwd);
+}
+function displayPath(pathValue, cwd) {
+    if (!isAbsolute(pathValue))
+        return pathValue;
+    const rel = relative(cwd, pathValue);
+    if (rel && rel !== "." && !rel.startsWith("..") && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)) {
+        return rel;
+    }
+    const home = homedir();
+    return pathValue.startsWith(home) ? `~${pathValue.slice(home.length)}` : pathValue;
+}
+function formatPath(pathValue, cwd) {
+    if (!isAbsolute(pathValue))
+        return pathValue;
+    const rel = relative(cwd, pathValue);
+    return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : basename(pathValue);
+}
+function unique(...groups) {
+    const seen = new Set();
+    const values = [];
+    for (const group of groups) {
+        for (const item of group) {
+            if (seen.has(item))
+                continue;
+            seen.add(item);
+            values.push(item);
+        }
+    }
+    return values;
+}