362 lines
11 KiB
TypeScript
362 lines
11 KiB
TypeScript
"use client";
|
|
|
|
import { ArchiveIcon, ClockIcon, MoreHorizontalIcon, RotateCcwIcon, Trash2Icon } from "lucide-react";
|
|
import { useMemo, useState } from "react";
|
|
import { toast } from "sonner";
|
|
|
|
import { Badge } from "@/components/ui/badge";
|
|
import { Button } from "@/components/ui/button";
|
|
import {
|
|
Dialog,
|
|
DialogContent,
|
|
DialogDescription,
|
|
DialogFooter,
|
|
DialogHeader,
|
|
DialogTitle,
|
|
} from "@/components/ui/dialog";
|
|
import {
|
|
DropdownMenu,
|
|
DropdownMenuContent,
|
|
DropdownMenuItem,
|
|
DropdownMenuTrigger,
|
|
} from "@/components/ui/dropdown-menu";
|
|
import {
|
|
Sheet,
|
|
SheetContent,
|
|
SheetDescription,
|
|
SheetHeader,
|
|
SheetTitle,
|
|
} from "@/components/ui/sheet";
|
|
import { useI18n } from "@/core/i18n/hooks";
|
|
import { useDeleteCustomSkill, useSetSkillState } from "@/core/skills/hooks";
|
|
import type { Skill } from "@/core/skills/type";
|
|
import { desensitize } from "@/lib/desensitize";
|
|
import { cn } from "@/lib/utils";
|
|
|
|
type Kind = "stale" | "archived";
|
|
|
|
export function SkillStateSheet({
|
|
kind,
|
|
open,
|
|
onOpenChange,
|
|
skills,
|
|
}: {
|
|
kind: Kind;
|
|
open: boolean;
|
|
onOpenChange: (open: boolean) => void;
|
|
skills: Skill[];
|
|
}) {
|
|
const { t } = useI18n();
|
|
const tt = t.settings.skills;
|
|
const ts = tt.stateSheet;
|
|
const isArchived = kind === "archived";
|
|
|
|
return (
|
|
<Sheet open={open} onOpenChange={onOpenChange}>
|
|
<SheetContent className="flex w-full flex-col gap-0 p-0 sm:max-w-2xl">
|
|
<SheetHeader className="border-b">
|
|
<SheetTitle className="flex items-center gap-2">
|
|
{isArchived ? (
|
|
<ArchiveIcon className="size-4" />
|
|
) : (
|
|
<ClockIcon className="size-4" />
|
|
)}
|
|
{isArchived ? ts.archivedTitle : ts.staleTitle}
|
|
<span className="text-muted-foreground text-sm font-normal">
|
|
({skills.length})
|
|
</span>
|
|
</SheetTitle>
|
|
<SheetDescription>
|
|
{isArchived ? ts.archivedDescription : ts.staleDescription}
|
|
</SheetDescription>
|
|
</SheetHeader>
|
|
<div className="flex-1 overflow-auto p-4">
|
|
{skills.length === 0 ? (
|
|
<div className="text-muted-foreground py-12 text-center text-sm">
|
|
{ts.empty}
|
|
</div>
|
|
) : (
|
|
<div className="flex flex-col gap-3">
|
|
{skills.map((skill) => (
|
|
<SkillStateRow key={skill.name} skill={skill} kind={kind} />
|
|
))}
|
|
</div>
|
|
)}
|
|
</div>
|
|
</SheetContent>
|
|
</Sheet>
|
|
);
|
|
}
|
|
|
|
function SkillStateRow({ skill, kind }: { skill: Skill; kind: Kind }) {
|
|
const { t } = useI18n();
|
|
const tt = t.settings.skills;
|
|
const ts = tt.stateSheet;
|
|
const setState = useSetSkillState();
|
|
const deleteSkill = useDeleteCustomSkill();
|
|
const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
|
|
const [viewOpen, setViewOpen] = useState(false);
|
|
|
|
const pending = setState.isPending || deleteSkill.isPending;
|
|
const isArchived = kind === "archived";
|
|
|
|
const timeLabel = useMemo(() => {
|
|
if (isArchived) {
|
|
const when = skill.last_activity_at;
|
|
return when
|
|
? ts.archivedAt.replace("{when}", formatRelative(when))
|
|
: ts.archivedAt.replace("{when}", "—");
|
|
}
|
|
const when = skill.last_activity_at;
|
|
return when
|
|
? ts.lastUsedAt.replace("{when}", formatRelative(when))
|
|
: ts.neverUsed;
|
|
}, [isArchived, skill.last_activity_at, ts.archivedAt, ts.lastUsedAt, ts.neverUsed]);
|
|
|
|
async function handleRestore() {
|
|
try {
|
|
await setState.mutateAsync({ skillName: skill.name, state: "active" });
|
|
toast.success(ts.restoreSuccess);
|
|
} catch (err) {
|
|
toast.error(err instanceof Error ? err.message : String(err));
|
|
}
|
|
}
|
|
|
|
async function handleArchive() {
|
|
try {
|
|
await setState.mutateAsync({ skillName: skill.name, state: "archived" });
|
|
toast.success(ts.archiveSuccess);
|
|
} catch (err) {
|
|
toast.error(err instanceof Error ? err.message : String(err));
|
|
}
|
|
}
|
|
|
|
async function handleDelete() {
|
|
try {
|
|
await deleteSkill.mutateAsync(skill.name);
|
|
toast.success(tt.deleteSuccess);
|
|
setConfirmDeleteOpen(false);
|
|
} catch (err) {
|
|
toast.error(err instanceof Error ? err.message : String(err));
|
|
}
|
|
}
|
|
|
|
return (
|
|
<>
|
|
<div className="bg-card flex flex-col gap-2 rounded-md border p-3">
|
|
<div className="flex items-start justify-between gap-3">
|
|
<div className="min-w-0 flex-1">
|
|
<div className="flex flex-wrap items-center gap-2">
|
|
<span className="font-medium">{desensitize(skill.name)}</span>
|
|
{isArchived ? (
|
|
<Badge variant="secondary" className="text-xs" title={tt.badgeArchivedTitle}>
|
|
{tt.badgeArchived}
|
|
</Badge>
|
|
) : (
|
|
<Badge
|
|
variant="outline"
|
|
className="border-amber-500/30 text-amber-700 dark:text-amber-300 text-xs"
|
|
title={tt.badgeStaleTitle}
|
|
>
|
|
{tt.badgeStale}
|
|
</Badge>
|
|
)}
|
|
{skill.source === "agent" && (
|
|
<Badge
|
|
variant="outline"
|
|
className="border-cyan-500/30 text-cyan-700 dark:text-cyan-300 text-xs"
|
|
title={tt.badgeSourceAgentTitle}
|
|
>
|
|
{tt.badgeSourceAgent}
|
|
</Badge>
|
|
)}
|
|
{skill.source === "upload" && (
|
|
<Badge
|
|
variant="outline"
|
|
className="border-zinc-400/40 text-zinc-600 dark:text-zinc-400 text-xs"
|
|
title={tt.badgeSourceUploadTitle}
|
|
>
|
|
{tt.badgeSourceUpload}
|
|
</Badge>
|
|
)}
|
|
</div>
|
|
<p className="text-muted-foreground mt-1 line-clamp-2 text-sm">
|
|
{desensitize(skill.description ?? "")}
|
|
</p>
|
|
<p className="text-muted-foreground mt-1 flex flex-wrap gap-x-3 text-xs">
|
|
<span>{timeLabel}</span>
|
|
<span>
|
|
{skill.use_count && skill.use_count > 0
|
|
? tt.useCountInline.replace(
|
|
"{count}",
|
|
String(skill.use_count),
|
|
)
|
|
: tt.useCountInlineZero}
|
|
</span>
|
|
</p>
|
|
</div>
|
|
</div>
|
|
<div className="flex items-center justify-end gap-2">
|
|
<Button
|
|
size="sm"
|
|
onClick={() => void handleRestore()}
|
|
disabled={pending}
|
|
>
|
|
<RotateCcwIcon className="size-3.5" />
|
|
{ts.actionRestore}
|
|
</Button>
|
|
{!isArchived && (
|
|
<Button
|
|
size="sm"
|
|
variant="outline"
|
|
onClick={() => void handleArchive()}
|
|
disabled={pending}
|
|
>
|
|
<ArchiveIcon className="size-3.5" />
|
|
{ts.actionArchiveNow}
|
|
</Button>
|
|
)}
|
|
<DropdownMenu>
|
|
<DropdownMenuTrigger asChild>
|
|
<Button
|
|
size="icon"
|
|
variant="ghost"
|
|
className="h-8 w-8 shrink-0"
|
|
disabled={pending}
|
|
title={ts.moreMenu}
|
|
>
|
|
<MoreHorizontalIcon className="size-4" />
|
|
</Button>
|
|
</DropdownMenuTrigger>
|
|
<DropdownMenuContent align="end">
|
|
<DropdownMenuItem onSelect={() => setViewOpen(true)}>
|
|
{ts.actionView}
|
|
</DropdownMenuItem>
|
|
<DropdownMenuItem
|
|
onSelect={() => setConfirmDeleteOpen(true)}
|
|
className="text-destructive focus:text-destructive"
|
|
>
|
|
<Trash2Icon className="size-3.5" />
|
|
{ts.actionDelete}
|
|
</DropdownMenuItem>
|
|
</DropdownMenuContent>
|
|
</DropdownMenu>
|
|
</div>
|
|
</div>
|
|
|
|
<SkillViewDialog
|
|
skill={skill}
|
|
open={viewOpen}
|
|
onOpenChange={setViewOpen}
|
|
/>
|
|
|
|
<Dialog open={confirmDeleteOpen} onOpenChange={setConfirmDeleteOpen}>
|
|
<DialogContent>
|
|
<DialogHeader>
|
|
<DialogTitle>{tt.deleteAction}</DialogTitle>
|
|
<DialogDescription>
|
|
{desensitize(tt.deleteConfirm.replace("{name}", skill.name))}
|
|
</DialogDescription>
|
|
</DialogHeader>
|
|
<DialogFooter>
|
|
<Button
|
|
variant="outline"
|
|
onClick={() => setConfirmDeleteOpen(false)}
|
|
disabled={deleteSkill.isPending}
|
|
>
|
|
{t.common.cancel}
|
|
</Button>
|
|
<Button
|
|
variant="destructive"
|
|
onClick={() => void handleDelete()}
|
|
disabled={deleteSkill.isPending}
|
|
>
|
|
{deleteSkill.isPending ? t.common.loading : t.common.delete}
|
|
</Button>
|
|
</DialogFooter>
|
|
</DialogContent>
|
|
</Dialog>
|
|
</>
|
|
);
|
|
}
|
|
|
|
function SkillViewDialog({
|
|
skill,
|
|
open,
|
|
onOpenChange,
|
|
}: {
|
|
skill: Skill;
|
|
open: boolean;
|
|
onOpenChange: (open: boolean) => void;
|
|
}) {
|
|
const { t } = useI18n();
|
|
const tv = t.settings.skills.viewDialog;
|
|
|
|
return (
|
|
<Dialog open={open} onOpenChange={onOpenChange}>
|
|
<DialogContent className="max-w-lg">
|
|
<DialogHeader>
|
|
<DialogTitle>{desensitize(skill.name)}</DialogTitle>
|
|
<DialogDescription>{tv.title}</DialogDescription>
|
|
</DialogHeader>
|
|
<div className="grid gap-3 text-sm">
|
|
<Row label={tv.descriptionLabel}>
|
|
<span className="whitespace-pre-wrap">{desensitize(skill.description ?? "")}</span>
|
|
</Row>
|
|
<Row label={tv.stateLabel}>
|
|
<span className={cn("font-medium", stateColor(skill.state))}>
|
|
{skill.state ?? "active"}
|
|
</span>
|
|
</Row>
|
|
{skill.use_count !== undefined && (
|
|
<Row label={tv.useCountLabel}>{skill.use_count}</Row>
|
|
)}
|
|
{skill.last_activity_at && (
|
|
<Row label={tv.lastUsedLabel}>
|
|
{formatRelative(skill.last_activity_at)}
|
|
</Row>
|
|
)}
|
|
</div>
|
|
<DialogFooter>
|
|
<Button variant="outline" onClick={() => onOpenChange(false)}>
|
|
{tv.close}
|
|
</Button>
|
|
</DialogFooter>
|
|
</DialogContent>
|
|
</Dialog>
|
|
);
|
|
}
|
|
|
|
function Row({ label, children }: { label: string; children: React.ReactNode }) {
|
|
return (
|
|
<div className="grid grid-cols-[80px_1fr] gap-2">
|
|
<span className="text-muted-foreground shrink-0 text-xs">{label}</span>
|
|
<div className="min-w-0">{children}</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function stateColor(state: string | undefined): string {
|
|
switch (state) {
|
|
case "archived":
|
|
return "text-muted-foreground";
|
|
case "stale":
|
|
return "text-amber-600 dark:text-amber-300";
|
|
default:
|
|
return "text-emerald-600 dark:text-emerald-300";
|
|
}
|
|
}
|
|
|
|
function formatRelative(iso: string): string {
|
|
const ms = Date.now() - new Date(iso).getTime();
|
|
if (Number.isNaN(ms)) return iso;
|
|
const sec = Math.max(0, Math.floor(ms / 1000));
|
|
const min = Math.floor(sec / 60);
|
|
const hour = Math.floor(min / 60);
|
|
const day = Math.floor(hour / 24);
|
|
if (day >= 1) return `${day}d ago`;
|
|
if (hour >= 1) return `${hour}h ago`;
|
|
if (min >= 1) return `${min}m ago`;
|
|
return "just now";
|
|
}
|