@stigg/terminal 0.0.1-alpha

package/dist/mcp/clients/index.js

@@ -0,0 +1,27 @@
+import { ClaudeCodeMcpClient } from './claude-code.js';
+import { ClaudeDesktopMcpClient } from './claude-desktop.js';
+import { CodexMcpClient } from './codex.js';
+import { CursorMcpClient } from './cursor.js';
+import { VsCodeMcpClient } from './vscode.js';
+export { McpClient, DefaultJsonMcpClient } from './base.js';
+const ALL_CLIENTS = Object.freeze([
+    new ClaudeCodeMcpClient(),
+    new CursorMcpClient(),
+    new ClaudeDesktopMcpClient(),
+    new VsCodeMcpClient(),
+    new CodexMcpClient(),
+]);
+export function getAllClients() {
+    return ALL_CLIENTS;
+}
+export function getClientById(id) {
+    return ALL_CLIENTS.find((c) => c.id === id);
+}
+export async function getSupportedClients() {
+    const supported = [];
+    for (const c of ALL_CLIENTS) {
+        if (await c.isClientSupported())
+            supported.push(c);
+    }
+    return supported;
+}

package/dist/mcp/clients/mcp-remote.d.ts

@@ -0,0 +1,11 @@
+import type { Credential } from '../../types.js';
+/**
+ * Build a stdio-via-mcp-remote MCP entry for clients that don't speak HTTP
+ * natively (Claude Desktop, Codex). The API key is passed through an env
+ * var so it doesn't appear in the command's `args` array.
+ */
+export declare function buildMcpRemoteEntry(credential: Credential): {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+};

package/dist/mcp/clients/mcp-remote.js

@@ -0,0 +1,13 @@
+import { STIGG_MCP_URL } from './base.js';
+/**
+ * Build a stdio-via-mcp-remote MCP entry for clients that don't speak HTTP
+ * natively (Claude Desktop, Codex). The API key is passed through an env
+ * var so it doesn't appear in the command's `args` array.
+ */
+export function buildMcpRemoteEntry(credential) {
+    return {
+        command: 'npx',
+        args: ['-y', 'mcp-remote@latest', STIGG_MCP_URL, '--header', 'X-API-KEY:${STIGG_API_KEY}'],
+        env: { STIGG_API_KEY: credential.value },
+    };
+}

package/dist/mcp/clients/vscode.d.ts

@@ -0,0 +1,17 @@
+import type { ClientId, Credential } from '../../types.js';
+import { DefaultJsonMcpClient, type InstallResult, type McpServerConfig } from './base.js';
+export declare class VsCodeMcpClient extends DefaultJsonMcpClient {
+    readonly id: ClientId;
+    readonly name = "Visual Studio Code";
+    getConfigPath(): string;
+    getServerPropertyName(): string;
+    isClientSupported(): Promise<boolean>;
+    getServerConfig(credential: Credential): McpServerConfig;
+    /**
+     * Prefer `code --add-mcp '<json>'` when the `code` CLI is on PATH —
+     * that's the canonical entry point. Fall back to a direct file edit
+     * otherwise (typical when the user hasn't run "Install 'code' command
+     * in PATH" from the command palette).
+     */
+    addServer(credential: Credential): Promise<InstallResult>;
+}

package/dist/mcp/clients/vscode.js

