@nadicodeai/ui 0.1.0

package/dist/components/ai-elements/speech-input.d.ts

@@ -0,0 +1,55 @@
+import { Button } from "../button";
+import type { ComponentProps } from "react";
+interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    start(): void;
+    stop(): void;
+    onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onend: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void) | null;
+    onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void) | null;
+}
+interface SpeechRecognitionEvent extends Event {
+    results: SpeechRecognitionResultList;
+    resultIndex: number;
+}
+interface SpeechRecognitionResultList {
+    readonly length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResult;
+}
+interface SpeechRecognitionResult {
+    readonly length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+    isFinal: boolean;
+}
+interface SpeechRecognitionAlternative {
+    transcript: string;
+    confidence: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    error: string;
+}
+declare global {
+    interface Window {
+        SpeechRecognition: new () => SpeechRecognition;
+        webkitSpeechRecognition: new () => SpeechRecognition;
+    }
+}
+export type SpeechInputProps = ComponentProps<typeof Button> & {
+    onTranscriptionChange?: (text: string) => void;
+    /**
+     * Callback for when audio is recorded using MediaRecorder fallback.
+     * This is called in browsers that don't support the Web Speech API (Firefox, Safari).
+     * The callback receives an audio Blob that should be sent to a transcription service.
+     * Return the transcribed text, which will be passed to onTranscriptionChange.
+     */
+    onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+    lang?: string;
+};
+export declare const SpeechInput: ({ className, onTranscriptionChange, onAudioRecorded, lang, ...props }: SpeechInputProps) => import("react").JSX.Element;
+export {};
+//# sourceMappingURL=speech-input.d.ts.map

package/dist/components/ai-elements/speech-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speech-input.d.ts","sourceRoot":"","sources":["../../../src/components/ai-elements/speech-input.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAI7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,UAAU,iBAAkB,SAAQ,WAAW;IAC7C,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IACb,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/D,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7D,QAAQ,EACJ,CAAC,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,EAAE,sBAAsB,KAAK,IAAI,CAAC,GAC/D,IAAI,CAAC;IACT,OAAO,EACH,CAAC,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,EAAE,2BAA2B,KAAK,IAAI,CAAC,GACpE,IAAI,CAAC;CACV;AAED,UAAU,sBAAuB,SAAQ,KAAK;IAC5C,OAAO,EAAE,2BAA2B,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,2BAA2B;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAAC;IAC7C,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAAC;CAC1C;AAED,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,4BAA4B,CAAC;IAClD,CAAC,KAAK,EAAE,MAAM,GAAG,4BAA4B,CAAC;IAC9C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,4BAA4B;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,2BAA4B,SAAQ,KAAK;IACjD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,iBAAiB,EAAE,UAAU,iBAAiB,CAAC;QAC/C,uBAAuB,EAAE,UAAU,iBAAiB,CAAC;KACtD;CACF;AAID,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,OAAO,MAAM,CAAC,GAAG;IAC7D,qBAAqB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C;;;;;OAKG;IACH,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAkBF,eAAO,MAAM,WAAW,GAAI,uEAMzB,gBAAgB,gCAmOlB,CAAC"}

package/dist/components/ai-elements/speech-input.js

