spiracha 2.0.0 → 2.2.0

package/apps/ui/src/routes/kiro.$workspaceKey.tsx

@@ -1,24 +1,36 @@
 import type { KiroSessionSummary, KiroWorkspaceGroup } from '@spiracha/lib/kiro-exporter-types';
-import { useMutation, useSuspenseQuery } from '@tanstack/react-query';
-import { createFileRoute } from '@tanstack/react-router';
-import { useDeferredValue, useState } from 'react';
+import { useMutation, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { createFileRoute, useNavigate } from '@tanstack/react-router';
+import { Trash2 } from 'lucide-react';
+import { useDeferredValue, useMemo, useState } from 'react';
+import { DeleteConfirmDialog } from '#/components/delete-confirm-dialog';
 import { ExportDialog } from '#/components/export-dialog';
 import { KiroSessionsTable } from '#/components/kiro-sessions-table';
 import { ListSearchInput } from '#/components/list-search-input';
 import { LoadingPanel } from '#/components/loading-panel';
 import { PageHeader } from '#/components/page-header';
-import { ReloadErrorPanel } from '#/components/reload-error-panel';
+import { RouteErrorPanel } from '#/components/route-error-panel';
+import { Button } from '#/components/ui/button';
 import { downloadTextFile, downloadUrlFile } from '#/lib/download';
+import { createExportSelectionMutationInput, type ExportSelectionMutationInput } from '#/lib/export-mutation';
 import { kiroSessionsQueryOptions, kiroWorkspacesQueryOptions } from '#/lib/kiro-queries';
-import { exportKiroSessionFn } from '#/lib/kiro-server';
+import {
+    deleteKiroSessionFn,
+    deleteKiroSessionsFn,
+    exportKiroSessionFn,
+    exportKiroSessionsFn,
+} from '#/lib/kiro-server';
 import { matchesTextQuery } from '#/lib/text-filter';
+import { isWorkspaceEmptiedByDelete } from '#/lib/workspace-delete-navigation';
 
-type ExportDialogOptions = {
-    includeCommentary: boolean;
-    includeMetadata: boolean;
-    includeTools: boolean;
-    outputFormat: 'md' | 'txt';
-    zipArchive: boolean;
+type PendingSessionDelete = {
+    scope: 'all' | 'selected';
+    sessions: KiroSessionSummary[];
+};
+
+type PendingSessionExport = {
+    label: string;
+    sessionIds: string[];
 };
 
 const findWorkspaceOrThrow = (workspaces: KiroWorkspaceGroup[], workspaceKey: string) => {
@@ -30,35 +42,89 @@ const findWorkspaceOrThrow = (workspaces: KiroWorkspaceGroup[], workspaceKey: st
     return workspace;
 };
 
+const buildSessionExport = (selectedSessions: KiroSessionSummary[]): PendingSessionExport => ({
+    label: selectedSessions.length === 1 ? selectedSessions[0]!.title : `${selectedSessions.length} selected sessions`,
+    sessionIds: selectedSessions.map((session) => session.sessionId),
+});
+
+const getDeleteConfirmLabel = (pendingDelete: PendingSessionDelete | null, isPending: boolean) => {
+    if (isPending) {
+        return 'Deleting...';
+    }
+
+    if (pendingDelete?.scope === 'all') {
+        return 'Delete all';
+    }
+
+    return pendingDelete && pendingDelete.sessions.length > 1 ? 'Delete sessions' : 'Delete session';
+};
+
+const getDeleteDescription = (pendingDelete: PendingSessionDelete | null) => {
+    if (!pendingDelete) {
+        return 'Permanently delete the selected Kiro sessions from disk.';
+    }
+
+    if (pendingDelete.scope === 'all') {
+        return `Permanently delete all ${pendingDelete.sessions.length} Kiro sessions in this workspace from disk. This removes session JSON files and matching execution files.`;
+    }
+
+    if (pendingDelete.sessions.length === 1) {
+        return `Permanently delete "${pendingDelete.sessions[0]!.title}" from Kiro history. This removes the session JSON file and matching execution files from disk.`;
+    }
+
+    return `Permanently delete ${pendingDelete.sessions.length} selected Kiro sessions from disk. This removes session JSON files and matching execution files.`;
+};
+
+const getDeleteTitle = (pendingDelete: PendingSessionDelete | null) => {
+    if (pendingDelete?.scope === 'all') {
+        return `Delete all ${pendingDelete.sessions.length} Kiro sessions?`;
+    }
+
+    return pendingDelete && pendingDelete.sessions.length > 1
+        ? `Delete ${pendingDelete.sessions.length} Kiro sessions?`
+        : 'Delete this Kiro session?';
+};
+
 const KiroWorkspaceErrorComponent = ({ error }: { error: Error }) => {
-    return <ReloadErrorPanel description={error.message} title="Failed to load Kiro workspace" />;
+    return <RouteErrorPanel error={error} title="Failed to load Kiro workspace" />;
 };
 
 const KiroWorkspacePage = () => {
+    const navigate = useNavigate({ from: Route.fullPath });
     const params = Route.useParams();
+    const queryClient = useQueryClient();
     const workspaces = useSuspenseQuery(kiroWorkspacesQueryOptions()).data;
     const workspace = findWorkspaceOrThrow(workspaces, params.workspaceKey);
     const sessions = useSuspenseQuery(kiroSessionsQueryOptions(workspace.key)).data;
     const [searchInput, setSearchInput] = useState('');
-    const [pendingExport, setPendingExport] = useState<KiroSessionSummary | null>(null);
+    const [pendingDelete, setPendingDelete] = useState<PendingSessionDelete | null>(null);
+    const [pendingExport, setPendingExport] = useState<PendingSessionExport | null>(null);
     const deferredSearch = useDeferredValue(searchInput);
 
     const exportMutation = useMutation({
-        mutationFn: async (options: ExportDialogOptions) => {
-            if (!pendingExport) {
-                throw new Error('No Kiro session selected for export');
-            }
-
-            const download = await exportKiroSessionFn({
-                data: {
-                    includeCommentary: options.includeCommentary,
-                    includeMetadata: options.includeMetadata,
-                    includeTools: options.includeTools,
-                    outputFormat: options.outputFormat,
-                    sessionId: pendingExport.sessionId,
-                    zipArchive: options.zipArchive,
-                },
-            });
+        mutationFn: async ({ ids, options }: ExportSelectionMutationInput) => {
+            const download =
+                ids.length === 1
+                    ? await exportKiroSessionFn({
+                          data: {
+                              includeCommentary: options.includeCommentary,
+                              includeMetadata: options.includeMetadata,
+                              includeTools: options.includeTools,
+                              outputFormat: options.outputFormat,
+                              sessionId: ids[0]!,
+                              zipArchive: options.zipArchive,
+                          },
+                      })
+                    : await exportKiroSessionsFn({
+                          data: {
+                              includeCommentary: options.includeCommentary,
+                              includeMetadata: options.includeMetadata,
+                              includeTools: options.includeTools,
+                              outputFormat: options.outputFormat,
+                              sessionIds: [...ids],
+                              zipArchive: options.zipArchive,
+                          },
+                      });
             if (download.mode === 'download') {
                 downloadTextFile(download.fileName, download.content, download.mimeType);
                 return;
@@ -71,40 +137,117 @@ const KiroWorkspacePage = () => {
         },
     });
 
-    const visibleSessions = sessions.filter((session) =>
-        matchesTextQuery(deferredSearch, [
-            session.title,
-            session.sessionId,
-            session.selectedModel,
-            session.defaultModelTitle,
-            session.selectedProfileId,
-            session.sessionType,
-            session.filePath,
-        ]),
+    const deleteMutation = useMutation({
+        mutationFn: async (sessionIds: string[]) =>
+            sessionIds.length === 1
+                ? deleteKiroSessionFn({ data: { sessionId: sessionIds[0]! } })
+                : deleteKiroSessionsFn({ data: { sessionIds } }),
+        onSettled: async (_result, _error, sessionIds) => {
+            await Promise.all([
+                queryClient.invalidateQueries({ queryKey: ['kiro-workspaces'] }),
+                queryClient.invalidateQueries({ queryKey: ['kiro-sessions', workspace.key] }),
+                ...sessionIds.map((sessionId) =>
+                    queryClient.invalidateQueries({ queryKey: ['kiro-session', sessionId] }),
+                ),
+            ]);
+        },
+        onSuccess: async (_result, sessionIds) => {
+            const workspaceEmptied = isWorkspaceEmptiedByDelete(sessions, sessionIds, (session) => session.sessionId);
+            setPendingDelete(null);
+            if (workspaceEmptied) {
+                await navigate({ to: '/kiro' });
+            }
+        },
+    });
+
+    const visibleSessions = useMemo(
+        () =>
+            sessions.filter((session) =>
+                matchesTextQuery(deferredSearch, [
+                    session.title,
+                    session.sessionId,
+                    session.selectedModel,
+                    session.defaultModelTitle,
+                    session.selectedProfileId,
+                    session.sessionType,
+                    session.filePath,
+                ]),
+            ),
+        [deferredSearch, sessions],
+    );
+    const visibleSessionsById = useMemo(
+        () => new Map(visibleSessions.map((session) => [session.sessionId, session])),
+        [visibleSessions],
     );
+    const lookupSelectedSessions = (sessionIds: string[]) =>
+        sessionIds
+            .map((sessionId) => visibleSessionsById.get(sessionId) ?? null)
+            .filter((session): session is KiroSessionSummary => session !== null);
+    const openExportForSessions = (selectedSessions: KiroSessionSummary[]) => {
+        if (selectedSessions.length === 0) {
+            return;
+        }
+
+        setPendingExport(buildSessionExport(selectedSessions));
+    };
+    const openDeleteForSessions = (selectedSessions: KiroSessionSummary[], scope: PendingSessionDelete['scope']) => {
+        if (selectedSessions.length > 0) {
+            setPendingDelete({ scope, sessions: selectedSessions });
+        }
+    };
 
     return (
         <div className="space-y-6">
             <PageHeader
                 actions={
-                    <ListSearchInput
-                        placeholder="Search session title, id, model, or type"
-                        value={searchInput}
-                        onValueChange={setSearchInput}
-                    />
+                    <div className="flex flex-col gap-2 sm:flex-row">
+                        <Button
+                            className="rounded-full"
+                            disabled={deleteMutation.isPending || sessions.length === 0}
+                            type="button"
+                            variant="destructive"
+                            onClick={() => openDeleteForSessions(sessions, 'all')}
+                        >
+                            <Trash2 className="size-4" />
+                            Delete all
+                        </Button>
+                        <ListSearchInput
+                            placeholder="Search session title, id, model, or type"
+                            value={searchInput}
+                            onValueChange={setSearchInput}
+                        />
+                    </div>
                 }
                 eyebrow="Kiro workspace"
                 subtitle="Inspect local Kiro sessions, user prompts, assistant responses, images, and prompt logs."
                 title={workspace.label}
             />
 
-            <KiroSessionsTable sessions={visibleSessions} onExportSession={setPendingExport} />
+            <KiroSessionsTable
+                sessions={visibleSessions}
+                onDeleteSession={(session) => openDeleteForSessions([session], 'selected')}
+                onDeleteSessions={(sessionIds) => openDeleteForSessions(lookupSelectedSessions(sessionIds), 'selected')}
+                onExportSession={(session) => openExportForSessions([session])}
+                onExportSessions={(sessionIds) => openExportForSessions(lookupSelectedSessions(sessionIds))}
+            />
 
             <ExportDialog
+                errorMessage={
+                    exportMutation.isError
+                        ? exportMutation.error instanceof Error
+                            ? exportMutation.error.message
+                            : 'Session export failed'
+                        : null
+                }
+                forceZipArchive={pendingExport ? pendingExport.sessionIds.length > 1 : false}
                 open={pendingExport !== null}
                 pending={exportMutation.isPending}
-                title={pendingExport ? `Export ${pendingExport.title}` : 'Export session'}
-                onExport={(options) => exportMutation.mutate(options)}
+                title={pendingExport ? `Export ${pendingExport.label}` : 'Export session'}
+                onExport={(options) => {
+                    if (pendingExport) {
+                        exportMutation.mutate(createExportSelectionMutationInput(pendingExport.sessionIds, options));
+                    }
+                }}
                 onOpenChange={(open) => {
                     if (!open) {
                         setPendingExport(null);
@@ -113,11 +256,30 @@ const KiroWorkspacePage = () => {
                 }}
             />
 
-            {exportMutation.isError ? (
-                <p className="text-[var(--destructive)] text-sm">
-                    {exportMutation.error instanceof Error ? exportMutation.error.message : 'Session export failed'}
-                </p>
-            ) : null}
+            <DeleteConfirmDialog
+                confirmLabel={getDeleteConfirmLabel(pendingDelete, deleteMutation.isPending)}
+                description={getDeleteDescription(pendingDelete)}
+                errorMessage={
+                    deleteMutation.isError
+                        ? deleteMutation.error instanceof Error
+                            ? deleteMutation.error.message
+                            : 'Session delete failed'
+                        : null
+                }
+                open={pendingDelete !== null}
+                title={getDeleteTitle(pendingDelete)}
+                onConfirm={() => {
+                    if (pendingDelete) {
+                        deleteMutation.mutate(pendingDelete.sessions.map((session) => session.sessionId));
+                    }
+                }}
+                onOpenChange={(open) => {
+                    if (!open) {
+                        setPendingDelete(null);
+                        deleteMutation.reset();
+                    }
+                }}
+            />
         </div>
     );
 };

package/apps/ui/src/routes/kiro.index.tsx

@@ -4,12 +4,12 @@ import { useDeferredValue, useState } from 'react';
 import { KiroWorkspacesTable } from '#/components/kiro-workspaces-table';
 import { ListSearchInput } from '#/components/list-search-input';
 import { PageHeader } from '#/components/page-header';
-import { ReloadErrorPanel } from '#/components/reload-error-panel';
+import { RouteErrorPanel } from '#/components/route-error-panel';
 import { kiroWorkspacesQueryOptions } from '#/lib/kiro-queries';
 import { matchesTextQuery } from '#/lib/text-filter';
 
 const KiroErrorComponent = ({ error }: { error: Error }) => {
-    return <ReloadErrorPanel description={error.message} title="Failed to load Kiro workspaces" />;
+    return <RouteErrorPanel error={error} title="Failed to load Kiro workspaces" />;
 };
 
 const KiroPage = () => {

package/apps/ui/src/routes/opencode-sessions.$sessionId.tsx

@@ -1,34 +1,30 @@
 import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
 import type { OpenCodeSessionTranscript } from '@spiracha/lib/opencode-exporter-types';
-import { useMutation, useSuspenseQuery } from '@tanstack/react-query';
-import { createFileRoute, Link } from '@tanstack/react-router';
-import { Download } from 'lucide-react';
+import { useMutation, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { createFileRoute, Link, useNavigate } from '@tanstack/react-router';
+import { Download, Trash2 } from 'lucide-react';
 import { useMemo, useState } from 'react';
 import { Breadcrumbs } from '#/components/breadcrumbs';
+import { DeleteConfirmDialog } from '#/components/delete-confirm-dialog';
 import { ExportDialog } from '#/components/export-dialog';
 import { JsonPanel } from '#/components/json-panel';
 import { LoadingPanel } from '#/components/loading-panel';
 import { MetadataSection } from '#/components/metadata-section';
 import { MetricCard } from '#/components/metric-card';
 import { PageHeader } from '#/components/page-header';
-import { ReloadErrorPanel } from '#/components/reload-error-panel';
-import { TranscriptView } from '#/components/transcript-view';
+import { RouteErrorPanel } from '#/components/route-error-panel';
+import { DEFAULT_SHOW_USER_MESSAGES, TranscriptView } from '#/components/transcript-view';
 import { Button } from '#/components/ui/button';
 import { Checkbox } from '#/components/ui/checkbox';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '#/components/ui/tabs';
 import { downloadTextFile, downloadUrlFile } from '#/lib/download';
+import type { ExportDialogOptions } from '#/lib/export-options';
 import { formatDateTime, formatList, formatNumber, formatTokens } from '#/lib/formatters';
-import { openCodeSessionDetailQueryOptions } from '#/lib/opencode-queries';
-import { exportOpenCodeSessionFn } from '#/lib/opencode-server';
+import { openCodeSessionDetailQueryOptions, openCodeWorkspacesQueryOptions } from '#/lib/opencode-queries';
+import { deleteOpenCodeSessionFn, exportOpenCodeSessionFn } from '#/lib/opencode-server';
 import { getOpenCodeThreadTranscriptStats, openCodeTranscriptToThreadEvents } from '#/lib/opencode-transcript-events';
-
-type ExportDialogOptions = {
-    includeCommentary: boolean;
-    includeMetadata: boolean;
-    includeTools: boolean;
-    outputFormat: 'md' | 'txt';
-    zipArchive: boolean;
-};
+import { RouteStateResetBoundary } from '#/lib/route-state-reset';
+import { shouldNavigateToSourceIndexAfterDelete } from '#/lib/workspace-delete-navigation';
 
 type TranscriptControlsProps = {
     rawJsonDisabled?: boolean;
@@ -45,7 +41,7 @@ type TranscriptControlsProps = {
 };
 
 const OpenCodeSessionDetailErrorComponent = ({ error }: { error: Error }) => {
-    return <ReloadErrorPanel description={error.message} title="Failed to load OpenCode session" />;
+    return <RouteErrorPanel error={error} title="Failed to load OpenCode session" />;
 };
 
 const buildSessionMetadata = (detail: OpenCodeSessionTranscript) => [
@@ -159,18 +155,26 @@ const OpenCodeRawPanels = ({ detail, events }: { detail: OpenCodeSessionTranscri
 };
 
 const OpenCodeSessionDetailPage = () => {
-    const detail = useSuspenseQuery(openCodeSessionDetailQueryOptions(Route.useParams().sessionId)).data;
+    const navigate = useNavigate();
+    const queryClient = useQueryClient();
+    const params = Route.useParams();
+    const detail = useSuspenseQuery(openCodeSessionDetailQueryOptions(params.sessionId)).data;
+    const [deleteOpen, setDeleteOpen] = useState(false);
     const [pendingExport, setPendingExport] = useState(false);
     const [showToolCalls, setShowToolCalls] = useState(false);
     const [showCommentary, setShowCommentary] = useState(false);
     const [showExtraEvents, setShowExtraEvents] = useState(false);
     const [showRawJson, setShowRawJson] = useState(false);
-    const [showUserMessages, setShowUserMessages] = useState(true);
-    const transcriptEvents = useMemo(() => openCodeTranscriptToThreadEvents(detail), [detail]);
+    const [showUserMessages, setShowUserMessages] = useState(DEFAULT_SHOW_USER_MESSAGES);
+    const transcriptEvents = useMemo(() => (detail ? openCodeTranscriptToThreadEvents(detail) : []), [detail]);
     const transcriptStats = useMemo(() => getOpenCodeThreadTranscriptStats(transcriptEvents), [transcriptEvents]);
 
     const exportSessionMutation = useMutation({
         mutationFn: async (options: ExportDialogOptions) => {
+            if (!detail) {
+                throw new Error(`OpenCode session not found: ${params.sessionId}`);
+            }
+
             const download = await exportOpenCodeSessionFn({
                 data: {
                     includeCommentary: options.includeCommentary,
@@ -193,19 +197,66 @@ const OpenCodeSessionDetailPage = () => {
         },
     });
 
+    const deleteSessionMutation = useMutation({
+        mutationFn: () => {
+            if (!detail) {
+                throw new Error(`OpenCode session not found: ${params.sessionId}`);
+            }
+
+            return deleteOpenCodeSessionFn({ data: { sessionId: detail.session.sessionId } });
+        },
+        onSuccess: async () => {
+            if (!detail) {
+                return;
+            }
+
+            await Promise.all([
+                queryClient.invalidateQueries({ queryKey: ['opencode-workspaces'] }),
+                queryClient.invalidateQueries({ queryKey: ['opencode-sessions', detail.session.workspaceKey] }),
+                queryClient.invalidateQueries({ queryKey: ['opencode-session', detail.session.sessionId] }),
+            ]);
+            const workspaces = await queryClient.fetchQuery(openCodeWorkspacesQueryOptions());
+            if (
+                shouldNavigateToSourceIndexAfterDelete(
+                    workspaces,
+                    detail.session.workspaceKey,
+                    (workspace) => workspace.key,
+                )
+            ) {
+                navigate({ to: '/opencode' });
+                return;
+            }
+            navigate({
+                params: { workspaceKey: detail.session.workspaceKey },
+                to: '/opencode/$workspaceKey',
+            });
+        },
+    });
+
     return (
         <div className="space-y-6">
             <PageHeader
                 actions={
-                    <Button
-                        className="rounded-full"
-                        type="button"
-                        variant="outline"
-                        onClick={() => setPendingExport(true)}
-                    >
-                        <Download className="mr-2 size-4" />
-                        Export
-                    </Button>
+                    <>
+                        <Button
+                            className="rounded-full"
+                            type="button"
+                            variant="outline"
+                            onClick={() => setPendingExport(true)}
+                        >
+                            <Download className="mr-2 size-4" />
+                            Export
+                        </Button>
+                        <Button
+                            className="rounded-full border-[var(--destructive)]/20 text-[var(--destructive)]"
+                            type="button"
+                            variant="outline"
+                            onClick={() => setDeleteOpen(true)}
+                        >
+                            <Trash2 className="mr-2 size-4" />
+                            Delete
+                        </Button>
+                    </>
                 }
                 breadcrumb={
                     <Breadcrumbs
@@ -316,12 +367,40 @@ const OpenCodeSessionDetailPage = () => {
                     }
                 }}
             />
+
+            <DeleteConfirmDialog
+                confirmLabel={deleteSessionMutation.isPending ? 'Deleting...' : 'Delete session'}
+                description="Permanently delete this OpenCode session from the database. This removes the session, child sessions, messages, and parts."
+                errorMessage={
+                    deleteSessionMutation.isError
+                        ? deleteSessionMutation.error instanceof Error
+                            ? deleteSessionMutation.error.message
+                            : 'Session delete failed'
+                        : null
+                }
+                open={deleteOpen}
+                title="Delete this OpenCode session?"
+                onConfirm={() => deleteSessionMutation.mutate()}
+                onOpenChange={(open) => {
+                    setDeleteOpen(open);
+                    if (!open) {
+                        deleteSessionMutation.reset();
+                    }
+                }}
+            />
         </div>
     );
 };
 
 export const Route = createFileRoute('/opencode-sessions/$sessionId')({
-    component: OpenCodeSessionDetailPage,
+    component: () => {
+        const { sessionId } = Route.useParams();
+        return (
+            <RouteStateResetBoundary routeKey={sessionId}>
+                <OpenCodeSessionDetailPage />
+            </RouteStateResetBoundary>
+        );
+    },
     errorComponent: OpenCodeSessionDetailErrorComponent,
     loader: ({ context, params }) =>
         context.queryClient.ensureQueryData(openCodeSessionDetailQueryOptions(params.sessionId)),