create-principles-disciple 1.0.0 → 1.74.0

package/console/dist/ui/components/error-boundary.d.ts

@@ -0,0 +1,15 @@
+import { Component, type ReactNode } from "react";
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/console/dist/ui/components/error-boundary.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Component } from "react";
+import i18n from "../i18n/index.js";
+import { Card, CardContent } from "./ui/card.js";
+import { Button } from "./ui/button.js";
+import { AlertCircle } from "lucide-react";
+export class ErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    render() {
+        if (this.state.hasError) {
+            if (this.props.fallback)
+                return this.props.fallback;
+            return (_jsx(Card, { className: "border-destructive/50", children: _jsxs(CardContent, { className: "p-6", children: [_jsxs("div", { className: "flex items-center gap-3 mb-4", children: [_jsx(AlertCircle, { className: "h-5 w-5 text-destructive" }), _jsx("h3", { className: "font-semibold text-destructive", children: i18n.t("components:errorBoundary.title") })] }), _jsx("p", { className: "text-sm text-muted-foreground mb-4", children: this.state.error?.message ?? i18n.t("components:errorBoundary.description") }), _jsx(Button, { variant: "outline", onClick: () => this.setState({ hasError: false, error: null }), children: i18n.t("components:errorBoundary.retry") })] }) }));
+        }
+        return this.props.children;
+    }
+}

package/console/dist/ui/components/health-diagnostic-card.d.ts

@@ -0,0 +1,15 @@
+interface HealthCheckItem {
+    id: string;
+    name: string;
+    status: 'healthy' | 'warning' | 'error';
+    message: string;
+    lastCheck: string;
+}
+interface HealthDiagnosticCardProps {
+    overall: 'healthy' | 'degraded' | 'error';
+    checks: HealthCheckItem[];
+    onRefresh?: () => void;
+    loading?: boolean;
+}
+export declare function HealthDiagnosticCard({ overall, checks, onRefresh, loading, }: HealthDiagnosticCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/console/dist/ui/components/health-diagnostic-card.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Card, CardContent, CardHeader, CardTitle } from './ui/card.js';
+import { Badge } from './ui/badge.js';
+import { Button } from './ui/button.js';
+import { RefreshCw } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+export function HealthDiagnosticCard({ overall, checks, onRefresh, loading, }) {
+    const { t } = useTranslation();
+    const healthyCount = checks.filter(c => c.status === 'healthy').length;
+    const totalCount = checks.length;
+    const getOverallStatusText = () => {
+        switch (overall) {
+            case 'healthy': return t('components:healthDiagnostic.allNormal');
+            case 'degraded': return t('components:healthDiagnostic.needsAttention');
+            case 'error': return t('components:healthDiagnostic.criticalIssues');
+        }
+    };
+    const getOverallBadgeVariant = () => {
+        switch (overall) {
+            case 'healthy': return 'default';
+            case 'degraded': return 'secondary';
+            case 'error': return 'destructive';
+        }
+    };
+    const getStatusIcon = (status) => {
+        switch (status) {
+            case 'healthy': return '\u2713';
+            case 'warning': return '\u26A0';
+            case 'error': return '\u2717';
+            default: return '?';
+        }
+    };
+    const getStatusBadgeVariant = (status) => {
+        switch (status) {
+            case 'healthy': return 'default';
+            case 'warning': return 'secondary';
+            case 'error': return 'destructive';
+            default: return 'outline';
+        }
+    };
+    return (_jsxs(Card, { children: [_jsx(CardHeader, { className: "pb-2", children: _jsxs("div", { className: "flex justify-between items-center", children: [_jsx(CardTitle, { className: "text-sm", children: t('components:healthDiagnostic.title') }), _jsxs("div", { className: "flex items-center gap-2", children: [_jsxs(Badge, { variant: getOverallBadgeVariant(), children: [healthyCount, "/", totalCount, " healthy \u00B7 ", getOverallStatusText()] }), onRefresh && (_jsx(Button, { variant: "ghost", size: "sm", onClick: onRefresh, disabled: loading, children: _jsx(RefreshCw, { className: `w-4 h-4 ${loading ? 'animate-spin' : ''}`, "aria-hidden": "true" }) }))] })] }) }), _jsx(CardContent, { className: "flex flex-col gap-2", children: checks.map((check) => (_jsxs("div", { className: "flex items-center justify-between py-1 border-b last:border-0", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Badge, { variant: getStatusBadgeVariant(check.status), children: getStatusIcon(check.status) }), _jsx("span", { className: "text-sm", children: check.name })] }), _jsx("span", { className: "text-xs text-muted-foreground", children: check.message })] }, check.id))) })] }));
+}

