@raintree-technology/perps 0.1.0

package/dist/lib/state-context.js

@@ -0,0 +1,133 @@
+import { loadConfig } from "./config.js";
+import { readOperatorState } from "./operator-state.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function resolveEquityFromBalances(balances) {
+    if (balances.length === 0) {
+        return { equity: 0, available: 0, marginUsed: 0 };
+    }
+    const stableAssets = ["USD", "USDC", "USDT"];
+    const preferred = balances.find((b) => stableAssets.includes(b.asset.toUpperCase()));
+    const candidate = preferred ?? balances[0];
+    const equity = Number.parseFloat(candidate.total);
+    const available = Number.parseFloat(candidate.available);
+    const marginUsed = Number.parseFloat(candidate.marginUsed);
+    return {
+        equity: Number.isFinite(equity) ? equity : 0,
+        available: Number.isFinite(available) ? available : 0,
+        marginUsed: Number.isFinite(marginUsed) ? marginUsed : 0,
+    };
+}
+function toPositionContext(p) {
+    const size = Number.parseFloat(p.size);
+    const markPrice = Number.parseFloat(p.markPrice);
+    const liqPrice = p.liquidationPrice
+        ? Number.parseFloat(p.liquidationPrice)
+        : null;
+    return {
+        market: p.market,
+        side: p.side,
+        size,
+        entryPrice: Number.parseFloat(p.entryPrice),
+        markPrice,
+        notionalUsd: Math.abs(size) * markPrice,
+        unrealizedPnl: Number.parseFloat(p.unrealizedPnl),
+        realizedPnl: Number.parseFloat(p.realizedPnl),
+        leverage: p.leverage,
+        liquidationPrice: liqPrice,
+        marginType: p.marginType,
+    };
+}
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+// ---------------------------------------------------------------------------
+// Builder
+// ---------------------------------------------------------------------------
+export async function buildStateContext(adapter, exchangeId, config) {
+    const errors = [];
+    // Fetch in parallel with allSettled so partial failures don't kill everything
+    const [positionsResult, balancesResult, ordersResult] = await Promise.allSettled([
+        adapter.getPositions(),
+        adapter.getBalances(),
+        adapter.getOrders(),
+    ]);
+    let rawPositions = [];
+    if (positionsResult.status === "fulfilled") {
+        rawPositions = positionsResult.value;
+    }
+    else {
+        errors.push(`Failed to fetch positions: ${positionsResult.reason}`);
+    }
+    let rawBalances = [];
+    if (balancesResult.status === "fulfilled") {
+        rawBalances = balancesResult.value;
+    }
+    else {
+        errors.push(`Failed to fetch balances: ${balancesResult.reason}`);
+    }
+    let rawOrders = [];
+    if (ordersResult.status === "fulfilled") {
+        rawOrders = ordersResult.value;
+    }
+    else {
+        errors.push(`Failed to fetch orders: ${ordersResult.reason}`);
+    }
+    // Resolve equity from balances
+    const { equity, available, marginUsed } = resolveEquityFromBalances(rawBalances);
+    // Map positions
+    const positions = rawPositions.map(toPositionContext);
+    // Compute aggregates
+    const totalExposureUsd = positions.reduce((sum, p) => sum + p.notionalUsd, 0);
+    const netUnrealizedPnl = positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
+    const netRealizedPnl = positions.reduce((sum, p) => sum + p.realizedPnl, 0);
+    const leverageUsed = equity > 0 ? round2(totalExposureUsd / equity) : 0;
+    // Filter open orders
+    const openOrders = rawOrders.filter((o) => o.status === "open");
+    // Read operator state for halted/drawdown info
+    const operatorState = readOperatorState();
+    const killSwitchHalted = operatorState.killSwitch.enabled;
+    const heartbeatHalted = operatorState.heartbeat?.halted ?? false;
+    const halted = killSwitchHalted || heartbeatHalted;
+    let haltReason = "";
+    if (killSwitchHalted) {
+        haltReason = operatorState.killSwitch.reason ?? "kill switch enabled";
+    }
+    else if (heartbeatHalted) {
+        haltReason = operatorState.heartbeat?.haltReason ?? "halted";
+    }
+    const drawdownFromPeakPct = operatorState.heartbeat?.drawdownPct ?? 0;
+    const peakEquity = operatorState.heartbeat?.peakEquity ?? equity;
+    // Risk limits from config
+    const resolvedConfig = config ?? loadConfig(false);
+    const risk = resolvedConfig.risk;
+    return {
+        exchange: exchangeId,
+        timestamp: Date.now(),
+        equity,
+        availableBalance: available,
+        marginUsed,
+        marginAvailable: available,
+        totalExposureUsd,
+        netUnrealizedPnl,
+        netRealizedPnl,
+        leverageUsed,
+        positionCount: positions.length,
+        positions,
+        openOrderCount: openOrders.length,
+        openOrders,
+        halted,
+        haltReason,
+        drawdownFromPeakPct,
+        peakEquity,
+        riskLimits: {
+            maxPositionSizeUsd: risk.maxPositionSizeUsd,
+            maxTotalExposureUsd: risk.maxTotalExposureUsd,
+            maxLeverage: risk.maxLeverage,
+            minSignalConfidence: risk.minSignalConfidence,
+            maxDrawdownPct: risk.maxDrawdownPct,
+        },
+        errors,
+    };
+}