@@ -0,0 +1,84 @@
+import { execFileSync } from 'node:child_process';
+import { access, constants } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { optionalEnv } from '../../auth/config.js';
+import { DefaultJsonMcpClient, errorMessage, prettifyPath, STIGG_MCP_URL, STIGG_SERVER_NAME, } from './base.js';
+export class VsCodeMcpClient extends DefaultJsonMcpClient {
+    id = 'vscode';
+    name = 'Visual Studio Code';
+    getConfigPath() {
+        const override = optionalEnv('STIGG_VSCODE_CONFIG');
+        if (override)
+            return override;
+        if (process.platform === 'darwin') {
+            return join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'mcp.json');
+        }
+        if (process.platform === 'win32') {
+            return join(process.env.APPDATA ?? '', 'Code', 'User', 'mcp.json');
+        }
+        return join(homedir(), '.config', 'Code', 'User', 'mcp.json');
+    }
+    getServerPropertyName() {
+        return 'servers';
+    }
+    async isClientSupported() {
+        if (!['darwin', 'win32', 'linux'].includes(process.platform))
+            return false;
+        if (await pathExists(dirname(this.getConfigPath())))
+            return true;
+        return commandExists('code');
+    }
+    getServerConfig(credential) {
+        return {
+            type: 'http',
+            url: STIGG_MCP_URL,
+            headers: { 'X-API-KEY': credential.value },
+        };
+    }
+    /**
+     * Prefer `code --add-mcp '<json>'` when the `code` CLI is on PATH —
+     * that's the canonical entry point. Fall back to a direct file edit
+     * otherwise (typical when the user hasn't run "Install 'code' command
+     * in PATH" from the command palette).
+     */
+    async addServer(credential) {
+        if (await commandExists('code')) {
+            const payload = JSON.stringify({
+                name: STIGG_SERVER_NAME,
+                ...this.getServerConfig(credential),
+            });
+            try {
+                execFileSync('code', ['--add-mcp', payload], { stdio: 'pipe' });
+                return { ok: true, target: 'code --add-mcp' };
+            }
+            catch (e) {
+                // Fall through to the file-write fallback.
+                const reason = errorMessage(e);
+                const fileResult = await super.addServer(credential);
+                if (fileResult.ok)
+                    return fileResult;
+                return {
+                    ok: false,
+                    target: prettifyPath(this.getConfigPath()),
+                    reason: `code --add-mcp failed (${reason}); file fallback also failed: ${fileResult.reason ?? 'unknown'}`,
+                };
+            }
+        }
+        return super.addServer(credential);
+    }
+}
+function pathExists(path) {
+    return access(path, constants.F_OK).then(() => true, () => false);
+}
+function commandExists(cmd) {
+    return new Promise((resolve) => {
+        try {
+            execFileSync('sh', ['-c', `command -v ${cmd}`], { stdio: 'pipe' });
+            resolve(true);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/mcp/clients.d.ts

@@ -0,0 +1,4 @@
+import type { ClientId, McpClientHandler } from "../types.js";
+export declare function claudeCodeHandler(): McpClientHandler;
+export declare function cursorHandler(): McpClientHandler;
+export declare function detectClients(handlers: Record<ClientId, McpClientHandler>): Promise<ClientId[]>;

package/dist/mcp/clients.js

@@ -0,0 +1,50 @@
+import { access, constants } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { optionalEnv } from "../auth/config.js";
+import { buildMcpEntry, hasMcpEntry, writeMcpEntry } from "./writer.js";
+const DEFAULT_URL = "https://mcp.stigg.io";
+const SERVER_NAME = "stigg";
+function mcpUrl() {
+    return optionalEnv("STIGG_MCP_URL") ?? DEFAULT_URL;
+}
+function claudeCodeConfigPath() {
+    return (optionalEnv("STIGG_CLAUDE_CONFIG") ?? join(homedir(), ".claude.json"));
+}
+function cursorConfigPath() {
+    return (optionalEnv("STIGG_CURSOR_CONFIG") ??
+        join(homedir(), ".cursor", "mcp.json"));
+}
+function pathExists(path) {
+    return access(path, constants.F_OK).then(() => true, () => false);
+}
+export function claudeCodeHandler() {
+    const path = claudeCodeConfigPath();
+    return {
+        id: "claude-code",
+        label: "~/.claude.json",
+        configPath: path,
+        hasExistingEntry: () => hasMcpEntry(path, SERVER_NAME),
+        write: (credential) => writeMcpEntry(path, SERVER_NAME, buildMcpEntry(credential, mcpUrl())),
+        isInstalled: () => pathExists(path).then((ok) => ok ? true : pathExists(join(homedir(), ".claude"))),
+    };
+}
+export function cursorHandler() {
+    const path = cursorConfigPath();
+    return {
+        id: "cursor",
+        label: "~/.cursor/mcp.json",
+        configPath: path,
+        hasExistingEntry: () => hasMcpEntry(path, SERVER_NAME),
+        write: (credential) => writeMcpEntry(path, SERVER_NAME, buildMcpEntry(credential, mcpUrl())),
+        isInstalled: () => pathExists(join(homedir(), ".cursor")),
+    };
+}
+export async function detectClients(handlers) {
+    const ids = [];
+    for (const handler of Object.values(handlers)) {
+        if (await handler.isInstalled())
+            ids.push(handler.id);
+    }
+    return ids;
+}

package/dist/mcp/config-merge.d.ts

@@ -0,0 +1,9 @@
+import * as jsonc from 'jsonc-parser';
+export declare class ConfigParseError extends Error {
+    path: string;
+    detail: jsonc.ParseError[] | string;
+    constructor(path: string, detail: jsonc.ParseError[] | string);
+}
+export declare function parseStrict(text: string, path: string): Record<string, unknown>;
+export declare function setJsonPath(text: string, path: jsonc.JSONPath, value: unknown): string;
+export declare function readJsonPath(value: unknown, path: readonly (string | number)[]): unknown;

package/dist/mcp/config-merge.js

@@ -0,0 +1,51 @@
+import * as jsonc from 'jsonc-parser';
+const FORMATTING_OPTIONS = {
+    tabSize: 2,
+    insertSpaces: true,
+    eol: '\n',
+};
+const PARSE_OPTIONS = {
+    allowTrailingComma: true,
+    allowEmptyContent: true,
+};
+export class ConfigParseError extends Error {
+    path;
+    detail;
+    constructor(path, detail) {
+        const summary = typeof detail === 'string'
+            ? detail
+            : `${detail.length} parse error(s) starting at offset ${detail[0]?.offset ?? 0}`;
+        super(`${path} is not valid JSON: ${summary}`);
+        this.path = path;
+        this.detail = detail;
+        this.name = 'ConfigParseError';
+    }
+}
+export function parseStrict(text, path) {
+    if (!text.trim())
+        return {};
+    const errors = [];
+    const value = jsonc.parse(text, errors, PARSE_OPTIONS);
+    if (errors.length > 0)
+        throw new ConfigParseError(path, errors);
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new ConfigParseError(path, 'root value is not an object');
+    }
+    return value;
+}
+export function setJsonPath(text, path, value) {
+    const seed = text.trim() ? text : '{}';
+    const edits = jsonc.modify(seed, path, value, {
+        formattingOptions: FORMATTING_OPTIONS,
+    });
+    return jsonc.applyEdits(seed, edits);
+}
+export function readJsonPath(value, path) {
+    let cur = value;
+    for (const seg of path) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}

package/dist/mcp/writer.d.ts

@@ -0,0 +1,6 @@
+import type { WriteResult } from '../types.js';
+export type { WriteResult };
+export type McpServerConfig = Record<string, unknown>;
+export declare function hasMcpEntry(path: string, propertyName: string, serverName: string): Promise<boolean>;
+export declare function writeMcpEntry(path: string, propertyName: string, serverName: string, entry: McpServerConfig): Promise<WriteResult>;
+export declare function removeMcpEntry(path: string, propertyName: string, serverName: string): Promise<WriteResult>;

package/dist/mcp/writer.js

@@ -0,0 +1,65 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { parseStrict, readJsonPath, setJsonPath } from './config-merge.js';
+export async function hasMcpEntry(path, propertyName, serverName) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return false;
+        throw e;
+    }
+    const parsed = parseStrict(text, path);
+    return readJsonPath(parsed, [propertyName, serverName]) !== undefined;
+}
+export async function writeMcpEntry(path, propertyName, serverName, entry) {
+    await mkdir(dirname(path), { recursive: true });
+    let text = '';
+    let fileExisted = false;
+    try {
+        text = await readFile(path, 'utf8');
+        fileExisted = true;
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    if (fileExisted && text.trim()) {
+        parseStrict(text, path);
+    }
+    const existed = fileExisted
+        ? readJsonPath(parseStrict(text, path), [propertyName, serverName]) !== undefined
+        : false;
+    let backedUpTo;
+    if (existed) {
+        backedUpTo = `${path}.bak.${Date.now()}`;
+        await writeFile(backedUpTo, text, 'utf8');
+    }
+    const updated = setJsonPath(text, [propertyName, serverName], entry);
+    const final = updated.endsWith('\n') ? updated : `${updated}\n`;
+    await writeFile(path, final, 'utf8');
+    return { path, written: true, backedUpTo };
+}
+export async function removeMcpEntry(path, propertyName, serverName) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return { path, written: false };
+        }
+        throw e;
+    }
+    if (readJsonPath(parseStrict(text, path), [propertyName, serverName]) === undefined) {
+        return { path, written: false };
+    }
+    const backedUpTo = `${path}.bak.${Date.now()}`;
+    await writeFile(backedUpTo, text, 'utf8');
+    const updated = setJsonPath(text, [propertyName, serverName], undefined);
+    const final = updated.endsWith('\n') ? updated : `${updated}\n`;
+    await writeFile(path, final, 'utf8');
+    return { path, written: true, backedUpTo };
+}