package/console/dist/ui/components/language-switcher.d.ts

@@ -0,0 +1 @@
+export declare function LanguageSwitcher(): import("react/jsx-runtime").JSX.Element;

package/console/dist/ui/components/language-switcher.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useTranslation } from "react-i18next";
+import { Button } from "./ui/button.js";
+const LANGUAGES = [
+    { code: "zh-CN", label: "中文", englishLabel: "Chinese" },
+    { code: "en", label: "English", englishLabel: "English" },
+];
+export function LanguageSwitcher() {
+    const { i18n } = useTranslation();
+    const currentLang = LANGUAGES.find((lang) => lang.code === i18n.language);
+    const toggleLanguage = () => {
+        const nextLang = i18n.language === "zh-CN" ? "en" : "zh-CN";
+        i18n.changeLanguage(nextLang);
+        localStorage.setItem("pd-language", nextLang);
+    };
+    return (_jsx(Button, { variant: "ghost", size: "sm", onClick: toggleLanguage, className: "min-w-[70px]", children: currentLang?.label }));
+}

package/console/dist/ui/components/page-header.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface PageHeaderProps {
+    title: string;
+    description?: string;
+    onRefresh?: () => void;
+    lastUpdated?: Date | null;
+    actions?: React.ReactNode;
+}
+export declare function PageHeader({ title, description, onRefresh, lastUpdated, actions, }: PageHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/console/dist/ui/components/page-header.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { useTranslation } from "react-i18next";
+import { RefreshCw } from "lucide-react";
+import { cn } from "../../lib/utils.js";
+import { Button } from "./ui/button.js";
+import { Separator } from "./ui/separator.js";
+export function PageHeader({ title, description, onRefresh, lastUpdated, actions, }) {
+    const { t } = useTranslation();
+    const [refreshing, setRefreshing] = React.useState(false);
+    const handleRefresh = async () => {
+        if (!onRefresh)
+            return;
+        setRefreshing(true);
+        try {
+            await onRefresh();
+        }
+        finally {
+            setRefreshing(false);
+        }
+    };
+    const formatTime = (date) => {
+        const now = new Date();
+        const diff = now.getTime() - date.getTime();
+        const minutes = Math.floor(diff / 60000);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (minutes < 1)
+            return t("components:pageHeader.justNow");
+        if (minutes < 60)
+            return t("components:pageHeader.minutesAgo", { count: minutes });
+        if (hours < 24)
+            return t("components:pageHeader.hoursAgo", { count: hours });
+        return t("components:pageHeader.daysAgo", { count: days });
+    };
+    return (_jsxs("header", { className: "mb-6", children: [_jsxs("div", { className: "flex items-start justify-between", children: [_jsxs("div", { children: [_jsx("h1", { className: "text-2xl font-bold tracking-tight", children: title }), description && (_jsx("p", { className: "mt-1 text-sm text-muted-foreground", children: description }))] }), _jsxs("div", { className: "flex items-center gap-3", children: [onRefresh && (_jsxs(Button, { variant: "outline", size: "sm", onClick: handleRefresh, disabled: refreshing, children: [_jsx(RefreshCw, { className: cn("h-4 w-4 mr-2", refreshing && "animate-spin"), "aria-hidden": "true" }), t("components:pageHeader.refresh")] })), actions] })] }), lastUpdated && (_jsx("div", { className: "mt-3 flex items-center text-xs text-muted-foreground", children: _jsx("span", { children: t("components:pageHeader.lastUpdated", { time: formatTime(lastUpdated) }) }) })), _jsx(Separator, { className: "mt-4" })] }));
+}

package/console/dist/ui/components/rejection-reason-dialog.d.ts

@@ -0,0 +1,6 @@
+export declare function RejectionReasonDialog({ open, onOpenChange, onSubmit, loading, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: (reason: string) => void;
+    loading?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/console/dist/ui/components/rejection-reason-dialog.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, } from "./ui/dialog.js";
+import { Button } from "./ui/button.js";
+const MIN_REASON_LENGTH = 10;
+export function RejectionReasonDialog({ open, onOpenChange, onSubmit, loading, }) {
+    const { t } = useTranslation();
+    const [reason, setReason] = useState("");
+    const isValid = reason.trim().length >= MIN_REASON_LENGTH;
+    function handleSubmit() {
+        if (!isValid)
+            return;
+        onSubmit(reason.trim());
+        setReason("");
+    }
+    function handleCancel() {
+        setReason("");
+        onOpenChange(false);
+    }
+    return (_jsx(Dialog, { open: open, onOpenChange: (nextOpen) => { if (!nextOpen)
+            setReason(""); onOpenChange(nextOpen); }, children: _jsxs(DialogContent, { className: "max-w-md", children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: t("components:rejectionDialog.title") }), _jsx(DialogDescription, { children: t("components:rejectionDialog.description", { min: MIN_REASON_LENGTH }) })] }), _jsx("textarea", { className: "w-full min-h-[100px] rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50", placeholder: t("components:rejectionDialog.placeholder"), value: reason, onChange: (e) => setReason(e.target.value), disabled: loading }), reason.length > 0 && !isValid && (_jsx("p", { className: "text-xs text-amber-600", children: t("components:rejectionDialog.tooShort", { min: MIN_REASON_LENGTH, current: reason.trim().length }) })), _jsxs(DialogFooter, { children: [_jsx(Button, { variant: "outline", onClick: handleCancel, disabled: loading, children: t("common:cancel") }), _jsx(Button, { variant: "destructive", onClick: handleSubmit, disabled: !isValid || loading, children: t("components:approvalCard.reject") })] })] }) }));
+}