package/dist/lib/strategy/basis-trade.d.ts

@@ -0,0 +1,2 @@
+import type { StrategyDefinition } from "./interface.js";
+export declare const basisTradeStrategy: StrategyDefinition;

package/dist/lib/strategy/basis-trade.js

@@ -0,0 +1,24 @@
+import { registerStrategy } from "./registry.js";
+export const basisTradeStrategy = {
+    id: "basis-trade",
+    name: "Basis Trade (Cash-and-Carry)",
+    description: "Single-exchange basis convergence trade. When the perp trades at a premium to the index, short the perp to profit as the basis converges. When at a discount, long the perp.",
+    legs: 1,
+    shape: "directional",
+    exchanges: "single",
+    entrySignal: "Absolute basis spread (perp vs index) exceeds minimum threshold",
+    exitSignal: "Basis converges toward zero, manual close, or TP/SL hit",
+    parameters: [
+        { name: "minBasis", type: "number", default: 0.1, description: "Minimum basis spread (%) to enter" },
+        { name: "size", type: "number", description: "Position size in USD" },
+        { name: "confidence", type: "number", default: 0.5, description: "Signal confidence (0-1)" },
+        { name: "takeProfitPct", type: "number", description: "Take-profit basis convergence threshold (%)" },
+        { name: "stopLossPct", type: "number", description: "Stop-loss basis divergence threshold (%)" },
+    ],
+    riskProfile: {
+        maxPositionSizeUsd: 3000,
+        maxLeverage: 3,
+        maxDrawdownPct: 5,
+    },
+};
+registerStrategy(basisTradeStrategy);

package/dist/lib/strategy/funding-arb.d.ts

@@ -0,0 +1,2 @@
+import type { StrategyDefinition } from "./interface.js";
+export declare const fundingArbStrategy: StrategyDefinition;

package/dist/lib/strategy/funding-arb.js

@@ -0,0 +1,23 @@
+import { registerStrategy } from "./registry.js";
+export const fundingArbStrategy = {
+    id: "funding-arb",
+    name: "Funding Rate Arbitrage",
+    description: "Delta-neutral cross-exchange funding rate capture. Short on the exchange paying the highest rate, long on the exchange paying the lowest. Profits from the funding rate differential.",
+    legs: 2,
+    shape: "delta-neutral",
+    exchanges: "cross",
+    entrySignal: "Funding rate spread between exchanges exceeds minimum threshold",
+    exitSignal: "Funding rate spread compresses or reverses, manual close, or TP/SL hit",
+    parameters: [
+        { name: "minSpread", type: "number", default: 0.05, description: "Minimum annualized funding spread (%) to enter" },
+        { name: "size", type: "number", description: "Position size in USD per leg" },
+        { name: "confidence", type: "number", default: 0.5, description: "Signal confidence (0-1)" },
+        { name: "takeProfitPct", type: "number", default: 4, description: "Take-profit percentage" },
+        { name: "stopLossPct", type: "number", default: 2, description: "Stop-loss percentage" },
+    ],
+    riskProfile: {
+        maxPositionSizeUsd: 5000,
+        maxLeverage: 3,
+    },
+};
+registerStrategy(fundingArbStrategy);

