@pstdio/ui 0.0.1

package/storybook-static/assets/x-D42ziktz.js

@@ -0,0 +1 @@
+import{c as o}from"./createLucideIcon-CcBBUKX8.js";const c=[["path",{d:"M18 6 6 18",key:"1bl5f8"}],["path",{d:"m6 6 12 12",key:"d8bk6v"}]],t=o("x",c);export{t as X};

package/storybook-static/components/alert.d.ts

@@ -0,0 +1,9 @@
+import { Alert as ChakraAlert } from '@chakra-ui/react';
+import * as React from "react";
+export interface AlertProps extends Omit<ChakraAlert.RootProps, "title"> {
+    startElement?: React.ReactNode;
+    endElement?: React.ReactNode;
+    title?: React.ReactNode;
+    icon?: React.ReactElement;
+}
+export declare const AlertMessage: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;

package/storybook-static/components/breadcrumb.d.ts

@@ -0,0 +1,18 @@
+import { Breadcrumb as ChakraBreadcrumb, SystemStyleObject } from '@chakra-ui/react';
+import * as React from "react";
+export interface BreadcrumbItem {
+    title: React.ReactNode;
+    url?: string;
+    onClick?: () => void;
+}
+export interface BreadcrumbLinkProps {
+    to: string;
+    children: React.ReactNode;
+}
+export interface BreadcrumbProps extends ChakraBreadcrumb.RootProps {
+    separator?: React.ReactNode;
+    separatorGap?: SystemStyleObject["gap"];
+    items: BreadcrumbItem[];
+    linkComponent?: React.ComponentType<BreadcrumbLinkProps>;
+}
+export declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLDivElement>>;

package/storybook-static/components/breadcrumb.stories.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+type StoryFn = () => ReactNode;
+declare const meta: {
+    title: string;
+    component: import('react').ForwardRefExoticComponent<import('./breadcrumb').BreadcrumbProps & import('react').RefAttributes<HTMLDivElement>>;
+    decorators: ((Story: StoryFn) => import("react/jsx-runtime").JSX.Element)[];
+    args: {
+        items: ({
+            title: string;
+            url: string;
+        } | {
+            title: string;
+            url?: undefined;
+        })[];
+        separator: string;
+        separatorGap: string;
+    };
+};
+export default meta;
+export declare const Default: {};
+export declare const IconSeparator: {
+    args: {
+        separator: import("react/jsx-runtime").JSX.Element;
+    };
+};

package/storybook-static/components/chat-ui/agent-types.d.ts