package/console/dist/ui/components/theme-provider.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+type Theme = "light" | "dark" | "system";
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+}
+interface ThemeProviderState {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+}
+export declare function ThemeProvider({ children, defaultTheme, storageKey, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTheme(): ThemeProviderState;
+export {};

package/console/dist/ui/components/theme-provider.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+const initialState = {
+    theme: "system",
+    setTheme: () => { },
+};
+const ThemeProviderContext = React.createContext(initialState);
+export function ThemeProvider({ children, defaultTheme = "system", storageKey = "pd-theme", }) {
+    const [theme, setThemeState] = React.useState(() => {
+        if (typeof window !== "undefined") {
+            const stored = localStorage.getItem(storageKey);
+            return stored || defaultTheme;
+        }
+        return defaultTheme;
+    });
+    React.useEffect(() => {
+        const root = window.document.documentElement;
+        const isDark = theme === "dark" ||
+            (theme === "system" &&
+                window.matchMedia("(prefers-color-scheme: dark)").matches);
+        root.classList.toggle("dark", isDark);
+        localStorage.setItem(storageKey, theme);
+    }, [theme, storageKey]);
+    const setTheme = (newTheme) => {
+        setThemeState(newTheme);
+    };
+    return (_jsx(ThemeProviderContext.Provider, { value: { theme, setTheme }, children: children }));
+}
+export function useTheme() {
+    const context = React.useContext(ThemeProviderContext);
+    if (context === undefined) {
+        throw new Error("useTheme must be used within a ThemeProvider");
+    }
+    return context;
+}

package/console/dist/ui/components/theme-toggle.d.ts

@@ -0,0 +1 @@
+export declare function ThemeToggle(): import("react/jsx-runtime").JSX.Element;

package/console/dist/ui/components/theme-toggle.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { Sun, Moon } from "lucide-react";
+import { Button } from "./ui/button.js";
+import { useTheme } from "./theme-provider.js";
+export function ThemeToggle() {
+    const { theme, setTheme } = useTheme();
+    const [systemDark, setSystemDark] = React.useState(false);
+    React.useEffect(() => {
+        const mq = window.matchMedia("(prefers-color-scheme: dark)");
+        setSystemDark(mq.matches);
+        const handler = (e) => setSystemDark(e.matches);
+        mq.addEventListener("change", handler);
+        return () => mq.removeEventListener("change", handler);
+    }, []);
+    const isDark = theme === "dark" ||
+        (theme === "system" && systemDark);
+    const toggleTheme = () => {
+        if (theme === "light") {
+            setTheme("dark");
+        }
+        else if (theme === "dark") {
+            setTheme("light");
+        }
+        else {
+            setTheme(isDark ? "light" : "dark");
+        }
+    };
+    return (_jsx(Button, { variant: "ghost", size: "icon", onClick: toggleTheme, className: "transition-transform duration-300 hover:rotate-180 motion-reduce:transition-none motion-reduce:hover:rotate-0", title: isDark ? "Switch to light mode" : "Switch to dark mode", "aria-label": isDark ? "Switch to light mode" : "Switch to dark mode", children: isDark ? (_jsx(Sun, { className: "h-5 w-5" })) : (_jsx(Moon, { className: "h-5 w-5" })) }));
+}

package/console/dist/ui/components/ui/alert-dialog.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/console/dist/ui/components/ui/alert-dialog.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import { cn } from "../../../lib/utils.js";
+import { buttonVariants } from "./button.js";
+const AlertDialog = AlertDialogPrimitive.Root;
+const AlertDialogTrigger = AlertDialogPrimitive.Trigger;
+const AlertDialogPortal = AlertDialogPrimitive.Portal;
+const AlertDialogOverlay = React.forwardRef(({ className, ...props }, ref) => (_jsx(AlertDialogPrimitive.Overlay, { className: cn("fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", className), ...props, ref: ref })));
+AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName;
+const AlertDialogContent = React.forwardRef(({ className, ...props }, ref) => (_jsxs(AlertDialogPortal, { children: [_jsx(AlertDialogOverlay, {}), _jsx(AlertDialogPrimitive.Content, { ref: ref, className: cn("fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg", className), ...props })] })));
+AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName;
+const AlertDialogHeader = ({ className, ...props }) => (_jsx("div", { className: cn("flex flex-col gap-2 text-center sm:text-left", className), ...props }));
+AlertDialogHeader.displayName = "AlertDialogHeader";
+const AlertDialogFooter = ({ className, ...props }) => (_jsx("div", { className: cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className), ...props }));
+AlertDialogFooter.displayName = "AlertDialogFooter";
+const AlertDialogTitle = React.forwardRef(({ className, ...props }, ref) => (_jsx(AlertDialogPrimitive.Title, { ref: ref, className: cn("text-lg font-semibold", className), ...props })));
+AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName;
+const AlertDialogDescription = React.forwardRef(({ className, ...props }, ref) => (_jsx(AlertDialogPrimitive.Description, { ref: ref, className: cn("text-sm text-muted-foreground", className), ...props })));
+AlertDialogDescription.displayName =
+    AlertDialogPrimitive.Description.displayName;
+const AlertDialogAction = React.forwardRef(({ className, ...props }, ref) => (_jsx(AlertDialogPrimitive.Action, { ref: ref, className: cn(buttonVariants(), className), ...props })));
+AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName;
+const AlertDialogCancel = React.forwardRef(({ className, ...props }, ref) => (_jsx(AlertDialogPrimitive.Cancel, { ref: ref, className: cn(buttonVariants({ variant: "outline" }), "mt-2 sm:mt-0", className), ...props })));
+AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/console/dist/ui/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/console/dist/ui/components/ui/badge.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { cn } from "../../../lib/utils.js";
+const badgeVariants = cva("inline-flex items-center rounded-full px-3 py-1 text-xs font-medium transition-colors", {
+    variants: {
+        variant: {
+            default: "bg-primary text-primary-foreground hover:bg-primary/80",
+            secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+            destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/80",
+            outline: "border border-input text-foreground",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+    },
+});
+function Badge({ className, variant, ...props }) {
+    return (_jsx("div", { className: cn(badgeVariants({ variant }), className), ...props }));
+}
+export { Badge, badgeVariants };

package/console/dist/ui/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/console/dist/ui/components/ui/button.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { cn } from "../../../lib/utils.js";
+const buttonVariants = cva("inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50", {
+    variants: {
+        variant: {
+            default: "bg-primary text-primary-foreground hover:bg-primary/90",
+            destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+            outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+            secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+            ghost: "hover:bg-accent hover:text-accent-foreground",
+            link: "text-primary underline-offset-4 hover:underline",
+        },
+        size: {
+            default: "h-10 px-4 py-2",
+            sm: "h-9 rounded-md px-3",
+            lg: "h-11 rounded-md px-8",
+            icon: "h-10 w-10",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+        size: "default",
+    },
+});
+const Button = React.forwardRef(({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    return (_jsx(Comp, { className: cn(buttonVariants({ variant, size, className })), ref: ref, ...props }));
+});
+Button.displayName = "Button";
+export { Button, buttonVariants };

package/console/dist/ui/components/ui/card.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/console/dist/ui/components/ui/card.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../../lib/utils.js";
+const Card = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("rounded-lg border border-border bg-card text-card-foreground shadow-sm", className), ...props })));
+Card.displayName = "Card";
+const CardHeader = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("flex flex-col gap-1.5 p-6", className), ...props })));
+CardHeader.displayName = "CardHeader";
+const CardTitle = React.forwardRef(({ className, ...props }, ref) => (_jsx("h3", { ref: ref, className: cn("text-lg font-semibold leading-none tracking-tight", className), ...props })));
+CardTitle.displayName = "CardTitle";
+const CardDescription = React.forwardRef(({ className, ...props }, ref) => (_jsx("p", { ref: ref, className: cn("text-sm text-muted-foreground", className), ...props })));
+CardDescription.displayName = "CardDescription";
+const CardContent = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("p-6 pt-0", className), ...props })));
+CardContent.displayName = "CardContent";
+const CardFooter = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("flex items-center p-6 pt-0", className), ...props })));
+CardFooter.displayName = "CardFooter";
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/console/dist/ui/components/ui/charts.d.ts