package/dist/lib/strategy/interface.d.ts

@@ -0,0 +1,23 @@
+export interface StrategyParameter {
+    name: string;
+    type: "number" | "string" | "boolean";
+    default?: unknown;
+    description: string;
+}
+export interface StrategyRiskProfile {
+    maxPositionSizeUsd?: number;
+    maxLeverage?: number;
+    maxDrawdownPct?: number;
+}
+export interface StrategyDefinition {
+    id: string;
+    name: string;
+    description: string;
+    legs: number;
+    shape: "delta-neutral" | "directional" | "market-neutral";
+    parameters: StrategyParameter[];
+    riskProfile: StrategyRiskProfile;
+    exchanges: "single" | "cross";
+    entrySignal: string;
+    exitSignal: string;
+}

package/dist/lib/strategy/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/strategy/registry.d.ts

@@ -0,0 +1,4 @@
+import type { StrategyDefinition } from "./interface.js";
+export declare function registerStrategy(definition: StrategyDefinition): void;
+export declare function listStrategies(): StrategyDefinition[];
+export declare function getStrategy(id: string): StrategyDefinition | undefined;

package/dist/lib/strategy/registry.js

@@ -0,0 +1,10 @@
+const strategies = new Map();
+export function registerStrategy(definition) {
+    strategies.set(definition.id, definition);
+}
+export function listStrategies() {
+    return [...strategies.values()];
+}
+export function getStrategy(id) {
+    return strategies.get(id);
+}

package/dist/lib/telemetry.d.ts

@@ -0,0 +1,25 @@
+export interface TelemetryCounter {
+    total: number;
+    success: number;
+    failed: number;
+    skipped: number;
+    manual: number;
+    lastUpdatedAt: number;
+}
+export interface TelemetryStore {
+    version: number;
+    updatedAt: number;
+    counters: Record<string, TelemetryCounter>;
+}
+export declare function recordTelemetryMetric(args: {
+    metric: string;
+    status: "success" | "failed" | "skipped" | "manual";
+}): void;
+export declare function getTelemetrySnapshot(): TelemetryStore;
+export declare function summarizeFailureRates(store: TelemetryStore): Array<{
+    metric: string;
+    total: number;
+    failureRate: number;
+    successRate: number;
+}>;
+export declare function resetTelemetry(): void;

package/dist/lib/telemetry.js

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { TELEMETRY_PATH } from "./paths.js";
+import { ensurePrivateDir, hardenPrivateFile, PRIVATE_FILE_MODE } from "./fs-security.js";
+const TELEMETRY_SCHEMA_VERSION = 1;
+function telemetryEnabled() {
+    if (process.env.PERPS_DISABLE_TELEMETRY === "1") {
+        return false;
+    }
+    if (process.env.VITEST) {
+        return false;
+    }
+    return true;
+}
+function createCounter() {
+    return {
+        total: 0,
+        success: 0,
+        failed: 0,
+        skipped: 0,
+        manual: 0,
+        lastUpdatedAt: 0,
+    };
+}
+function createStore() {
+    return {
+        version: TELEMETRY_SCHEMA_VERSION,
+        updatedAt: Date.now(),
+        counters: {},
+    };
+}
+function readStore() {
+    if (!existsSync(TELEMETRY_PATH)) {
+        return createStore();
+    }
+    try {
+        const raw = readFileSync(TELEMETRY_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            version: TELEMETRY_SCHEMA_VERSION,
+            updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
+            counters: parsed.counters ?? {},
+        };
+    }
+    catch {
+        return createStore();
+    }
+}
+function writeStore(store) {
+    ensurePrivateDir(dirname(TELEMETRY_PATH));
+    writeFileSync(TELEMETRY_PATH, `${JSON.stringify(store, null, 2)}\n`, {
+        mode: PRIVATE_FILE_MODE,
+    });
+    hardenPrivateFile(TELEMETRY_PATH);
+}
+function upsertCounter(store, key) {
+    const existing = store.counters[key] ?? createCounter();
+    store.counters[key] = existing;
+    return existing;
+}
+export function recordTelemetryMetric(args) {
+    if (!telemetryEnabled()) {
+        return;
+    }
+    const store = readStore();
+    const counter = upsertCounter(store, args.metric);
+    counter.total += 1;
+    if (args.status === "success")
+        counter.success += 1;
+    if (args.status === "failed")
+        counter.failed += 1;
+    if (args.status === "skipped")
+        counter.skipped += 1;
+    if (args.status === "manual")
+        counter.manual += 1;
+    counter.lastUpdatedAt = Date.now();
+    store.updatedAt = counter.lastUpdatedAt;
+    writeStore(store);
+}
+export function getTelemetrySnapshot() {
+    return readStore();
+}
+export function summarizeFailureRates(store) {
+    const rows = [];
+    for (const [metric, counter] of Object.entries(store.counters)) {
+        const total = Math.max(0, counter.total);
+        const failureRate = total > 0 ? counter.failed / total : 0;
+        const successRate = total > 0 ? counter.success / total : 0;
+        rows.push({
+            metric,
+            total,
+            failureRate,
+            successRate,
+        });
+    }
+    rows.sort((a, b) => b.failureRate - a.failureRate || b.total - a.total);
+    return rows;
+}
+export function resetTelemetry() {
+    writeStore(createStore());
+}

package/dist/lib/trace-queries.d.ts

@@ -0,0 +1,20 @@
+export interface TraceSummary {
+    traceId: string;
+    firstSeen: number;
+    lastSeen: number;
+    exchange: string;
+    markets: string[];
+    journalEntries: number;
+    riskEvaluations: number;
+    riskDenials: number;
+    journalStatus: "succeeded" | "failed" | "pending" | "mixed" | null;
+    durationMs: number;
+}
+export interface TraceListOptions {
+    minutes?: number;
+    exchange?: string;
+    market?: string;
+    limit?: number;
+    status?: "succeeded" | "failed" | "denied";
+}
+export declare function listTraces(options?: TraceListOptions): TraceSummary[];

package/dist/lib/trace-queries.js

@@ -0,0 +1,133 @@
+import { getDb } from "./db/index.js";
+function deriveJournalStatus(statuses, journalEntries) {
+    if (journalEntries === 0)
+        return null;
+    if (statuses.size === 1) {
+        const value = [...statuses][0];
+        if (value === "succeeded" || value === "failed" || value === "pending") {
+            return value;
+        }
+        return "mixed";
+    }
+    return "mixed";
+}
+export function listTraces(options) {
+    const db = getDb();
+    const minutes = options?.minutes ?? 60;
+    const limit = options?.limit ?? 50;
+    const cutoff = Date.now() - minutes * 60 * 1000;
+    const traceMap = new Map();
+    // 1. Query risk_evaluation_log grouped by trace_id
+    const riskRows = db
+        .prepare(`SELECT trace_id,
+              MIN(created_at) as first_seen,
+              MAX(created_at) as last_seen,
+              exchange,
+              GROUP_CONCAT(DISTINCT market) as markets,
+              COUNT(*) as eval_count,
+              SUM(CASE WHEN allowed = 0 THEN 1 ELSE 0 END) as denial_count
+       FROM risk_evaluation_log
+       WHERE trace_id IS NOT NULL AND created_at > ?
+       GROUP BY trace_id`)
+        .all(cutoff);
+    for (const row of riskRows) {
+        const markets = new Set(row.markets ? row.markets.split(",").filter(Boolean) : []);
+        traceMap.set(row.trace_id, {
+            traceId: row.trace_id,
+            firstSeen: row.first_seen,
+            lastSeen: row.last_seen,
+            exchange: row.exchange,
+            markets,
+            journalEntries: 0,
+            riskEvaluations: row.eval_count,
+            riskDenials: row.denial_count,
+            statuses: new Set(),
+        });
+    }
+    // 2. Query execution_journal grouped by trace_id
+    const journalRows = db
+        .prepare(`SELECT trace_id,
+              MIN(created_at) as first_seen,
+              MAX(created_at) as last_seen,
+              exchange,
+              GROUP_CONCAT(DISTINCT market) as markets,
+              COUNT(*) as entry_count,
+              GROUP_CONCAT(DISTINCT status) as statuses
+       FROM execution_journal
+       WHERE trace_id IS NOT NULL AND created_at > ?
+       GROUP BY trace_id`)
+        .all(cutoff);
+    for (const row of journalRows) {
+        const existing = traceMap.get(row.trace_id);
+        const journalMarkets = row.markets
+            ? row.markets.split(",").filter(Boolean)
+            : [];
+        const journalStatuses = row.statuses
+            ? row.statuses.split(",").filter(Boolean)
+            : [];
+        if (existing) {
+            // Merge
+            existing.firstSeen = Math.min(existing.firstSeen, row.first_seen);
+            existing.lastSeen = Math.max(existing.lastSeen, row.last_seen);
+            for (const m of journalMarkets)
+                existing.markets.add(m);
+            existing.journalEntries = row.entry_count;
+            for (const s of journalStatuses)
+                existing.statuses.add(s);
+        }
+        else {
+            const markets = new Set(journalMarkets);
+            const statuses = new Set(journalStatuses);
+            traceMap.set(row.trace_id, {
+                traceId: row.trace_id,
+                firstSeen: row.first_seen,
+                lastSeen: row.last_seen,
+                exchange: row.exchange,
+                markets,
+                journalEntries: row.entry_count,
+                riskEvaluations: 0,
+                riskDenials: 0,
+                statuses,
+            });
+        }
+    }
+    // 3. Convert to TraceSummary, apply filters, sort, limit
+    let results = [];
+    for (const acc of traceMap.values()) {
+        const journalStatus = deriveJournalStatus(acc.statuses, acc.journalEntries);
+        results.push({
+            traceId: acc.traceId,
+            firstSeen: acc.firstSeen,
+            lastSeen: acc.lastSeen,
+            exchange: acc.exchange,
+            markets: [...acc.markets],
+            journalEntries: acc.journalEntries,
+            riskEvaluations: acc.riskEvaluations,
+            riskDenials: acc.riskDenials,
+            journalStatus,
+            durationMs: acc.lastSeen - acc.firstSeen,
+        });
+    }
+    // Apply optional filters
+    if (options?.exchange) {
+        const ex = options.exchange;
+        results = results.filter((t) => t.exchange === ex);
+    }
+    if (options?.market) {
+        const mkt = options.market;
+        results = results.filter((t) => t.markets.includes(mkt));
+    }
+    if (options?.status) {
+        const st = options.status;
+        if (st === "denied") {
+            results = results.filter((t) => t.riskDenials > 0);
+        }
+        else {
+            results = results.filter((t) => t.journalStatus === st);
+        }
+    }
+    // Sort by lastSeen DESC
+    results.sort((a, b) => b.lastSeen - a.lastSeen);
+    // Limit
+    return results.slice(0, limit);
+}

