ghostykit 0.0.0-stage → 0.2.0

package/dist/react/Piloto.d.ts

@@ -0,0 +1,84 @@
+import { type CSSProperties, type ReactNode } from "react";
+import { type ToolVerbs } from "../core/steps";
+import type { Attachment, Reference, Turn } from "../core/types";
+import type { PilotTransport } from "../transport";
+import { type UploadResult } from "./Composer";
+import { type MarkdownOptions, type PilotIcon, type PilotTheme } from "./context";
+import { type PilotStrings } from "./strings";
+import { type PermissionHandler, type Pilot, type UsePilotOptions } from "./usePilot";
+export interface PilotoFeatures {
+    /** Botones de adjuntar. Default: sí si hay `upload`. */
+    attachments?: boolean;
+    /** «Reintentar» en la última respuesta. Default: sí. */
+    retry?: boolean;
+    /** «Copiar» en las burbujas. Default: sí. */
+    copy?: boolean;
+    /** Tokens y costo bajo cada respuesta. Default: sí. */
+    usage?: boolean;
+    /** Selector de modelo (si el agente ofrece varios). Default: sí. */
+    models?: boolean;
+    /** Las opciones finales de la última respuesta como botones. Default: sí. */
+    replyOptions?: boolean;
+    /** «· 12 s» junto a la frase de espera. Default: sí. */
+    duration?: boolean;
+}
+export interface PilotoSlots {
+    /** Las entregas de cada respuesta (archivos, páginas, tarjetas propias). */
+    renderDeliveries?: (turn: Turn, live: boolean) => ReactNode;
+    /** Botones propios en la barra del composer. */
+    composerExtras?: ReactNode;
+    /** Lo que se ve con el hilo vacío (en lugar del saludo de casa). */
+    emptyState?: ReactNode;
+    /** Arriba a la derecha, sobre el hilo (compartir, abrir en grande…). */
+    headerActions?: ReactNode;
+    /** Pegado arriba del composer (un aviso, un banner). */
+    aboveComposer?: ReactNode;
+}
+export interface PilotoProps extends UsePilotOptions {
+    transport: PilotTransport | null;
+    /** Si la app ya usa `usePilot` (para leer el estado afuera), pásalo aquí. */
+    pilot?: Pilot;
+    agentName?: string;
+    locale?: "es" | "en";
+    strings?: Partial<PilotStrings>;
+    theme?: PilotTheme;
+    /** La piel: `ghosty` (default), `easybits`, `neutral`, o el nombre de una propia (`[data-skin]`). */
+    skin?: string;
+    className?: string;
+    style?: CSSProperties;
+    toolVerbs?: ToolVerbs;
+    toolIcons?: Record<string, PilotIcon>;
+    /** El texto del usuario como se pinta (quita la fontanería que la app pega al prompt). */
+    formatUserText?: (text: string) => string;
+    markdown?: MarkdownOptions;
+    /** Saludo del hilo vacío. */
+    welcome?: ReactNode;
+    avatar?: ReactNode;
+    placeholder?: string;
+    suggestions?: string[];
+    upload?: (file: File) => Promise<UploadResult>;
+    transcribe?: (audio: Blob) => Promise<string>;
+    voiceNoteText?: (transcript: string) => string;
+    features?: PilotoFeatures;
+    /**
+     * Contestar un permiso (p. ej. el POST de aprobación de la app, con su sesión). Default:
+     * `transport.respondPermission`. Devuelve `{resolved:false}` si ya no estaba abierto.
+     */
+    onPermission?: PermissionHandler;
+    /** Referencias controladas (si no, Piloto las guarda; agrégalas con `ref.addReference`). */
+    references?: Reference[];
+    onReferencesChange?: (refs: Reference[]) => void;
+    /** Clic en un chip de referencia (resaltar la tarjeta en la app). */
+    onReferenceClick?: (ref: Reference) => void;
+    slots?: PilotoSlots;
+}
+/** Lo que la app puede hacer desde afuera (`<Piloto ref={…} />`). */
+export interface PilotoHandle {
+    send: (text: string, attachments?: Attachment[]) => void;
+    addReference: (ref: Reference) => void;
+    /** Escribe en la caja sin mandar. */
+    setDraft: (text: string) => void;
+    focus: () => void;
+}
+export declare const Piloto: import("react").ForwardRefExoticComponent<PilotoProps & import("react").RefAttributes<PilotoHandle>>;
+export default Piloto;

package/dist/react/Status.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from "react";
+import type { ConnectPhase } from "../core/types";
+/** Los tres puntos de «escribiendo». Color y animación por CSS (`.piloto-typing`). */
+export declare function TypingDots(): import("react").JSX.Element;
+export declare function WaitLabel({ phase, since, elsewhere, onLost, showDuration, }: {
+    phase: ConnectPhase;
+    /** Desde que se MANDÓ el mensaje (no desde que se montó la etiqueta). */
+    since?: number | null;
+    elsewhere?: boolean;
+    onLost?: () => void;
+    showDuration?: boolean;
+}): import("react").JSX.Element;
+/** Lo que ocupa el hilo mientras se conecta: tres pasos reales en vez de un «Conectando…» mudo. */
+export declare function ConnectingState({ phase, error, avatar, onRetry }: {
+    phase: ConnectPhase;
+    error: string | null;
+    avatar?: ReactNode;
+    onRetry?: () => void;
+}): import("react").JSX.Element;