@@ -0,0 +1,51 @@
+interface DonutChartItem {
+    label: string;
+    value: number;
+    color: string;
+}
+interface DonutChartProps {
+    items: DonutChartItem[];
+    size?: number;
+    strokeWidth?: number;
+    className?: string;
+}
+export declare function DonutChart({ items, size, strokeWidth, className }: DonutChartProps): import("react/jsx-runtime").JSX.Element;
+interface DonutChartWithLegendProps {
+    items: DonutChartItem[];
+    size?: number;
+    strokeWidth?: number;
+    className?: string;
+}
+export declare function DonutChartWithLegend({ items, size, strokeWidth, className }: DonutChartWithLegendProps): import("react/jsx-runtime").JSX.Element;
+interface BarChartItem {
+    label: string;
+    value: number;
+    color: string;
+}
+interface BarChartProps {
+    items: BarChartItem[];
+    maxValue?: number;
+    className?: string;
+}
+export declare function HorizontalBarChart({ items, maxValue, className }: BarChartProps): import("react/jsx-runtime").JSX.Element;
+interface CoverageIndicatorProps {
+    covered: number;
+    total: number;
+    className?: string;
+}
+export declare function CoverageIndicator({ covered, total, className }: CoverageIndicatorProps): import("react/jsx-runtime").JSX.Element;
+interface HistogramProps {
+    buckets: {
+        label: string;
+        count: number;
+    }[];
+    className?: string;
+}
+export declare function Histogram({ buckets, className }: HistogramProps): import("react/jsx-runtime").JSX.Element;
+export declare function computeValueBuckets(principles: {
+    valueScore: number;
+}[], bucketCount?: number): {
+    label: string;
+    count: number;
+}[];
+export {};