@@ -0,0 +1,187 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "../button.js";
+import { Spinner } from "../spinner.js";
+import { cn } from "../../lib/utils.js";
+import { MicIcon, SquareIcon } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+const detectSpeechInputMode = () => {
+    if (typeof window === "undefined") {
+        return "none";
+    }
+    if ("SpeechRecognition" in window || "webkitSpeechRecognition" in window) {
+        return "speech-recognition";
+    }
+    if ("MediaRecorder" in window && "mediaDevices" in navigator) {
+        return "media-recorder";
+    }
+    return "none";
+};
+export const SpeechInput = ({ className, onTranscriptionChange, onAudioRecorded, lang = "en-US", ...props }) => {
+    const [isListening, setIsListening] = useState(false);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [mode] = useState(detectSpeechInputMode);
+    const [isRecognitionReady, setIsRecognitionReady] = useState(false);
+    const recognitionRef = useRef(null);
+    const mediaRecorderRef = useRef(null);
+    const streamRef = useRef(null);
+    const audioChunksRef = useRef([]);
+    const onTranscriptionChangeRef = useRef(onTranscriptionChange);
+    const onAudioRecordedRef = useRef(onAudioRecorded);
+    // Keep refs in sync
+    onTranscriptionChangeRef.current = onTranscriptionChange;
+    onAudioRecordedRef.current = onAudioRecorded;
+    // Initialize Speech Recognition when mode is speech-recognition
+    useEffect(() => {
+        if (mode !== "speech-recognition") {
+            return;
+        }
+        const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+        const speechRecognition = new SpeechRecognition();
+        speechRecognition.continuous = true;
+        speechRecognition.interimResults = true;
+        speechRecognition.lang = lang;
+        const handleStart = () => {
+            setIsListening(true);
+        };
+        const handleEnd = () => {
+            setIsListening(false);
+        };
+        const handleResult = (event) => {
+            const speechEvent = event;
+            let finalTranscript = "";
+            for (let i = speechEvent.resultIndex; i < speechEvent.results.length; i += 1) {
+                const result = speechEvent.results[i];
+                if (result.isFinal) {
+                    finalTranscript += result[0]?.transcript ?? "";
+                }
+            }
+            if (finalTranscript) {
+                onTranscriptionChangeRef.current?.(finalTranscript);
+            }
+        };
+        const handleError = () => {
+            setIsListening(false);
+        };
+        speechRecognition.addEventListener("start", handleStart);
+        speechRecognition.addEventListener("end", handleEnd);
+        speechRecognition.addEventListener("result", handleResult);
+        speechRecognition.addEventListener("error", handleError);
+        recognitionRef.current = speechRecognition;
+        setIsRecognitionReady(true);
+        return () => {
+            speechRecognition.removeEventListener("start", handleStart);
+            speechRecognition.removeEventListener("end", handleEnd);
+            speechRecognition.removeEventListener("result", handleResult);
+            speechRecognition.removeEventListener("error", handleError);
+            speechRecognition.stop();
+            recognitionRef.current = null;
+            setIsRecognitionReady(false);
+        };
+    }, [mode, lang]);
+    // Cleanup MediaRecorder and stream on unmount
+    useEffect(() => () => {
+        if (mediaRecorderRef.current?.state === "recording") {
+            mediaRecorderRef.current.stop();
+        }
+        if (streamRef.current) {
+            for (const track of streamRef.current.getTracks()) {
+                track.stop();
+            }
+        }
+    }, []);
+    // Start MediaRecorder recording
+    const startMediaRecorder = useCallback(async () => {
+        if (!onAudioRecordedRef.current) {
+            return;
+        }
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            streamRef.current = stream;
+            const mediaRecorder = new MediaRecorder(stream);
+            audioChunksRef.current = [];
+            const handleDataAvailable = (event) => {
+                if (event.data.size > 0) {
+                    audioChunksRef.current.push(event.data);
+                }
+            };
+            const handleStop = async () => {
+                for (const track of stream.getTracks()) {
+                    track.stop();
+                }
+                streamRef.current = null;
+                const audioBlob = new Blob(audioChunksRef.current, {
+                    type: "audio/webm",
+                });
+                if (audioBlob.size > 0 && onAudioRecordedRef.current) {
+                    setIsProcessing(true);
+                    try {
+                        const transcript = await onAudioRecordedRef.current(audioBlob);
+                        if (transcript) {
+                            onTranscriptionChangeRef.current?.(transcript);
+                        }
+                    }
+                    catch {
+                        // Error handling delegated to the onAudioRecorded caller
+                    }
+                    finally {
+                        setIsProcessing(false);
+                    }
+                }
+            };
+            const handleError = () => {
+                setIsListening(false);
+                for (const track of stream.getTracks()) {
+                    track.stop();
+                }
+                streamRef.current = null;
+            };
+            mediaRecorder.addEventListener("dataavailable", handleDataAvailable);
+            mediaRecorder.addEventListener("stop", handleStop);
+            mediaRecorder.addEventListener("error", handleError);
+            mediaRecorderRef.current = mediaRecorder;
+            mediaRecorder.start();
+            setIsListening(true);
+        }
+        catch {
+            setIsListening(false);
+        }
+    }, []);
+    // Stop MediaRecorder recording
+    const stopMediaRecorder = useCallback(() => {
+        if (mediaRecorderRef.current?.state === "recording") {
+            mediaRecorderRef.current.stop();
+        }
+        setIsListening(false);
+    }, []);
+    const toggleListening = useCallback(() => {
+        if (mode === "speech-recognition" && recognitionRef.current) {
+            if (isListening) {
+                recognitionRef.current.stop();
+            }
+            else {
+                recognitionRef.current.start();
+            }
+        }
+        else if (mode === "media-recorder") {
+            if (isListening) {
+                stopMediaRecorder();
+            }
+            else {
+                startMediaRecorder();
+            }
+        }
+    }, [mode, isListening, startMediaRecorder, stopMediaRecorder]);
+    // Determine if button should be disabled
+    const isDisabled = mode === "none" ||
+        (mode === "speech-recognition" && !isRecognitionReady) ||
+        (mode === "media-recorder" && !onAudioRecorded) ||
+        isProcessing;
+    return (_jsxs("div", { className: "relative inline-flex items-center justify-center", children: [isListening &&
+                [0, 1, 2].map((index) => (_jsx("div", { className: "absolute inset-0 animate-ping rounded-full border-2 border-destructive/30", style: {
+                        animationDelay: `${index * 0.3}s`,
+                        animationDuration: "2s",
+                    } }, index))), _jsxs(Button, { className: cn("relative z-10 rounded-full transition-all duration-300", isListening
+                    ? "bg-destructive text-destructive-foreground hover:bg-destructive/80 hover:text-destructive-foreground"
+                    : "bg-primary text-primary-foreground hover:bg-primary/80 hover:text-primary-foreground", className), disabled: isDisabled, onClick: toggleListening, ...props, children: [isProcessing && _jsx(Spinner, {}), !isProcessing && isListening && _jsx(SquareIcon, { className: "size-4" }), !(isProcessing || isListening) && _jsx(MicIcon, { className: "size-4" })] })] }));
+};