package/dist/react/Steps.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+import type { ToolEntry } from "../core/types";
+import { type PilotIcon } from "./context";
+/** La garra de máquina de peluches: el ícono de «usó una herramienta» que no tiene clase propia. */
+export declare function ClawIcon({ className }: {
+    className?: string;
+}): import("react").JSX.Element;
+/** Íconos de casa por `kind`. Lo desconocido cae en la garra. */
+export declare const DEFAULT_TOOL_ICONS: Record<string, PilotIcon>;
+export declare function AgentSteps({ tools, live }: {
+    tools: ToolEntry[];
+    live: boolean;
+}): import("react").JSX.Element;
+/** El detalle de un paso (lista desplegada): rótulo, detalle y ruta. */
+export declare function ToolRow({ tool }: {
+    tool: ToolEntry;
+}): import("react").JSX.Element;
+/** La narración del agente como avance: una palomita por lo que ya dijo que hacía. */
+export declare function Narration({ steps, children }: {
+    steps: string[];
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/react/TextAtPace.d.ts

@@ -0,0 +1,29 @@
+import { type BlockProps } from "streamdown";
+/** 400 ms lineal, como claude.ai. */
+export declare const CHUNK_MS = 400;
+/**
+ * Cuánto del texto se enseña ya. Sólo anima si el turno estaba VIVO al montar.
+ * `whole`: llegó completo de una vez (el remate de los subagentes): se escribe tramo a tramo hasta
+ * el final, sin la regla de «quieto 600 ms = suelta el resto».
+ */
+export declare function useTextAtPace(text: string, live: boolean, whole?: boolean): {
+    visible: string;
+    animate: boolean;
+};
+type Chunk = {
+    start: number;
+    t: number;
+};
+type Registry = Map<string, {
+    chunks: Chunk[];
+    total: number;
+}>;
+export declare const ChunksContext: import("react").Context<{
+    registry: Registry;
+    part: number;
+} | null>;
+/** Un registro por respuesta: vive lo que viva la burbuja. */
+export declare function useChunkRegistry(): Registry;
+/** El bloque de Streamdown con sus tramos. Sólo cambia de plugin cuando cambia su texto. */
+export declare const ChunkedBlock: import("react").NamedExoticComponent<BlockProps>;
+export {};

package/dist/react/context.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentType } from "react";
+import { type ToolVerbs } from "../core/steps";
+import { type PilotStrings } from "./strings";
+/** Un ícono: cualquier componente que acepte `className` (los de lucide-react sirven tal cual). */
+export type PilotIcon = ComponentType<{
+    className?: string;
+}>;
+export type PilotTheme = "light" | "dark" | "auto";
+/** Ajustes del markdown de las respuestas. */
+export interface MarkdownOptions {
+    /** Reescribe el markdown antes de pintarlo (p. ej. `#12` → `[#12](#folio-12)`). */
+    transform?: (md: string) => string;
+    /** Un clic en un enlace. Devuelve `true` si la app lo manejó (no se abre el aviso de salida). */
+    onLinkClick?: (href: string, event: MouseEvent) => boolean;
+}
+export interface PilotoConfig {
+    strings: PilotStrings;
+    toolVerbs: ToolVerbs;
+    /** Ícono por `kind` de paso o por NOMBRE de herramienta. */
+    toolIcons: Record<string, PilotIcon>;
+    formatUserText: (text: string) => string;
+    theme: PilotTheme;
+    /** La piel: `ghosty` (default), `easybits`, `neutral` o una propia (`data-skin`). */
+    skin: string;
+    markdown: MarkdownOptions;
+}
+export declare const PilotoContext: import("react").Context<PilotoConfig>;
+export declare const usePiloto: () => PilotoConfig;
+/** Las clases de la raíz: el alcance de los estilos y el tema. Lo usan también los portales. */
+export declare function rootProps(theme: PilotTheme, skin?: string): {
+    className: string;
+    "data-theme": PilotTheme;
+    "data-skin": string;
+};

package/dist/react/index.d.ts

@@ -0,0 +1,14 @@
+export { Piloto, Piloto as default, type PilotoFeatures, type PilotoHandle, type PilotoProps, type PilotoSlots } from "./Piloto";
+export { usePilot, useSseTransport, type PermissionAnswer, type PermissionHandler, type Pilot, type SendOptions, type TurnDoneInfo, type UsePilotOptions } from "./usePilot";
+export { AgentBubble, CopyUserMessage, DeliveryChips, ReplyOptionButtons, TurnFooter, UsageStats, UserBubble, type AgentBubbleProps } from "./Bubble";
+export { AgentSteps, ClawIcon, DEFAULT_TOOL_ICONS, Narration, ToolRow } from "./Steps";
+export { LinkSafetyModal, Markdown } from "./Markdown";
+export { useTextAtPace } from "./TextAtPace";
+export { Composer, ModelPicker, mimeOf, type ComposerProps, type UploadResult } from "./Composer";
+export { ConfirmCard, DecisionLines } from "./ConfirmCard";
+export { ReferenceChips, Suggestions } from "./Chips";
+export { ConnectingState, TypingDots, WaitLabel } from "./Status";
+export { PilotoContext, usePiloto, type MarkdownOptions, type PilotIcon, type PilotoConfig, type PilotTheme } from "./context";
+export { STRINGS_EN, STRINGS_ES, type PilotStrings } from "./strings";
+export * from "../core";
+export { PilotHttpError, createPostStreamTransport, createSseTransport, readSse, type PilotListener, type PilotTransport, type PostStreamTransportOptions, type SseTransportOptions, type SubscribeOptions, } from "../transport";