@raintree-technology/perps 0.1.0

package/dist/adapters/utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared adapter utilities for safe payload extraction and type conversion.
+ *
+ * These helpers allow adapters to traverse untyped JSON payloads (REST/WS responses)
+ * and extract typed values without unsafe casts.
+ */
+export type JsonRecord = Record<string, unknown>;
+export declare function isRecord(value: unknown): value is JsonRecord;
+export declare function pickUnknown(payload: unknown, paths: string[]): unknown;
+export declare function pickArray(payload: unknown, paths: string[]): JsonRecord[];
+export declare function pickObject(payload: unknown, paths: string[]): JsonRecord | null;
+export declare function pickString(payload: unknown, paths: string[]): string | null;
+export declare function pickNumber(payload: unknown, paths: string[], fallback: number): number;
+export declare function pickBoolean(payload: unknown, paths: string[], fallback: boolean): boolean;
+export declare function toTimestampMs(value: unknown, fallback: number): number;
+export declare function decimalToScaled(value: string, decimals: number): bigint;
+export declare function decimalPlaces(value: string): number;

package/dist/adapters/utils.js

@@ -0,0 +1,122 @@
+/**
+ * Shared adapter utilities for safe payload extraction and type conversion.
+ *
+ * These helpers allow adapters to traverse untyped JSON payloads (REST/WS responses)
+ * and extract typed values without unsafe casts.
+ */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function pickUnknown(payload, paths) {
+    for (const path of paths) {
+        const segments = path.split(".");
+        let current = payload;
+        let valid = true;
+        for (const segment of segments) {
+            if (Array.isArray(current)) {
+                const index = Number(segment);
+                if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+                    valid = false;
+                    break;
+                }
+                current = current[index];
+                continue;
+            }
+            if (!isRecord(current) || !(segment in current)) {
+                valid = false;
+                break;
+            }
+            current = current[segment];
+        }
+        if (valid)
+            return current;
+    }
+    return undefined;
+}
+export function pickArray(payload, paths) {
+    for (const path of paths) {
+        const value = pickUnknown(payload, [path]);
+        if (Array.isArray(value)) {
+            return value.filter(isRecord);
+        }
+    }
+    if (Array.isArray(payload)) {
+        return payload.filter(isRecord);
+    }
+    return [];
+}
+export function pickObject(payload, paths) {
+    for (const path of paths) {
+        const value = pickUnknown(payload, [path]);
+        if (isRecord(value)) {
+            return value;
+        }
+    }
+    return null;
+}
+export function pickString(payload, paths) {
+    const value = pickUnknown(payload, paths);
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value.toString();
+    if (typeof value === "bigint")
+        return value.toString();
+    return null;
+}
+export function pickNumber(payload, paths, fallback) {
+    const value = pickUnknown(payload, paths);
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = parseFloat(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    if (typeof value === "bigint")
+        return Number(value);
+    return fallback;
+}
+export function pickBoolean(payload, paths, fallback) {
+    const value = pickUnknown(payload, paths);
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        if (value.toLowerCase() === "true")
+            return true;
+        if (value.toLowerCase() === "false")
+            return false;
+    }
+    return fallback;
+}
+export function toTimestampMs(value, fallback) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value > 1e12 ? value : value * 1000;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed > 1e12 ? parsed : parsed * 1000;
+        }
+    }
+    return fallback;
+}
+export function decimalToScaled(value, decimals) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return 0n;
+    const negative = trimmed.startsWith("-");
+    const normalized = negative ? trimmed.slice(1) : trimmed;
+    const [wholeRaw, fractionRaw = ""] = normalized.split(".");
+    const whole = wholeRaw === "" ? "0" : wholeRaw;
+    const fraction = (fractionRaw + "0".repeat(decimals)).slice(0, decimals);
+    const digits = `${whole}${fraction}`.replace(/^0+/, "") || "0";
+    const scaled = BigInt(digits);
+    return negative ? -scaled : scaled;
+}
+export function decimalPlaces(value) {
+    const idx = value.indexOf(".");
+    if (idx === -1)
+        return 0;
+    return value.length - idx - 1;
+}