package/dist/setup/storage.d.ts

@@ -0,0 +1,21 @@
+import type { ClientId, Environment } from '../types.js';
+export interface SetupInfo {
+    user: string;
+    account: string;
+    accountId: string;
+    environment: string;
+    environmentId: string;
+    credentialLabel: string;
+    /** Snapshot of all environments visible at init time. Used by the env
+     *  switcher so it can render the picker without an extra API round-trip. */
+    environments?: Environment[];
+    /** Clients we wrote an MCP entry to, so the env switcher knows which
+     *  configs to rewrite without re-detecting. */
+    clients?: ClientId[];
+    completedAt: string;
+}
+export declare function setupConfigDir(): string;
+export declare function setupPath(): string;
+export declare function saveSetup(info: SetupInfo): Promise<string>;
+export declare function loadSetup(): Promise<SetupInfo | null>;
+export declare function clearSetup(): Promise<void>;

package/dist/setup/storage.js

@@ -0,0 +1,34 @@
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function setupConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg)
+        return join(xdg, 'stigg');
+    return join(homedir(), '.config', 'stigg');
+}
+export function setupPath() {
+    return join(setupConfigDir(), 'setup.json');
+}
+export async function saveSetup(info) {
+    const dir = setupConfigDir();
+    const path = setupPath();
+    await mkdir(dir, { recursive: true });
+    await writeFile(path, JSON.stringify(info, null, 2), 'utf8');
+    await chmod(path, 0o600);
+    return path;
+}
+export async function loadSetup() {
+    try {
+        const raw = await readFile(setupPath(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+}
+export async function clearSetup() {
+    await rm(setupPath(), { force: true });
+}

package/dist/skills/install.d.ts

@@ -0,0 +1,19 @@
+import type { ClientId } from '../types.js';
+export interface SubResult {
+    ok: boolean;
+    reason?: string;
+}
+export interface InstallResult {
+    /** Result of `claude plugin install stigg@stigg-marketplace` (Claude Code path). */
+    claudeCode?: SubResult;
+    /** Result of `npx skills add stiggio/skills --all` (Agent Skills format, multi-client). */
+    agentSkills?: SubResult;
+    /** Convenience boolean — true iff every attempted sub-step succeeded. */
+    ok: boolean;
+}
+/**
+ * Install Stigg skills using the right canonical path for each client family.
+ * Claude Code → `claude plugin marketplace add` + `claude plugin install`.
+ * Anything else that consumes the Agent Skills format → `npx skills add`.
+ */
+export declare function installStiggSkills(selectedClients: ClientId[]): Promise<InstallResult>;

package/dist/skills/install.js

@@ -0,0 +1,64 @@
+import { spawn } from 'node:child_process';
+import { findClaudeBinary } from '../mcp/clients/claude-code.js';
+const MARKETPLACE = 'stiggio/skills';
+const PLUGIN_REF = 'stigg@stigg-marketplace';
+/**
+ * Install Stigg skills using the right canonical path for each client family.
+ * Claude Code → `claude plugin marketplace add` + `claude plugin install`.
+ * Anything else that consumes the Agent Skills format → `npx skills add`.
+ */
+export async function installStiggSkills(selectedClients) {
+    const result = { ok: true };
+    if (selectedClients.includes('claude-code')) {
+        result.claudeCode = await installClaudeCodePlugin();
+        if (!result.claudeCode.ok)
+            result.ok = false;
+    }
+    const otherClients = selectedClients.filter((c) => c !== 'claude-code');
+    if (otherClients.length > 0) {
+        result.agentSkills = await installAgentSkills();
+        if (!result.agentSkills.ok)
+            result.ok = false;
+    }
+    return result;
+}
+async function installClaudeCodePlugin() {
+    const bin = findClaudeBinary();
+    if (!bin)
+        return { ok: false, reason: '`claude` CLI not found on PATH' };
+    // Step 1: register the marketplace. Idempotent — re-running is a no-op.
+    const mpResult = await runCommand(bin, ['plugin', 'marketplace', 'add', MARKETPLACE]);
+    if (!mpResult.ok) {
+        return { ok: false, reason: `plugin marketplace add failed: ${mpResult.reason ?? 'unknown'}` };
+    }
+    // Step 2: install (or update) the plugin.
+    const installResult = await runCommand(bin, ['plugin', 'install', PLUGIN_REF]);
+    if (!installResult.ok) {
+        return { ok: false, reason: `plugin install failed: ${installResult.reason ?? 'unknown'}` };
+    }
+    return { ok: true };
+}
+async function installAgentSkills() {
+    if (!(await commandExists('npx')))
+        return { ok: false, reason: '`npx` not available on PATH' };
+    return runCommand('npx', ['-y', 'skills', 'add', MARKETPLACE, '--all']);
+}
+function commandExists(cmd) {
+    return runCommand('sh', ['-c', `command -v ${cmd}`]).then((r) => r.ok);
+}
+function runCommand(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (err) => resolve({ ok: false, reason: err.message }));
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolve({ ok: true });
+            else
+                resolve({ ok: false, reason: stderr.trim() || `exit ${code}` });
+        });
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+export type ClientId = 'claude-code' | 'cursor' | 'claude-desktop' | 'vscode' | 'codex';
+export interface Credential {
+    value: string;
+    accountId?: string;
+    environmentId?: string;
+    environmentSlug?: string;
+}
+export interface Account {
+    id: string;
+    displayName: string;
+}
+export interface Environment {
+    id: string;
+    name: string;
+    slug?: string;
+}
+export interface Session {
+    email: string;
+    accessToken: string;
+}
+export interface ApiKey {
+    id: string;
+    name: string;
+    lastFour: string;
+    scopes: string[];
+    keyType: string;
+    createdAt: string;
+    value?: string;
+}
+export interface WriteResult {
+    path: string;
+    client?: ClientId;
+    written: boolean;
+    backedUpTo?: string;
+}

package/dist/types.js

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

package/dist/ui/components/Card.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export type CardStatus = "active" | "done" | "error";
+interface CardProps {
+    title: string;
+    subtitle?: string;
+    status?: CardStatus;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+}
+export declare function Card({ title, subtitle, status, children, footer, }: CardProps): React.ReactElement;
+export {};

package/dist/ui/components/Card.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { COLORS, GLYPHS, shouldRenderBorder } from "../theme.js";
+const STATUS_GLYPH = {
+    active: "",
+    done: GLYPHS.check,
+    error: GLYPHS.cross,
+};
+const STATUS_COLOR = {
+    active: COLORS.primary,
+    done: COLORS.success,
+    error: COLORS.error,
+};
+export function Card({ title, subtitle, status = "active", children, footer, }) {
+    const useBorder = shouldRenderBorder();
+    const borderColor = STATUS_COLOR[status];
+    const glyph = STATUS_GLYPH[status];
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", borderStyle: useBorder ? "round" : undefined, borderColor: borderColor, paddingX: useBorder ? 1 : 0, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: borderColor, bold: true, children: title }), _jsxs(Box, { children: [subtitle && _jsx(Text, { dimColor: true, children: subtitle }), glyph && (_jsxs(Text, { color: borderColor, children: [subtitle ? "  " : "", glyph] }))] })] }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: children }), footer] }));
+}

package/dist/ui/components/ContextRow.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface ContextEntry {
+    label: string;
+    value: string;
+    hint?: string;
+}
+interface ContextRowProps {
+    entries: ContextEntry[];
+}
+export declare function ContextRow({ entries }: ContextRowProps): React.ReactElement;
+export {};

package/dist/ui/components/ContextRow.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function ContextRow({ entries }) {
+    if (entries.length === 0)
+        return _jsx(Box, {});
+    const labelWidth = Math.max(...entries.map((e) => e.label.length));
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: entries.map((entry, i) => (_jsxs(Box, { children: [_jsx(Box, { width: labelWidth + 2, children: _jsx(Text, { dimColor: true, children: entry.label }) }), _jsx(Text, { children: entry.value }), entry.hint && (_jsxs(Text, { dimColor: true, children: ["  ", entry.hint] }))] }, `${entry.label}-${i}`))) }));
+}