@@ -0,0 +1,205 @@
+export type AgentId = "opencode" | "claude-code";
+export type SessionMessageRole = "user" | "assistant" | "tool" | "system" | "developer";
+export type TextPart = {
+    type: "text";
+    text: string;
+};
+export type ReasoningPart = {
+    type: "reasoning";
+    text: string;
+};
+export type ToolPartActionType = "read" | "write" | "execute" | "network" | "other";
+export type ToolPartStatus = "pending" | "running" | "completed" | "failed" | "denied";
+export type ToolPart = {
+    type: "tool";
+    tool: string;
+    callId?: string;
+    actionType?: ToolPartActionType;
+    status?: ToolPartStatus;
+    state?: {
+        status?: string;
+        input?: unknown;
+        output?: unknown;
+        errorText?: string;
+        metadata?: unknown;
+    };
+};
+export type StepStartPart = {
+    type: "step-start";
+    snapshot?: string;
+};
+export type StepFinishPart = {
+    type: "step-finish";
+    reason?: string;
+    snapshot?: string;
+    cost?: number;
+    tokens?: unknown;
+};
+export type PatchPart = {
+    type: "patch";
+    hash?: string;
+    files?: unknown;
+};
+export type FilePart = {
+    type: "file";
+    mediaType?: string;
+    filename?: string;
+    url: string;
+};
+export type LoadingPart = {
+    type: "loading";
+};
+export type ErrorPart = {
+    type: "error";
+    errorType: "timeout" | "crash" | "permission" | "other";
+};
+export type TokenUsagePart = {
+    type: "token_usage";
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+};
+export type SessionMessagePart = TextPart | ReasoningPart | ToolPart | StepStartPart | StepFinishPart | PatchPart | FilePart | LoadingPart | ErrorPart | TokenUsagePart;
+export type SessionMessage = {
+    id: string;
+    role: SessionMessageRole;
+    parts: SessionMessagePart[];
+    index?: number;
+    createdAt?: number;
+    modelId?: string;
+    providerId?: string;
+    tokens?: {
+        input?: number;
+        output?: number;
+        reasoning?: number;
+        cache?: {
+            read?: number;
+            write?: number;
+        };
+    };
+};
+export type SessionStartInput = {
+    prompt: string;
+    title?: string;
+    model?: string | null;
+    cwd?: string;
+    eventStore?: EventStore;
+};
+export type SessionStartResult = {
+    sessionId: string;
+    process?: SpawnedProcess;
+};
+export type SessionMessageInput = {
+    sessionId: string;
+    prompt: string;
+    model?: string | null;
+    cwd?: string;
+    messageOffset?: number;
+};
+export type SessionMessagesInput = {
+    cwd?: string | null;
+};
+export type AvailabilityInfo = {
+    type: "INSTALLED" | "NOT_FOUND";
+};
+export type AgentModel = {
+    id: string;
+};
+export type AgentCapability = "SessionFork" | "ContextUsage" | "Approvals";
+export type SessionListEntry = {
+    id: string;
+    title: string;
+    directory: string;
+    updatedAt: string;
+};
+export type SessionExport = {
+    session: SessionListEntry;
+    messages: SessionMessage[];
+};
+export type LaunchInput = {
+    prompt: string;
+    title?: string;
+    model?: string | null;
+    cwd?: string;
+};
+export type LaunchResult = {
+    pid?: number;
+    sessionId?: string;
+};
+export type RawLogEvent = {
+    type: "stdout";
+    data: string;
+} | {
+    type: "stderr";
+    data: string;
+} | {
+    type: "session_id";
+    sessionId: string;
+} | {
+    type: "message_id";
+    messageId: string;
+} | {
+    type: "ready";
+} | {
+    type: "finished";
+};
+export type JsonPatch = {
+    op: "add" | "replace" | "remove";
+    path: string;
+    value?: unknown;
+};
+export type EventStore = {
+    push(patch: JsonPatch): void;
+    getHistory(): JsonPatch[];
+    subscribe(): AsyncIterable<JsonPatch>;
+    historyPlusStream(): AsyncIterable<JsonPatch>;
+};
+export type SpawnedProcess = {
+    sessionId: string;
+    stdin: import('node:stream').Writable;
+    kill(): void;
+    onExit: Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+};
+export type ResumeResult = {
+    process?: SpawnedProcess;
+};
+export type ApprovalRequest = {
+    id: string;
+    toolName: string;
+    toolInput: unknown;
+    toolUseId: string;
+};
+export type ApprovalResponse = {
+    id: string;
+    decision: "approve" | "deny" | "timeout";
+};
+export type ApprovalService = {
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    handleResponse(response: ApprovalResponse): void;
+    dispose(): void;
+};
+export type AgentService = {
+    id: AgentId;
+    name: string;
+    capabilities(): AgentCapability[];
+    checkAvailability(): AvailabilityInfo;
+    listModels(): AgentModel[];
+    startSession(input: SessionStartInput): Promise<SessionStartResult>;
+    resumeSession(input: SessionMessageInput, eventStore: EventStore, approvalService?: ApprovalService): Promise<ResumeResult>;
+    getMessages(sessionId: string, input?: SessionMessagesInput): Promise<SessionMessage[]>;
+    listSessions(input?: {
+        cwd?: string;
+    }): Promise<SessionListEntry[]>;
+    exportSession(sessionId: string): Promise<SessionExport>;
+    launchSession(input: LaunchInput): Promise<LaunchResult>;
+    setSessionTitle?(sessionId: string, title: string): Promise<void>;
+};
+export type AgentRegistry = {
+    get(id: AgentId): AgentService | null;
+    list(): AgentService[];
+    checkAll(): Record<AgentId, AvailabilityInfo>;
+};

package/storybook-static/components/chat-ui/components/ai-conversation.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ChatPrimitives } from './ai-conversation';
+declare const meta: Meta<typeof ChatPrimitives.Root>;
+export default meta;
+type Story = StoryObj<typeof ChatPrimitives.Root>;
+export declare const FullConversationPreview: Story;

package/storybook-static/components/chat-ui/components/ai-message.d.ts