package/dist/components/ai-elements/stack-trace.d.ts

@@ -0,0 +1,38 @@
+import { Button } from "../button";
+import { CollapsibleContent, CollapsibleTrigger } from "../collapsible";
+import type { ComponentProps } from "react";
+export type StackTraceProps = ComponentProps<"div"> & {
+    trace: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+};
+export declare const StackTrace: import("react").MemoExoticComponent<({ trace, className, open, defaultOpen, onOpenChange, onFilePathClick, children, ...props }: StackTraceProps) => import("react").JSX.Element>;
+export type StackTraceHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+export declare const StackTraceHeader: import("react").MemoExoticComponent<({ className, children, ...props }: StackTraceHeaderProps) => import("react").JSX.Element>;
+export type StackTraceErrorProps = ComponentProps<"div">;
+export declare const StackTraceError: import("react").MemoExoticComponent<({ className, children, ...props }: StackTraceErrorProps) => import("react").JSX.Element>;
+export type StackTraceErrorTypeProps = ComponentProps<"span">;
+export declare const StackTraceErrorType: import("react").MemoExoticComponent<({ className, children, ...props }: StackTraceErrorTypeProps) => import("react").JSX.Element>;
+export type StackTraceErrorMessageProps = ComponentProps<"span">;
+export declare const StackTraceErrorMessage: import("react").MemoExoticComponent<({ className, children, ...props }: StackTraceErrorMessageProps) => import("react").JSX.Element>;
+export type StackTraceActionsProps = ComponentProps<"div">;
+export declare const StackTraceActions: import("react").MemoExoticComponent<({ className, children, ...props }: StackTraceActionsProps) => import("react").JSX.Element>;
+export type StackTraceCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const StackTraceCopyButton: import("react").MemoExoticComponent<({ onCopy, onError, timeout, className, children, ...props }: StackTraceCopyButtonProps) => import("react").JSX.Element>;
+export type StackTraceExpandButtonProps = ComponentProps<"div">;
+export declare const StackTraceExpandButton: import("react").MemoExoticComponent<({ className, ...props }: StackTraceExpandButtonProps) => import("react").JSX.Element>;
+export type StackTraceContentProps = ComponentProps<typeof CollapsibleContent> & {
+    maxHeight?: number;
+};
+export declare const StackTraceContent: import("react").MemoExoticComponent<({ className, maxHeight, children, ...props }: StackTraceContentProps) => import("react").JSX.Element>;
+export type StackTraceFramesProps = ComponentProps<"div"> & {
+    showInternalFrames?: boolean;
+};
+export declare const StackTraceFrames: import("react").MemoExoticComponent<({ className, showInternalFrames, ...props }: StackTraceFramesProps) => import("react").JSX.Element>;
+//# sourceMappingURL=stack-trace.d.ts.map