package/dist/cli/command-metadata.d.ts

@@ -0,0 +1,2 @@
+export type CommandIntent = "execution" | "data" | "neutral";
+export declare function classifyCommandIntentFromMetadata(path: string[]): CommandIntent;

package/dist/cli/command-metadata.js

@@ -0,0 +1,44 @@
+const ROOT_INTENTS = {
+    order: "execution",
+    markets: "data",
+    asset: "data",
+    data: "data",
+    exchange: "data",
+    ui: "data",
+};
+const PATH_INTENTS = {
+    "arb/execute": "execution",
+    "account/add": "execution",
+    "agent/serve": "execution",
+    "arb/spread": "data",
+    "arb/funding": "data",
+    "arb/track": "data",
+    "arb/compare": "data",
+    "arb/history": "data",
+    "arb/positions": "data",
+    "arb/alert": "data",
+    "account/balances": "data",
+    "account/positions": "data",
+    "account/ls": "data",
+    "account/remove": "data",
+    "account/set-default": "data",
+};
+function normalizePath(path) {
+    return path.map((segment) => segment.trim().toLowerCase()).filter(Boolean);
+}
+export function classifyCommandIntentFromMetadata(path) {
+    const normalizedPath = normalizePath(path);
+    if (normalizedPath.length === 0) {
+        return "neutral";
+    }
+    const fullPath = normalizedPath.join("/");
+    const pathIntent = PATH_INTENTS[fullPath];
+    if (pathIntent) {
+        return pathIntent;
+    }
+    const rootIntent = ROOT_INTENTS[normalizedPath[0]];
+    if (rootIntent) {
+        return rootIntent;
+    }
+    return "neutral";
+}

package/dist/cli/context.d.ts

@@ -0,0 +1,14 @@
+import { InfoClient, ExchangeClient } from "@nktkas/hyperliquid";
+import type { Config } from "../lib/config.js";
+import type { Address } from "viem";
+import { ServerClient } from "../client/index.js";
+export interface CLIContext {
+    config: Config;
+    getPublicClient(): InfoClient;
+    getWalletClient(): ExchangeClient;
+    getWalletAddress(): Address;
+    getServerClient(): Promise<ServerClient | null>;
+    hasAccount(): boolean;
+    requiresAccountSetup(): boolean;
+}
+export declare function createContext(config: Config): CLIContext;

package/dist/cli/context.js

@@ -0,0 +1,59 @@
+import { HttpTransport, InfoClient, ExchangeClient, } from "@nktkas/hyperliquid";
+import { privateKeyToAccount } from "viem/accounts";
+import { tryConnectToServer } from "../client/index.js";
+export function createContext(config) {
+    let publicClient = null;
+    let walletClient = null;
+    let serverClient = undefined; // undefined = not checked yet
+    const transport = new HttpTransport({
+        isTestnet: config.testnet,
+    });
+    return {
+        config,
+        getPublicClient() {
+            if (!publicClient) {
+                publicClient = new InfoClient({ transport });
+            }
+            return publicClient;
+        },
+        getWalletClient() {
+            if (!walletClient) {
+                if (!config.privateKey) {
+                    if (config.account?.type === "readonly") {
+                        throw new Error(`Account "${config.account.alias}" is read-only and cannot perform trading operations.\n` +
+                            "Run 'perps account add' to set up an API wallet for trading.");
+                    }
+                    throw new Error("No account configured. Run 'perps account add' to set up your account.");
+                }
+                const account = privateKeyToAccount(config.privateKey);
+                walletClient = new ExchangeClient({ transport, wallet: account });
+            }
+            return walletClient;
+        },
+        getWalletAddress() {
+            if (config.walletAddress) {
+                return config.walletAddress;
+            }
+            if (config.privateKey) {
+                const account = privateKeyToAccount(config.privateKey);
+                return account.address;
+            }
+            throw new Error("No account configured. Run 'perps account add' to set up your account.");
+        },
+        async getServerClient() {
+            // Return cached result if already checked
+            if (serverClient !== undefined) {
+                return serverClient;
+            }
+            // Try to connect to server
+            serverClient = await tryConnectToServer();
+            return serverClient;
+        },
+        hasAccount() {
+            return !!(config.walletAddress || config.privateKey);
+        },
+        requiresAccountSetup() {
+            return !config.walletAddress && !config.privateKey;
+        },
+    };
+}