@@ -0,0 +1,94 @@
+import { HTMLChakraProps, RecipeVariantProps } from '@chakra-ui/react';
+declare const recipe: import('@chakra-ui/react').SlotRecipeDefinition<"content" | "root", {
+    from: {
+        user: {
+            root: {
+                mb: "md";
+                flexDirection: "row";
+                "& > div": {
+                    marginLeft: "lg";
+                };
+            };
+            content: {
+                bg: "bg.muted";
+                borderBottomRightRadius: number;
+            };
+        };
+        assistant: {
+            root: {
+                mb: "md";
+                flexDirection: "row";
+                justifyContent: "start";
+                "& > div": {
+                    marginRight: "lg";
+                };
+            };
+        };
+        developer: {
+            root: {
+                width: "full";
+                flexDirection: "row-reverse";
+            };
+            content: {
+                width: "full";
+            };
+        };
+    };
+    size: {
+        sm: {
+            root: {
+                gap: "xs";
+            };
+            content: {
+                px: "xs";
+                py: "xs";
+                textStyle: "xs";
+            };
+        };
+        md: {
+            content: {
+                px: "xs";
+                py: "xs";
+            };
+        };
+        lg: {
+            root: {
+                gap: "md";
+            };
+            content: {
+                px: "sm";
+                py: "xs";
+                textStyle: "md";
+            };
+        };
+    };
+    shape: {
+        rounded: {
+            content: {
+                rounded: "lg";
+            };
+        };
+        pill: {
+            content: {
+                rounded: "full";
+            };
+        };
+        square: {
+            content: {
+                rounded: "none";
+            };
+        };
+    };
+}>;
+type VariantProps = RecipeVariantProps<typeof recipe>;
+export interface MessageRootProps extends HTMLChakraProps<"div">, VariantProps {
+}
+export declare const MessageRoot: import('react').ForwardRefExoticComponent<MessageRootProps & import('react').RefAttributes<HTMLDivElement>>;
+export interface MessageContentProps extends HTMLChakraProps<"div">, VariantProps {
+}
+export declare const MessageContent: import('react').ForwardRefExoticComponent<MessageContentProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const ChatMessage: {
+    readonly Root: import('react').ForwardRefExoticComponent<MessageRootProps & import('react').RefAttributes<HTMLDivElement>>;
+    readonly Content: import('react').ForwardRefExoticComponent<MessageContentProps & import('react').RefAttributes<HTMLDivElement>>;
+};
+export {};

package/storybook-static/components/chat-ui/components/ai-message.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ChatMessage } from './ai-message';
+declare const meta: Meta<typeof ChatMessage.Root>;
+export default meta;
+type Story = StoryObj<typeof ChatMessage.Root>;
+export declare const UserAndAssistant: Story;

package/storybook-static/components/chat-ui/components/ai-response.d.ts

@@ -0,0 +1,6 @@
+import { BoxProps } from '@chakra-ui/react';
+export interface ChatRichContentProps extends Omit<BoxProps, "children"> {
+    children: string;
+}
+export declare const ChatRichContent: (props: ChatRichContentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Response: (props: ChatRichContentProps) => import("react/jsx-runtime").JSX.Element;

package/storybook-static/components/chat-ui/components/ai-response.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Response } from './ai-response';
+declare const meta: Meta<typeof Response>;
+export default meta;
+type Story = StoryObj<typeof Response>;
+export declare const AssistantResponse: Story;
+export declare const UserPromptAsContent: Story;

package/storybook-static/components/chat-ui/components/approval-prompt.d.ts