package/dist/ui/components/Footer.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export interface KeyHint {
+    key: string;
+    label: string;
+}
+interface FooterProps {
+    hints: KeyHint[];
+}
+export declare function Footer({ hints }: FooterProps): React.ReactElement;
+export {};

package/dist/ui/components/Footer.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import React from "react";
+import { GLYPHS } from "../theme.js";
+export function Footer({ hints }) {
+    if (hints.length === 0)
+        return _jsx(Box, {});
+    return (_jsx(Box, { marginTop: 1, children: hints.map((hint, i) => (_jsxs(React.Fragment, { children: [i > 0 && (_jsxs(Text, { dimColor: true, children: ["  ", GLYPHS.bullet, "  "] })), _jsx(Text, { color: "cyan", children: hint.key }), _jsxs(Text, { dimColor: true, children: [" ", hint.label] })] }, `${hint.key}-${i}`))) }));
+}

package/dist/ui/components/Header.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+interface HeaderProps {
+    title: string;
+    step?: {
+        current: number;
+        total: number;
+    };
+    badge?: string;
+}
+export declare function Header({ title, step, badge }: HeaderProps): React.ReactElement;
+export {};

package/dist/ui/components/Header.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { COLORS } from "../theme.js";
+export function Header({ title, step, badge }) {
+    return (_jsxs(Box, { justifyContent: "space-between", marginBottom: 1, children: [_jsx(Text, { bold: true, color: COLORS.primary, children: title }), _jsxs(Box, { children: [step && (_jsxs(Text, { dimColor: true, children: ["step ", step.current, " of ", step.total] })), badge && (_jsxs(Text, { color: "cyan", children: [step ? "  " : "", badge] }))] })] }));
+}

package/dist/ui/components/JsonPreview.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export type DiffLineKind = "add" | "remove" | "context" | "header";
+export interface DiffLine {
+    kind: DiffLineKind;
+    text: string;
+}
+interface JsonPreviewProps {
+    lines: DiffLine[];
+    title?: string;
+}
+export declare function JsonPreview({ lines, title, }: JsonPreviewProps): React.ReactElement;
+export declare function jsonToDiffLines(entry: unknown, serverName: string): DiffLine[];
+export {};