package/dist/components/ai-elements/stack-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-trace.d.ts","sourceRoot":"","sources":["../../../src/components/ai-elements/stack-trace.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAEL,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAQlC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AA4I5C,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9E,CAAC;AAEF,eAAO,MAAM,UAAU,mIAUlB,eAAe,iCAkCnB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9E,eAAO,MAAM,gBAAgB,0EACS,qBAAqB,iCAkB1D,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;AAEzD,eAAO,MAAM,eAAe,0EACU,oBAAoB,iCAYzD,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAE9D,eAAO,MAAM,mBAAmB,0EACM,wBAAwB,iCAY7D,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAEjE,eAAO,MAAM,sBAAsB,0EACG,2BAA2B,iCAShE,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;AAS3D,eAAO,MAAM,iBAAiB,0EACQ,sBAAsB,iCAW3D,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,cAAc,CAAC,OAAO,MAAM,CAAC,GAAG;IACtE,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,oBAAoB,oGAQ5B,yBAAyB,iCA6C7B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;AAEhE,eAAO,MAAM,sBAAsB,gEACP,2BAA2B,iCAiBtD,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,cAAc,CACjD,OAAO,kBAAkB,CAC1B,GAAG;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,iBAAiB,qFAMzB,sBAAsB,iCAmB1B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IAC1D,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AA2CF,eAAO,MAAM,gBAAgB,oFAKxB,qBAAqB,iCA8CzB,CAAC"}

package/dist/components/ai-elements/stack-trace.js