package/console/dist/ui/components/ui/charts.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "../../../lib/utils.js";
+export function DonutChart({ items, size = 120, strokeWidth = 20, className }) {
+    const total = items.reduce((sum, item) => sum + item.value, 0);
+    if (total === 0) {
+        return (_jsx("div", { className: cn("flex items-center justify-center", className), style: { width: size, height: size }, children: _jsx("span", { className: "text-xs text-muted-foreground", children: "No data" }) }));
+    }
+    const radius = (size - strokeWidth) / 2;
+    const circumference = 2 * Math.PI * radius;
+    const center = size / 2;
+    let accumulatedOffset = 0;
+    const segments = items.map((item) => {
+        const percentage = item.value / total;
+        const dashLength = circumference * percentage;
+        const gap = circumference - dashLength;
+        const offset = -accumulatedOffset;
+        accumulatedOffset += dashLength;
+        return {
+            ...item,
+            percentage,
+            dashLength,
+            gap,
+            offset,
+        };
+    });
+    return (_jsx("div", { className: cn("relative", className), children: _jsx("svg", { width: size, height: size, viewBox: `0 0 ${size} ${size}`, children: segments.map((segment, index) => (_jsx("circle", { cx: center, cy: center, r: radius, fill: "none", stroke: segment.color, strokeWidth: strokeWidth, strokeDasharray: `${segment.dashLength} ${segment.gap}`, strokeDashoffset: segment.offset, strokeLinecap: "butt", transform: `rotate(-90 ${center} ${center})`, className: "transition-[stroke-dashoffset,stroke-dasharray] duration-500 motion-reduce:transition-none" }, index))) }) }));
+}
+export function DonutChartWithLegend({ items, size = 120, strokeWidth = 20, className }) {
+    const total = items.reduce((sum, item) => sum + item.value, 0);
+    return (_jsxs("div", { className: cn("flex items-center gap-4", className), children: [_jsx(DonutChart, { items: items, size: size, strokeWidth: strokeWidth }), _jsx("div", { className: "space-y-1.5", children: items.map((item) => (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("div", { className: "w-3 h-3 rounded-sm flex-shrink-0", style: { backgroundColor: item.color } }), _jsx("span", { className: "text-xs text-muted-foreground whitespace-nowrap", children: item.label }), _jsx("span", { className: "text-xs font-medium tabular-nums", children: item.value }), total > 0 && (_jsxs("span", { className: "text-xs text-muted-foreground tabular-nums", children: ["(", ((item.value / total) * 100).toFixed(0), "%)"] }))] }, item.label))) })] }));
+}
+export function HorizontalBarChart({ items, maxValue, className }) {
+    const max = maxValue ?? Math.max(...items.map((i) => i.value), 1);
+    return (_jsx("div", { className: cn("space-y-2", className), children: items.map((item) => (_jsxs("div", { className: "space-y-0.5", children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsx("span", { className: "text-xs text-muted-foreground", children: item.label }), _jsx("span", { className: "text-xs font-medium tabular-nums", children: item.value })] }), _jsx("div", { className: "h-2 bg-muted rounded-full overflow-hidden", children: _jsx("div", { className: "h-full rounded-full transition-[width] duration-500 motion-reduce:transition-none", style: {
+                            width: `${Math.min((item.value / max) * 100, 100)}%`,
+                            backgroundColor: item.color,
+                        } }) })] }, item.label))) }));
+}
+export function CoverageIndicator({ covered, total, className }) {
+    const percentage = total > 0 ? (covered / total) * 100 : 0;
+    const color = percentage >= 80 ? "bg-primary" : percentage >= 50 ? "bg-amber-500" : "bg-destructive";
+    return (_jsxs("div", { className: cn("space-y-1", className), children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsxs("span", { className: "text-xs text-muted-foreground", children: [covered, " / ", total] }), _jsxs("span", { className: "text-xs font-medium tabular-nums", children: [percentage.toFixed(0), "%"] })] }), _jsx("div", { className: "h-2 bg-muted rounded-full overflow-hidden", children: _jsx("div", { className: cn("h-full rounded-full transition-[width] duration-500 motion-reduce:transition-none", color), style: { width: `${percentage}%` } }) })] }));
+}
+export function Histogram({ buckets, className }) {
+    const maxCount = Math.max(...buckets.map((b) => b.count), 1);
+    return (_jsx("div", { className: cn("flex items-end gap-1", className), style: { height: 80 }, children: buckets.map((bucket) => {
+            const height = (bucket.count / maxCount) * 100;
+            return (_jsxs("div", { className: "flex-1 flex flex-col items-center gap-1", children: [_jsx("div", { className: "w-full bg-primary/70 rounded-t transition-[height] duration-500 hover:bg-primary motion-reduce:transition-none", style: { height: `${Math.max(height, 2)}%` }, title: `${bucket.label}: ${bucket.count}` }), _jsx("span", { className: "text-[10px] text-muted-foreground truncate w-full text-center", children: bucket.label })] }, bucket.label));
+        }) }));
+}
+export function computeValueBuckets(principles, bucketCount = 5) {
+    if (principles.length === 0) {
+        return Array.from({ length: bucketCount }, (_, i) => ({
+            label: `${i * 20}`,
+            count: 0,
+        }));
+    }
+    const maxScore = Math.max(...principles.map((p) => p.valueScore), 1);
+    const bucketSize = maxScore / bucketCount;
+    const buckets = Array.from({ length: bucketCount }, (_, i) => ({
+        label: `${(i * bucketSize).toFixed(0)}`,
+        count: 0,
+    }));
+    for (const p of principles) {
+        const bucketIndex = Math.min(Math.floor(p.valueScore / bucketSize), bucketCount - 1);
+        buckets[bucketIndex].count++;
+    }
+    return buckets;
+}