package/dist/cli/experience.d.ts

@@ -0,0 +1,48 @@
+type StatusKind = "success" | "error" | "warn" | "info";
+type ThemeTone = StatusKind | "dim" | "brand" | "accent";
+export declare const supportsColor: (stream?: NodeJS.WriteStream) => boolean;
+export declare const highlighter: {
+    bold: (text: string) => string;
+    dim: (text: string) => string;
+    dimWhite: (text: string) => string;
+    success: (text: string) => string;
+    error: (text: string) => string;
+    warn: (text: string) => string;
+    info: (text: string) => string;
+    brand: (text: string) => string;
+    accent: (text: string) => string;
+};
+/**
+ * Strip ANSI escape codes from a string to get its visible length
+ */
+export declare function stripAnsi(text: string): string;
+export declare function formatStatusLine(kind: StatusKind, text: string, stream?: NodeJS.WriteStream): string;
+export declare function formatTag(label: string, tone?: ThemeTone): string;
+export declare function printSessionBanner(args: {
+    version: string;
+    commandPath: string[];
+    exchange: string;
+    isTestnet: boolean;
+}): void;
+export declare function printCommandCompletion(durationSeconds: number): void;
+export interface FramedLine {
+    plainText: string;
+    renderedText: string;
+}
+export interface FrameBoxOptions {
+    indent?: number;
+    padding?: number;
+    borderTone?: ThemeTone;
+}
+export declare function createFramedLine(plainText: string, renderedText?: string): FramedLine;
+export declare function renderFramedBox(lines: FramedLine[], options?: FrameBoxOptions): string;
+export declare function printFramedBox(lines: FramedLine[], options?: FrameBoxOptions): void;
+export interface SpinnerHandle {
+    update: (nextText: string) => void;
+    succeed: (message: string) => void;
+    fail: (message: string) => void;
+    info: (message: string) => void;
+}
+export declare function startSpinner(initialText: string): SpinnerHandle;
+export declare function registerCursorCleanup(): void;
+export {};

package/dist/cli/experience.js

@@ -0,0 +1,243 @@
+const ANSI_RESET = "\u001b[0m";
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_DIM = "\u001b[2m";
+const ANSI_RED = "\u001b[31m";
+const ANSI_GREEN = "\u001b[32m";
+const ANSI_YELLOW = "\u001b[33m";
+const ANSI_CYAN = "\u001b[36m";
+const ANSI_BRIGHT_BLUE = "\u001b[94m";
+const ANSI_BRIGHT_CYAN = "\u001b[96m";
+const ANSI_DIM_WHITE = "\u001b[90m";
+const ANSI_CLEAR_LINE = "\u001b[2K";
+// eslint-disable-next-line no-control-regex
+const ANSI_REGEX = /\u001b\[[0-9;]*m/g;
+export const supportsColor = (stream = process.stdout) => Boolean(stream.isTTY) && !process.env.NO_COLOR;
+const supportsDecoratedOutput = (stream = process.stdout) => Boolean(stream.isTTY);
+const supportsUnicodeSymbols = () => {
+    if (process.platform !== "win32")
+        return true;
+    return Boolean(process.env.WT_SESSION || process.env.TERM_PROGRAM || process.env.ANSICON);
+};
+const paint = (text, ansiCode, stream = process.stdout) => {
+    if (!supportsColor(stream))
+        return text;
+    return `${ansiCode}${text}${ANSI_RESET}`;
+};
+const unicode = supportsUnicodeSymbols();
+const symbolMap = {
+    success: unicode ? "◆" : "[ok]",
+    error: unicode ? "◈" : "[x]",
+    warn: unicode ? "▲" : "[!]",
+    info: unicode ? "●" : "[i]",
+};
+const SPINNER_FRAMES = unicode
+    ? ["⠇", "⠋", "⠙", "⠸", "⠴", "⠦"]
+    : ["-", "\\", "|", "/"];
+const PERPS_MARK_UNICODE = [
+    "╔═╗┌─┐┬─┐┌─┐┌─┐",
+    "╠═╝├┤ ├┬┘├─┘└─┐",
+    "╩  └─┘┴└─┴  └─┘",
+];
+const PERPS_MARK_ASCII = [
+    " ____  _____ ____  ____  ____",
+    "|  _ \\| ____|  _ \\|  _ \\/ ___|",
+    "| |_) |  _| | |_) | |_) \\___ \\",
+    "|  __/| |___|  _ <|  __/ ___) |",
+    "|_|   |_____|_| \\_\\_|   |____/",
+];
+export const highlighter = {
+    bold: (text) => paint(text, ANSI_BOLD),
+    dim: (text) => paint(text, ANSI_DIM),
+    dimWhite: (text) => paint(text, ANSI_DIM_WHITE),
+    success: (text) => paint(text, ANSI_GREEN),
+    error: (text) => paint(text, ANSI_RED),
+    warn: (text) => paint(text, ANSI_YELLOW),
+    info: (text) => paint(text, ANSI_CYAN),
+    brand: (text) => paint(text, ANSI_BRIGHT_BLUE),
+    accent: (text) => paint(text, ANSI_BRIGHT_CYAN),
+};
+/**
+ * Strip ANSI escape codes from a string to get its visible length
+ */
+export function stripAnsi(text) {
+    return text.replace(ANSI_REGEX, "");
+}
+const colorizeByTone = (tone, text, stream = process.stdout) => {
+    if (tone === "success")
+        return paint(text, ANSI_GREEN, stream);
+    if (tone === "error")
+        return paint(text, ANSI_RED, stream);
+    if (tone === "warn")
+        return paint(text, ANSI_YELLOW, stream);
+    if (tone === "info")
+        return paint(text, ANSI_CYAN, stream);
+    if (tone === "brand")
+        return paint(text, ANSI_BRIGHT_BLUE, stream);
+    if (tone === "accent")
+        return paint(text, ANSI_BRIGHT_CYAN, stream);
+    return paint(text, ANSI_DIM, stream);
+};
+function decorateWithSymbol(kind, text, stream = process.stdout) {
+    if (!supportsDecoratedOutput(stream))
+        return text;
+    return `${symbolMap[kind]} ${text}`;
+}
+export function formatStatusLine(kind, text, stream = process.stdout) {
+    const withSymbol = decorateWithSymbol(kind, text, stream);
+    if (!supportsColor(stream))
+        return withSymbol;
+    return colorizeByTone(kind, withSymbol, stream);
+}
+export function formatTag(label, tone = "info") {
+    const normalized = label.trim().toUpperCase();
+    const raw = unicode ? `⟦${normalized}⟧` : `[${normalized}]`;
+    return colorizeByTone(tone, raw);
+}
+function getPerpsAsciiMark() {
+    return unicode ? PERPS_MARK_UNICODE : PERPS_MARK_ASCII;
+}
+export function printSessionBanner(args) {
+    if (!process.stdout.isTTY)
+        return;
+    const commandLabel = args.commandPath.length > 0 ? args.commandPath.join(" > ") : "root";
+    const networkTag = args.isTestnet ? formatTag("testnet", "warn") : formatTag("mainnet", "success");
+    const exchangeTag = formatTag(args.exchange, "accent");
+    const commandTag = formatTag(commandLabel, "brand");
+    console.log("");
+    for (const line of getPerpsAsciiMark()) {
+        console.log(highlighter.brand(line));
+    }
+    console.log(highlighter.dim("by Raintree Technology"));
+    console.log("");
+    console.log(`${highlighter.dim("mode")} ${networkTag}  ${highlighter.dim("exchange")} ${exchangeTag}`);
+    console.log(`${highlighter.dim("command")} ${commandTag}  ${highlighter.dim("version")} ${highlighter.dim(`v${args.version}`)}`);
+    console.log("");
+}
+export function printCommandCompletion(durationSeconds) {
+    const message = `Completed in ${durationSeconds.toFixed(2)}s`;
+    if (!process.stdout.isTTY) {
+        console.log(`\n${message}`);
+        return;
+    }
+    console.log("");
+    console.log(formatStatusLine("success", message));
+}
+export function createFramedLine(plainText, renderedText = plainText) {
+    return {
+        plainText,
+        renderedText,
+    };
+}
+function getBoxChars() {
+    if (unicode) {
+        return {
+            topLeft: "┌",
+            topRight: "┐",
+            bottomLeft: "└",
+            bottomRight: "┘",
+            horizontal: "─",
+            vertical: "│",
+        };
+    }
+    return {
+        topLeft: "+",
+        topRight: "+",
+        bottomLeft: "+",
+        bottomRight: "+",
+        horizontal: "-",
+        vertical: "|",
+    };
+}
+export function renderFramedBox(lines, options) {
+    if (lines.length === 0)
+        return "";
+    const boxChars = getBoxChars();
+    const indent = " ".repeat(options?.indent ?? 2);
+    const padding = " ".repeat(options?.padding ?? 1);
+    const borderTone = options?.borderTone ?? "dim";
+    const maxLineLength = Math.max(...lines.map((line) => line.plainText.length));
+    const horizontal = boxChars.horizontal.repeat(maxLineLength + padding.length * 2);
+    const border = (text) => colorizeByTone(borderTone, text);
+    const outputLines = [];
+    outputLines.push(`${indent}${border(`${boxChars.topLeft}${horizontal}${boxChars.topRight}`)}`);
+    for (const line of lines) {
+        const trailingSpaces = " ".repeat(maxLineLength - line.plainText.length);
+        outputLines.push(`${indent}${border(boxChars.vertical)}${padding}${line.renderedText}${trailingSpaces}${padding}${border(boxChars.vertical)}`);
+    }
+    outputLines.push(`${indent}${border(`${boxChars.bottomLeft}${horizontal}${boxChars.bottomRight}`)}`);
+    return outputLines.join("\n");
+}
+export function printFramedBox(lines, options) {
+    const rendered = renderFramedBox(lines, options);
+    if (rendered) {
+        console.log(rendered);
+    }
+}
+export function startSpinner(initialText) {
+    const canAnimate = Boolean(process.stdout.isTTY);
+    let text = initialText;
+    let frameIndex = 0;
+    let finished = false;
+    let timer = null;
+    const renderFrame = () => {
+        if (!canAnimate || finished)
+            return;
+        const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
+        frameIndex += 1;
+        process.stdout.write(`\r${ANSI_CLEAR_LINE}${highlighter.brand(frame)} ${text}`);
+    };
+    const finalize = (kind, message) => {
+        if (finished)
+            return;
+        finished = true;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+        if (canAnimate) {
+            process.stdout.write(`\r${ANSI_CLEAR_LINE}`);
+        }
+        console.log(formatStatusLine(kind, message));
+    };
+    if (canAnimate) {
+        renderFrame();
+        timer = setInterval(renderFrame, 90);
+    }
+    return {
+        update(nextText) {
+            text = nextText;
+            renderFrame();
+        },
+        succeed(message) {
+            finalize("success", message);
+        },
+        fail(message) {
+            finalize("error", message);
+        },
+        info(message) {
+            finalize("info", message);
+        },
+    };
+}
+/**
+ * Register signal handlers to restore terminal cursor on exit.
+ * Call once at startup when using hideCursor/watch mode.
+ */
+let cursorCleanupRegistered = false;
+export function registerCursorCleanup() {
+    if (cursorCleanupRegistered)
+        return;
+    cursorCleanupRegistered = true;
+    const restore = () => {
+        process.stdout.write("\x1b[?25h");
+    };
+    process.on("SIGINT", () => {
+        restore();
+        process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+        restore();
+        process.exit(143);
+    });
+    process.on("exit", restore);
+}

package/dist/cli/ink/app/AppShell.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { ShortcutHint, StatusChip, Tone } from "./types.js";
+export interface AppShellProps {
+    title: string;
+    subtitle?: string;
+    status?: StatusChip[];
+    lastUpdated?: Date;
+    shortcuts?: ShortcutHint[];
+    children: React.ReactNode;
+}
+export declare function AppShell({ title, subtitle, status, lastUpdated, shortcuts, children, }: AppShellProps): React.ReactElement;
+export declare function getToneTextColor(tone: Tone | undefined): string;

package/dist/cli/ink/app/AppShell.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { colors } from "../theme.js";
+function getToneColor(tone) {
+    switch (tone) {
+        case "success":
+            return colors.profit;
+        case "warning":
+            return colors.warning;
+        case "danger":
+            return colors.loss;
+        case "info":
+            return colors.info;
+        case "neutral":
+        default:
+            return colors.muted;
+    }
+}
+function formatClock(value) {
+    return value.toLocaleTimeString("en-US", {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+}
+export function AppShell({ title, subtitle, status = [], lastUpdated, shortcuts = [], children, }) {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 0, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: colors.header, children: title }), subtitle && (_jsxs(Text, { color: colors.muted, children: ["  ", subtitle] }))] }), _jsxs(Box, { marginBottom: 1, children: [status.map((chip, index) => (_jsx(Box, { marginRight: 1, children: _jsxs(Text, { color: getToneColor(chip.tone), children: ["[", chip.label, "]"] }) }, `${chip.label}-${index}`))), _jsx(Box, { flexGrow: 1 }), lastUpdated && _jsxs(Text, { color: colors.muted, children: ["updated ", formatClock(lastUpdated)] })] }), _jsx(Box, { flexDirection: "column", children: children }), shortcuts.length > 0 && (_jsx(Box, { marginTop: 1, children: shortcuts.map((shortcut, index) => (_jsx(Box, { marginRight: 2, children: _jsxs(Text, { color: colors.muted, children: [_jsx(Text, { color: colors.header, children: shortcut.key }), " ", shortcut.label] }) }, `${shortcut.key}-${index}`))) }))] }));
+}
+export function getToneTextColor(tone) {
+    return getToneColor(tone);
+}