@@ -0,0 +1,8 @@
+interface ApprovalPromptProps {
+    toolName: string;
+    toolInput?: unknown;
+    onApprove: () => void;
+    onDeny: () => void;
+}
+export declare const ApprovalPrompt: (props: ApprovalPromptProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/storybook-static/components/chat-ui/components/attachment-list.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { ResourceBadgeProps } from '../../resource-badge';
+export type AttachmentListRenderBadge = (props: AttachmentListItemRenderProps) => ReactNode;
+export interface AttachmentListItemRenderProps {
+    attachmentId: string;
+    onSelect?: () => void;
+    onRemove?: () => void;
+    size: ResourceBadgeProps["size"];
+    tone: ResourceBadgeProps["tone"];
+}
+export interface AttachmentListProps {
+    attachments?: string[];
+    onSelect?: (attachmentId: string) => void;
+    onRemove?: (attachmentId: string) => void;
+    renderBadge?: AttachmentListRenderBadge;
+    size?: ResourceBadgeProps["size"];
+    tone?: ResourceBadgeProps["tone"];
+}
+/**
+ * Simple attachment list component that displays resource badges.
+ *
+ */
+export declare const AttachmentList: (props: AttachmentListProps) => import("react/jsx-runtime").JSX.Element | null;

package/storybook-static/components/chat-ui/components/attachment-list.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { AttachmentList } from './attachment-list';
+declare const meta: Meta<typeof AttachmentList>;
+export default meta;
+type Story = StoryObj<typeof AttachmentList>;
+export declare const Default: Story;

package/storybook-static/components/chat-ui/components/auto-scroll.d.ts

@@ -0,0 +1,10 @@
+export interface AutoScrollProps {
+    userMessageCount: number;
+}
+interface ShouldAutoScrollArgs {
+    previousUserMessageCount: number;
+    userMessageCount: number;
+}
+export declare const shouldAutoScroll: (args: ShouldAutoScrollArgs) => boolean;
+export declare function AutoScroll(props: AutoScrollProps): null;
+export {};

package/storybook-static/components/chat-ui/components/chat-input.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+interface ChatInputProps {
+    defaultState: string;
+    placeholder?: string;
+    onSubmit?: (text: string, attachments: string[]) => void;
+    onInterrupt?: () => void;
+    streaming?: boolean;
+    attachedResources?: string[];
+    onClearAttachments?: () => void;
+    isDisabled?: boolean;
+    onChange?: (text: string) => void;
+    attachmentList?: ReactNode;
+    actions?: ReactNode;
+}
+export declare const ChatInput: (props: ChatInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/storybook-static/components/chat-ui/components/chat-input.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ChatInput } from './chat-input';
+declare const meta: Meta<typeof ChatInput>;
+export default meta;
+type Story = StoryObj<typeof ChatInput>;
+export declare const Default: Story;
+export declare const WithAttachments: Story;

package/storybook-static/components/chat-ui/components/chat-panel.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { SessionMessage } from './message-types';
+interface ChatPanelProps {
+    messages: SessionMessage[];
+    streaming?: boolean;
+    emptyStateTitle: string;
+    emptyStateDescription: string;
+    chatInputPlaceholder: string;
+    onSubmitMessage?: (text: string, attachments: string[]) => void;
+    actions?: ReactNode;
+    repoMenu?: ReactNode;
+    attachedResources?: string[];
+    onClearAttachments?: () => void;
+    attachmentList?: ReactNode;
+    approvalPrompt?: ReactNode;
+}
+export declare const ChatPanel: (props: ChatPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/storybook-static/components/chat-ui/components/chat-panel.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ChatPanel } from './chat-panel';
+declare const meta: Meta<typeof ChatPanel>;
+export default meta;
+type Story = StoryObj<typeof ChatPanel>;
+export declare const Empty: Story;
+export declare const Conversation: Story;
+export declare const Streaming: Story;

package/storybook-static/components/chat-ui/components/message-parts-renderer.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { SessionMessage } from '../agent-types';
+import { ToolInvocationTimelineProps } from './tool-invocation-timeline';
+type ToolInvocationTimelineComponent = (props: ToolInvocationTimelineProps) => ReactNode;
+export interface MessagePartsProps {
+    message: SessionMessage;
+    streaming?: boolean;
+    onOpenFile?: (filePath: string) => void;
+    toolInvocationTimeline?: ToolInvocationTimelineComponent;
+}
+export declare function MessagePartsRenderer(props: MessagePartsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/storybook-static/components/chat-ui/components/message-parts-renderer.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { MessagePartsRenderer } from './message-parts-renderer';
+declare const meta: Meta<typeof MessagePartsRenderer>;
+export default meta;
+type Story = StoryObj<typeof MessagePartsRenderer>;
+export declare const AssistantReasoningAndToolParts: Story;
+export declare const UserTextParts: Story;

package/storybook-static/components/chat-ui/components/message-types.d.ts

@@ -0,0 +1,6 @@
+import { SessionMessage, SessionMessagePart, ToolPart } from '../agent-types';
+export type { SessionMessage, SessionMessagePart, ToolPart };
+export type MessageOrigin = "user" | "assistant" | "developer";
+export declare const getMessageOrigin: (role: string) => MessageOrigin;
+export declare const isReasoningToolOnlyMessage: (message: SessionMessage) => boolean;
+export declare const mergeReasoningToolOnlyMessages: (messages: SessionMessage[]) => SessionMessage[];

package/storybook-static/components/chat-ui/components/model-swap-separator.d.ts

@@ -0,0 +1,5 @@
+export interface ModelSwapSeparatorProps {
+    fromModel: string;
+    toModel: string;
+}
+export declare const ModelSwapSeparator: (props: ModelSwapSeparatorProps) => import("react/jsx-runtime").JSX.Element;

package/storybook-static/components/chat-ui/components/model-swap-separator.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ModelSwapSeparator } from './model-swap-separator';
+declare const meta: Meta<typeof ModelSwapSeparator>;
+export default meta;
+type Story = StoryObj<typeof ModelSwapSeparator>;
+export declare const Default: Story;

package/storybook-static/components/chat-ui/components/send-button.d.ts

@@ -0,0 +1,7 @@
+import { IconButtonProps } from '@chakra-ui/react';
+export interface SendButtonProps extends IconButtonProps {
+    shortcut?: string;
+    title?: string;
+    canInterrupt: boolean;
+}
+export declare const SendButton: (props: SendButtonProps) => import("react/jsx-runtime").JSX.Element;

package/storybook-static/components/chat-ui/components/timeline.d.ts

@@ -0,0 +1,86 @@
+import { Timeline as ChakraTimeline } from '@chakra-ui/react';
+import { ReactNode } from 'react';
+import { IconName } from '../utils/get-icon';
+export declare const Timeline: typeof ChakraTimeline;
+export type TimelineDoc = {
+    items: Item[];
+};
+export type Item = {
+    id?: string;
+    timestamp?: string;
+    indicator?: Indicator;
+    title: TitleSegment[];
+    blocks?: Block[];
+    expandable?: boolean;
+};
+export type Indicator = {
+    type: "icon";
+    icon: IconName;
+    color?: string;
+} | {
+    type: "avatar";
+    src: string;
+    alt?: string;
+} | {
+    type: "none";
+};
+export type TitleSegment = {
+    kind: "text";
+    text: string;
+    bold?: boolean;
+    muted?: boolean;
+} | {
+    kind: "avatar";
+    src: string;
+    alt?: string;
+} | {
+    kind: "diff";
+    fileName: string;
+    filePath?: string;
+    additions?: number;
+    deletions?: number;
+} | {
+    kind: "link";
+    text: string;
+    href?: string;
+    filePath?: string;
+    bold?: boolean;
+    muted?: boolean;
+    variant?: "default" | "bubble";
+};
+export type Block = {
+    type: "comment";
+    text: string;
+    reactions?: {
+        clap?: number;
+    };
+} | {
+    type: "code";
+    language: string;
+    code: string;
+    editable?: boolean;
+} | {
+    type: "diff";
+    language?: string;
+    original: string;
+    modified: string;
+    sideBySide?: boolean;
+} | {
+    type: "input";
+    placeholder?: string;
+} | {
+    type: "text";
+    text: string;
+} | {
+    type: "references";
+    references: string[];
+} | {
+    type: "component";
+    render: (ctx: {
+        onOpenFile?: (filePath: string) => void;
+    }) => ReactNode;
+};
+export declare function TimelineFromJSON({ data, onOpenFile }: {
+    data: TimelineDoc;
+    onOpenFile?: (filePath: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/storybook-static/components/chat-ui/components/tool-invocation-timeline.d.ts

@@ -0,0 +1,7 @@
+import { ToolPart } from './message-types';
+export interface ToolInvocationTimelineProps {
+    invocations: ToolPart[];
+    labeledBlocks?: boolean;
+    onOpenFile?: (filePath: string) => void;
+}
+export declare function ToolInvocationTimeline(props: ToolInvocationTimelineProps): import("react/jsx-runtime").JSX.Element;

package/storybook-static/components/chat-ui/components/tool-invocation-timeline.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ToolInvocationTimeline } from './tool-invocation-timeline';
+declare const meta: Meta<typeof ToolInvocationTimeline>;
+export default meta;
+type Story = StoryObj<typeof ToolInvocationTimeline>;
+export declare const FromConversationData: Story;