@@ -0,0 +1,194 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { Button } from "../button.js";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger, } from "../collapsible.js";
+import { cn } from "../../lib/utils.js";
+import { AlertTriangleIcon, CheckIcon, ChevronDownIcon, CopyIcon, } from "lucide-react";
+import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+// Regex patterns for parsing stack traces
+const STACK_FRAME_WITH_PARENS_REGEX = /^at\s+(.+?)\s+\((.+):(\d+):(\d+)\)$/;
+const STACK_FRAME_WITHOUT_FN_REGEX = /^at\s+(.+):(\d+):(\d+)$/;
+const ERROR_TYPE_REGEX = /^(\w+Error|Error):\s*(.*)$/;
+const AT_PREFIX_REGEX = /^at\s+/;
+const StackTraceContext = createContext(null);
+const useStackTrace = () => {
+    const context = useContext(StackTraceContext);
+    if (!context) {
+        throw new Error("StackTrace components must be used within StackTrace");
+    }
+    return context;
+};
+const parseStackFrame = (line) => {
+    const trimmed = line.trim();
+    // Pattern: at functionName (filePath:line:column)
+    const withParensMatch = trimmed.match(STACK_FRAME_WITH_PARENS_REGEX);
+    if (withParensMatch) {
+        const [, functionName, filePath, lineNum, colNum] = withParensMatch;
+        const isInternal = filePath.includes("node_modules") ||
+            filePath.startsWith("node:") ||
+            filePath.includes("internal/");
+        return {
+            columnNumber: colNum ? Number.parseInt(colNum, 10) : null,
+            filePath: filePath ?? null,
+            functionName: functionName ?? null,
+            isInternal,
+            lineNumber: lineNum ? Number.parseInt(lineNum, 10) : null,
+            raw: trimmed,
+        };
+    }
+    // Pattern: at filePath:line:column (no function name)
+    const withoutFnMatch = trimmed.match(STACK_FRAME_WITHOUT_FN_REGEX);
+    if (withoutFnMatch) {
+        const [, filePath, lineNum, colNum] = withoutFnMatch;
+        const isInternal = (filePath?.includes("node_modules") ?? false) ||
+            (filePath?.startsWith("node:") ?? false) ||
+            (filePath?.includes("internal/") ?? false);
+        return {
+            columnNumber: colNum ? Number.parseInt(colNum, 10) : null,
+            filePath: filePath ?? null,
+            functionName: null,
+            isInternal,
+            lineNumber: lineNum ? Number.parseInt(lineNum, 10) : null,
+            raw: trimmed,
+        };
+    }
+    // Fallback: unparseable line
+    return {
+        columnNumber: null,
+        filePath: null,
+        functionName: null,
+        isInternal: trimmed.includes("node_modules") || trimmed.includes("node:"),
+        lineNumber: null,
+        raw: trimmed,
+    };
+};
+const parseStackTrace = (trace) => {
+    const lines = trace.split("\n").filter((line) => line.trim());
+    if (lines.length === 0) {
+        return {
+            errorMessage: trace,
+            errorType: null,
+            frames: [],
+            raw: trace,
+        };
+    }
+    const firstLine = lines[0].trim();
+    let errorType = null;
+    let errorMessage = firstLine;
+    // Try to extract error type from "ErrorType: message" format
+    const errorMatch = firstLine.match(ERROR_TYPE_REGEX);
+    if (errorMatch) {
+        const [, type, msg] = errorMatch;
+        errorType = type;
+        errorMessage = msg || "";
+    }
+    // Parse stack frames (lines starting with "at")
+    const frames = lines
+        .slice(1)
+        .filter((line) => line.trim().startsWith("at "))
+        .map(parseStackFrame);
+    return {
+        errorMessage,
+        errorType,
+        frames,
+        raw: trace,
+    };
+};
+export const StackTrace = memo(({ trace, className, open, defaultOpen = false, onOpenChange, onFilePathClick, children, ...props }) => {
+    const [isOpen, setIsOpen] = useControllableState({
+        defaultProp: defaultOpen,
+        onChange: onOpenChange,
+        prop: open,
+    });
+    const parsedTrace = useMemo(() => parseStackTrace(trace), [trace]);
+    const contextValue = useMemo(() => ({
+        isOpen,
+        onFilePathClick,
+        raw: trace,
+        setIsOpen,
+        trace: parsedTrace,
+    }), [parsedTrace, trace, isOpen, setIsOpen, onFilePathClick]);
+    return (_jsx(StackTraceContext.Provider, { value: contextValue, children: _jsx("div", { className: cn("not-prose w-full overflow-hidden rounded-lg border bg-background font-mono text-sm", className), ...props, children: children }) }));
+});
+export const StackTraceHeader = memo(({ className, children, ...props }) => {
+    const { isOpen, setIsOpen } = useStackTrace();
+    return (_jsx(Collapsible, { onOpenChange: setIsOpen, open: isOpen, children: _jsx(CollapsibleTrigger, { asChild: true, ...props, children: _jsx("div", { className: cn("flex w-full cursor-pointer items-center gap-3 p-3 text-left transition-colors hover:bg-muted/50", className), children: children }) }) }));
+});
+export const StackTraceError = memo(({ className, children, ...props }) => (_jsxs("div", { className: cn("flex flex-1 items-center gap-2 overflow-hidden", className), ...props, children: [_jsx(AlertTriangleIcon, { className: "size-4 shrink-0 text-destructive" }), children] })));
+export const StackTraceErrorType = memo(({ className, children, ...props }) => {
+    const { trace } = useStackTrace();
+    return (_jsx("span", { className: cn("shrink-0 font-semibold text-destructive", className), ...props, children: children ?? trace.errorType }));
+});
+export const StackTraceErrorMessage = memo(({ className, children, ...props }) => {
+    const { trace } = useStackTrace();
+    return (_jsx("span", { className: cn("truncate text-foreground", className), ...props, children: children ?? trace.errorMessage }));
+});
+const handleActionsClick = (e) => e.stopPropagation();
+const handleActionsKeyDown = (e) => {
+    if (e.key === "Enter" || e.key === " ") {
+        e.stopPropagation();
+    }
+};
+export const StackTraceActions = memo(({ className, children, ...props }) => (_jsx("div", { className: cn("flex shrink-0 items-center gap-1", className), onClick: handleActionsClick, onKeyDown: handleActionsKeyDown, role: "group", ...props, children: children })));
+export const StackTraceCopyButton = memo(({ onCopy, onError, timeout = 2000, className, children, ...props }) => {
+    const [isCopied, setIsCopied] = useState(false);
+    const timeoutRef = useRef(0);
+    const { raw } = useStackTrace();
+    const copyToClipboard = useCallback(async () => {
+        if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+            onError?.(new Error("Clipboard API not available"));
+            return;
+        }
+        try {
+            await navigator.clipboard.writeText(raw);
+            setIsCopied(true);
+            onCopy?.();
+            timeoutRef.current = window.setTimeout(() => setIsCopied(false), timeout);
+        }
+        catch (error) {
+            onError?.(error);
+        }
+    }, [raw, onCopy, onError, timeout]);
+    useEffect(() => () => {
+        window.clearTimeout(timeoutRef.current);
+    }, []);
+    const Icon = isCopied ? CheckIcon : CopyIcon;
+    return (_jsx(Button, { className: cn("size-7", className), onClick: copyToClipboard, size: "icon", variant: "ghost", ...props, children: children ?? _jsx(Icon, { size: 14 }) }));
+});
+export const StackTraceExpandButton = memo(({ className, ...props }) => {
+    const { isOpen } = useStackTrace();
+    return (_jsx("div", { className: cn("flex size-7 items-center justify-center", className), ...props, children: _jsx(ChevronDownIcon, { className: cn("size-4 text-muted-foreground transition-transform", isOpen ? "rotate-180" : "rotate-0") }) }));
+});
+export const StackTraceContent = memo(({ className, maxHeight = 400, children, ...props }) => {
+    const { isOpen } = useStackTrace();
+    return (_jsx(Collapsible, { open: isOpen, children: _jsx(CollapsibleContent, { className: cn("overflow-auto border-t bg-muted/30", "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:animate-out data-[state=open]:animate-in", className), style: { maxHeight }, ...props, children: children }) }));
+});
+const FilePathButton = memo(({ frame, onFilePathClick }) => {
+    const handleClick = useCallback(() => {
+        if (frame.filePath) {
+            onFilePathClick?.(frame.filePath, frame.lineNumber ?? undefined, frame.columnNumber ?? undefined);
+        }
+    }, [frame, onFilePathClick]);
+    return (_jsxs("button", { className: cn("underline decoration-dotted hover:text-primary", onFilePathClick && "cursor-pointer"), disabled: !onFilePathClick, onClick: handleClick, type: "button", children: [frame.filePath, frame.lineNumber !== null && `:${frame.lineNumber}`, frame.columnNumber !== null && `:${frame.columnNumber}`] }));
+});
+FilePathButton.displayName = "FilePathButton";
+export const StackTraceFrames = memo(({ className, showInternalFrames = true, ...props }) => {
+    const { trace, onFilePathClick } = useStackTrace();
+    const framesToShow = showInternalFrames
+        ? trace.frames
+        : trace.frames.filter((f) => !f.isInternal);
+    return (_jsxs("div", { className: cn("flex flex-col gap-1 p-3", className), ...props, children: [framesToShow.map((frame) => (_jsxs("div", { className: cn("text-xs", frame.isInternal
+                    ? "text-muted-foreground/50"
+                    : "text-foreground/90"), children: [_jsx("span", { className: "text-muted-foreground", children: "at " }), frame.functionName && (_jsxs("span", { className: frame.isInternal ? "" : "text-foreground", children: [frame.functionName, " "] })), frame.filePath && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground", children: "(" }), _jsx(FilePathButton, { frame: frame, onFilePathClick: onFilePathClick }), _jsx("span", { className: "text-muted-foreground", children: ")" })] })), !(frame.filePath || frame.functionName) && (_jsx("span", { children: frame.raw.replace(AT_PREFIX_REGEX, "") }))] }, frame.raw))), framesToShow.length === 0 && (_jsx("div", { className: "text-muted-foreground text-xs", children: "No stack frames" }))] }));
+});
+StackTrace.displayName = "StackTrace";
+StackTraceHeader.displayName = "StackTraceHeader";
+StackTraceError.displayName = "StackTraceError";
+StackTraceErrorType.displayName = "StackTraceErrorType";
+StackTraceErrorMessage.displayName = "StackTraceErrorMessage";
+StackTraceActions.displayName = "StackTraceActions";
+StackTraceCopyButton.displayName = "StackTraceCopyButton";
+StackTraceExpandButton.displayName = "StackTraceExpandButton";
+StackTraceContent.displayName = "StackTraceContent";
+StackTraceFrames.displayName = "StackTraceFrames";

package/dist/components/ai-elements/suggestion.d.ts

@@ -0,0 +1,11 @@
+import { Button } from "../button";
+import { ScrollArea } from "../scroll-area";
+import type { ComponentProps } from "react";
+export type SuggestionsProps = ComponentProps<typeof ScrollArea>;
+export declare const Suggestions: ({ className, children, ...props }: SuggestionsProps) => import("react").JSX.Element;
+export type SuggestionProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+    suggestion: string;
+    onClick?: (suggestion: string) => void;
+};
+export declare const Suggestion: ({ suggestion, onClick, className, variant, size, children, ...props }: SuggestionProps) => import("react").JSX.Element;
+//# sourceMappingURL=suggestion.d.ts.map

package/dist/components/ai-elements/suggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggestion.d.ts","sourceRoot":"","sources":["../../../src/components/ai-elements/suggestion.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EACL,UAAU,EAEX,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,OAAO,UAAU,CAAC,CAAC;AAEjE,eAAO,MAAM,WAAW,GAAI,mCAIzB,gBAAgB,gCAOlB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,uEAQxB,eAAe,gCAiBjB,CAAC"}

package/dist/components/ai-elements/suggestion.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "../button.js";
+import { ScrollArea, ScrollBar, } from "../scroll-area.js";
+import { cn } from "../../lib/utils.js";
+import { useCallback } from "react";
+export const Suggestions = ({ className, children, ...props }) => (_jsxs(ScrollArea, { className: "w-full overflow-x-auto whitespace-nowrap", ...props, children: [_jsx("div", { className: cn("flex w-max flex-nowrap items-center gap-2", className), children: children }), _jsx(ScrollBar, { className: "hidden", orientation: "horizontal" })] }));
+export const Suggestion = ({ suggestion, onClick, className, variant = "outline", size = "sm", children, ...props }) => {
+    const handleClick = useCallback(() => {
+        onClick?.(suggestion);
+    }, [onClick, suggestion]);
+    return (_jsx(Button, { className: cn("cursor-pointer rounded-full px-4", className), onClick: handleClick, size: size, type: "button", variant: variant, ...props, children: children || suggestion }));
+};

package/dist/components/ai-elements/task.d.ts

@@ -0,0 +1,15 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../collapsible";
+import type { ComponentProps } from "react";
+export type TaskItemFileProps = ComponentProps<"div">;
+export declare const TaskItemFile: ({ children, className, ...props }: TaskItemFileProps) => import("react").JSX.Element;
+export type TaskItemProps = ComponentProps<"div">;
+export declare const TaskItem: ({ children, className, ...props }: TaskItemProps) => import("react").JSX.Element;
+export type TaskProps = ComponentProps<typeof Collapsible>;
+export declare const Task: ({ defaultOpen, className, ...props }: TaskProps) => import("react").JSX.Element;
+export type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    title: string;
+};
+export declare const TaskTrigger: ({ children, className, title, ...props }: TaskTriggerProps) => import("react").JSX.Element;
+export type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const TaskContent: ({ children, className, ...props }: TaskContentProps) => import("react").JSX.Element;
+//# sourceMappingURL=task.d.ts.map

package/dist/components/ai-elements/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../src/components/ai-elements/task.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;AAEtD,eAAO,MAAM,YAAY,GAAI,mCAI1B,iBAAiB,gCAUnB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;AAElD,eAAO,MAAM,QAAQ,GAAI,mCAAmC,aAAa,gCAIxE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,cAAc,CAAC,OAAO,WAAW,CAAC,CAAC;AAE3D,eAAO,MAAM,IAAI,GAAI,sCAIlB,SAAS,gCAEX,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,OAAO,kBAAkB,CAAC,GAAG;IACzE,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,0CAKzB,gBAAgB,gCAUlB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEzE,eAAO,MAAM,WAAW,GAAI,mCAIzB,gBAAgB,gCAYlB,CAAC"}

package/dist/components/ai-elements/task.js

@@ -0,0 +1,10 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger, } from "../collapsible.js";
+import { cn } from "../../lib/utils.js";
+import { ChevronDownIcon, SearchIcon } from "lucide-react";
+export const TaskItemFile = ({ children, className, ...props }) => (_jsx("div", { className: cn("inline-flex items-center gap-1 rounded-md border bg-secondary px-1.5 py-0.5 text-foreground text-xs", className), ...props, children: children }));
+export const TaskItem = ({ children, className, ...props }) => (_jsx("div", { className: cn("text-muted-foreground text-sm", className), ...props, children: children }));
+export const Task = ({ defaultOpen = true, className, ...props }) => (_jsx(Collapsible, { className: cn(className), defaultOpen: defaultOpen, ...props }));
+export const TaskTrigger = ({ children, className, title, ...props }) => (_jsx(CollapsibleTrigger, { asChild: true, className: cn("group", className), ...props, children: children ?? (_jsxs("div", { className: "flex w-full cursor-pointer items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground", children: [_jsx(SearchIcon, { className: "size-4" }), _jsx("p", { className: "text-sm", children: title }), _jsx(ChevronDownIcon, { className: "size-4 transition-transform group-data-[state=open]:rotate-180" })] })) }));
+export const TaskContent = ({ children, className, ...props }) => (_jsx(CollapsibleContent, { className: cn("data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in", className), ...props, children: _jsx("div", { className: "mt-4 flex flex-col gap-2 border-l-2 border-muted pl-4", children: children }) }));

package/dist/components/ai-elements/terminal.d.ts

@@ -0,0 +1,28 @@
+import { Button } from "../button";
+import type { ComponentProps, HTMLAttributes } from "react";
+export type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalHeader: ({ className, children, ...props }: TerminalHeaderProps) => import("react").JSX.Element;
+export type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalTitle: ({ className, children, ...props }: TerminalTitleProps) => import("react").JSX.Element;
+export type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalStatus: ({ className, children, ...props }: TerminalStatusProps) => import("react").JSX.Element | null;
+export type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalActions: ({ className, children, ...props }: TerminalActionsProps) => import("react").JSX.Element;
+export type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const TerminalCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: TerminalCopyButtonProps) => import("react").JSX.Element;
+export type TerminalClearButtonProps = ComponentProps<typeof Button>;
+export declare const TerminalClearButton: ({ children, className, ...props }: TerminalClearButtonProps) => import("react").JSX.Element | null;
+export type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalContent: ({ className, children, ...props }: TerminalContentProps) => import("react").JSX.Element;
+export type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+    output: string;
+    isStreaming?: boolean;
+    autoScroll?: boolean;
+    onClear?: () => void;
+};
+export declare const Terminal: ({ output, isStreaming, autoScroll, onClear, className, children, ...props }: TerminalProps) => import("react").JSX.Element;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/components/ai-elements/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/components/ai-elements/terminal.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAI7C,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAwB5D,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;AAEjE,eAAO,MAAM,cAAc,GAAI,mCAI5B,mBAAmB,gCAUrB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;AAEhE,eAAO,MAAM,aAAa,GAAI,mCAI3B,kBAAkB,gCAQpB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;AAEjE,eAAO,MAAM,cAAc,GAAI,mCAI5B,mBAAmB,uCAerB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;AAElE,eAAO,MAAM,eAAe,GAAI,mCAI7B,oBAAoB,gCAItB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC,OAAO,MAAM,CAAC,GAAG;IACpE,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,6DAOhC,uBAAuB,gCA4CzB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,cAAc,CAAC,OAAO,MAAM,CAAC,CAAC;AAErE,eAAO,MAAM,mBAAmB,GAAI,mCAIjC,wBAAwB,uCAqB1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;AAElE,eAAO,MAAM,eAAe,GAAI,mCAI7B,oBAAoB,gCA6BtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,cAAc,CAAC,GAAG;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,6EAQtB,aAAa,gCAiCf,CAAC"}