package/dist/cli/ink/app/MetricStrip.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { Metric } from "./types.js";
+export interface MetricStripProps {
+    metrics: Metric[];
+}
+export declare function MetricStrip({ metrics }: MetricStripProps): React.ReactElement;

package/dist/cli/ink/app/MetricStrip.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { colors } from "../theme.js";
+import { getToneTextColor } from "./AppShell.js";
+function getDeltaColor(delta) {
+    if (delta.startsWith("+"))
+        return colors.profit;
+    if (delta.startsWith("-"))
+        return colors.loss;
+    return colors.muted;
+}
+export function MetricStrip({ metrics }) {
+    return (_jsx(Box, { marginBottom: 1, flexWrap: "wrap", children: metrics.map((metric, index) => (_jsxs(Box, { marginRight: 2, children: [_jsx(Text, { color: colors.muted, children: metric.label }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, color: getToneTextColor(metric.tone), children: metric.value }), metric.delta && (_jsxs(Text, { color: getDeltaColor(metric.delta), children: [" ", metric.delta] }))] }, `${metric.label}-${index}`))) }));
+}

package/dist/cli/ink/app/Panel.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { Tone } from "./types.js";
+export interface PanelProps {
+    title: string;
+    subtitle?: string;
+    tone?: Tone;
+    children: React.ReactNode;
+}
+export declare function Panel({ title, subtitle, tone, children, }: PanelProps): React.ReactElement;

package/dist/cli/ink/app/Panel.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { colors } from "../theme.js";
+import { getToneTextColor } from "./AppShell.js";
+export function Panel({ title, subtitle, tone = "neutral", children, }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: getToneTextColor(tone), paddingX: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: getToneTextColor(tone), children: title }), subtitle && (_jsxs(Text, { color: colors.muted, children: ["  ", subtitle] }))] }), _jsx(Box, { flexDirection: "column", children: children })] }));
+}

package/dist/cli/ink/app/ascii.d.ts

@@ -0,0 +1,2 @@
+export declare function toSparkline(values: number[], width?: number, chars?: string): string;
+export declare function toBar(value: number, max: number, width?: number, fillChar?: string, emptyChar?: string): string;