package/dist/lib/trace.d.ts

@@ -0,0 +1 @@
+export declare function generateTraceId(): string;

package/dist/lib/trace.js

@@ -0,0 +1,4 @@
+import { randomUUID } from "node:crypto";
+export function generateTraceId() {
+    return `trc_${randomUUID()}`;
+}

package/dist/lib/trade-reputation.d.ts

@@ -0,0 +1,6 @@
+export interface TradeReputationCheckInput {
+    exchangeId: string;
+    market: string;
+    command?: string;
+}
+export declare function assertTradeAllowed(input: TradeReputationCheckInput): void;

package/dist/lib/trade-reputation.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from "node:fs";
+function parseCsvList(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function compilePatterns(values, source) {
+    const patterns = [];
+    for (const value of values) {
+        try {
+            patterns.push(new RegExp(value, "i"));
+        }
+        catch {
+            throw new Error(`Invalid market pattern in ${source}: ${value}`);
+        }
+    }
+    return patterns;
+}
+function normalizeExchange(value) {
+    return value.trim().toLowerCase();
+}
+function normalizeMarket(value) {
+    return value.trim().toUpperCase();
+}
+function loadBlocklistFromEnv() {
+    const exchanges = parseCsvList(process.env.PERPS_BLOCKED_EXCHANGES).map(normalizeExchange);
+    const markets = parseCsvList(process.env.PERPS_BLOCKED_MARKETS).map(normalizeMarket);
+    const rawPatterns = parseCsvList(process.env.PERPS_BLOCKED_MARKET_PATTERNS);
+    const marketPatterns = compilePatterns(rawPatterns, "PERPS_BLOCKED_MARKET_PATTERNS");
+    return {
+        exchanges,
+        markets,
+        marketPatterns,
+    };
+}
+function loadBlocklistFromFile(filePath) {
+    if (!existsSync(filePath)) {
+        throw new Error(`Reputation blocklist file not found: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        throw new Error(`Unable to parse reputation blocklist file: ${filePath}`);
+    }
+    const exchanges = asStringArray(parsed.exchanges).map(normalizeExchange);
+    const markets = asStringArray(parsed.markets).map(normalizeMarket);
+    const rawPatterns = asStringArray(parsed.marketPatterns);
+    const marketPatterns = compilePatterns(rawPatterns, `blocklist file (${filePath})`);
+    return {
+        exchanges,
+        markets,
+        marketPatterns,
+    };
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+function loadEffectiveBlocklist() {
+    const envBlocklist = loadBlocklistFromEnv();
+    const filePath = process.env.PERPS_REPUTATION_BLOCKLIST_FILE?.trim();
+    if (!filePath) {
+        return envBlocklist;
+    }
+    const fileBlocklist = loadBlocklistFromFile(filePath);
+    return {
+        exchanges: dedupe([...envBlocklist.exchanges, ...fileBlocklist.exchanges]),
+        markets: dedupe([...envBlocklist.markets, ...fileBlocklist.markets]),
+        marketPatterns: [...envBlocklist.marketPatterns, ...fileBlocklist.marketPatterns],
+    };
+}
+export function assertTradeAllowed(input) {
+    const exchange = normalizeExchange(input.exchangeId);
+    const market = normalizeMarket(input.market);
+    const blocklist = loadEffectiveBlocklist();
+    const contextPrefix = input.command ? `${input.command}: ` : "";
+    if (blocklist.exchanges.includes(exchange)) {
+        throw new Error(`${contextPrefix}trade blocked by reputation policy: exchange "${exchange}" is blocked`);
+    }
+    if (blocklist.markets.includes(market)) {
+        throw new Error(`${contextPrefix}trade blocked by reputation policy: market "${market}" is blocked`);
+    }
+    for (const pattern of blocklist.marketPatterns) {
+        if (pattern.test(market)) {
+            throw new Error(`${contextPrefix}trade blocked by reputation policy: market "${market}" matched blocked pattern ${pattern.source}`);
+        }
+    }
+}

package/dist/lib/ui-tokens.d.ts

@@ -0,0 +1,21 @@
+/**
+ * UI tokens for lib/ modules
+ *
+ * Re-exports highlighter and inquirerTheme so that lib/ code
+ * never reaches into cli/ directly.
+ */
+export { highlighter } from "../cli/experience.js";
+export declare const inquirerTheme: {
+    prefix: {
+        idle: string;
+        done: string;
+    };
+    style: {
+        answer: (text: string) => string;
+        message: (text: string) => string;
+        error: (text: string) => string;
+        highlight: (text: string) => string;
+        description: (text: string) => string;
+        help: (text: string) => string;
+    };
+};

package/dist/lib/ui-tokens.js

@@ -0,0 +1,26 @@
+/**
+ * UI tokens for lib/ modules
+ *
+ * Re-exports highlighter and inquirerTheme so that lib/ code
+ * never reaches into cli/ directly.
+ */
+export { highlighter } from "../cli/experience.js";
+/**
+ * Theme configuration for @inquirer/prompts
+ * Uses highlighter so NO_COLOR is respected in prompts.
+ */
+import { highlighter } from "../cli/experience.js";
+export const inquirerTheme = {
+    prefix: {
+        idle: highlighter.info("?"),
+        done: highlighter.success("✔"),
+    },
+    style: {
+        answer: highlighter.info,
+        message: highlighter.bold,
+        error: highlighter.error,
+        highlight: highlighter.info,
+        description: highlighter.dimWhite,
+        help: highlighter.dimWhite,
+    },
+};