package/console/dist/ui/components/ui/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/console/dist/ui/components/ui/dialog.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import { X } from "lucide-react";
+import { cn } from "../../../lib/utils.js";
+const Dialog = DialogPrimitive.Root;
+const DialogTrigger = DialogPrimitive.Trigger;
+const DialogPortal = DialogPrimitive.Portal;
+const DialogClose = DialogPrimitive.Close;
+const DialogOverlay = React.forwardRef(({ className, ...props }, ref) => (_jsx(DialogPrimitive.Overlay, { ref: ref, className: cn("fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", className), ...props })));
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
+const DialogContent = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(DialogPortal, { children: [_jsx(DialogOverlay, {}), _jsxs(DialogPrimitive.Content, { ref: ref, className: cn("fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg", className), ...props, children: [children, _jsxs(DialogPrimitive.Close, { className: "absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground", children: [_jsx(X, { className: "h-4 w-4" }), _jsx("span", { className: "sr-only", children: "Close" })] })] })] })));
+DialogContent.displayName = DialogPrimitive.Content.displayName;
+const DialogHeader = ({ className, ...props }) => (_jsx("div", { className: cn("flex flex-col gap-1.5 text-center sm:text-left", className), ...props }));
+DialogHeader.displayName = "DialogHeader";
+const DialogFooter = ({ className, ...props }) => (_jsx("div", { className: cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className), ...props }));
+DialogFooter.displayName = "DialogFooter";
+const DialogTitle = React.forwardRef(({ className, ...props }, ref) => (_jsx(DialogPrimitive.Title, { ref: ref, className: cn("text-lg font-semibold leading-none tracking-tight", className), ...props })));
+DialogTitle.displayName = DialogPrimitive.Title.displayName;
+const DialogDescription = React.forwardRef(({ className, ...props }, ref) => (_jsx(DialogPrimitive.Description, { ref: ref, className: cn("text-sm text-muted-foreground", className), ...props })));
+DialogDescription.displayName = DialogPrimitive.Description.displayName;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };