spiracha 2.0.0 → 2.1.0

package/src/lib/grok-exporter-types.ts

@@ -0,0 +1,110 @@
+import os from 'node:os';
+import path from 'node:path';
+import type { ExportFormat, JsonValue } from './shared';
+
+export const getDefaultGrokHome = (_env: NodeJS.ProcessEnv = process.env, homeDir = os.homedir()): string => {
+    return path.join(homeDir, '.grok');
+};
+
+export const DEFAULT_GROK_HOME = getDefaultGrokHome();
+
+export const resolveGrokHome = (): string => {
+    const configured = process.env.SPIRACHA_GROK_HOME?.trim() || process.env.SPIRACHA_GROK_DIR?.trim();
+    return configured ? configured : DEFAULT_GROK_HOME;
+};
+
+export const resolveGrokSessionsDir = (): string => {
+    const configured = process.env.SPIRACHA_GROK_SESSIONS_DIR?.trim();
+    return configured ? configured : path.join(resolveGrokHome(), 'sessions');
+};
+
+export type GrokWorkspaceGroup = {
+    assistantMessageCount: number;
+    chatMessageCount: number;
+    directoryName: string;
+    key: string;
+    label: string;
+    lastActiveAtIso: string | null;
+    lastActiveAtMs: number | null;
+    messageCount: number;
+    reasoningCount: number;
+    sessionCount: number;
+    toolCallCount: number;
+    toolResultCount: number;
+    uri: string;
+    userMessageCount: number;
+    worktree: string;
+};
+
+export type GrokSessionSummary = {
+    agentName: string | null;
+    assistantMessageCount: number;
+    chatHistoryPath: string;
+    chatMessageCount: number;
+    createdAtIso: string | null;
+    createdAtMs: number | null;
+    currentModelId: string | null;
+    cwd: string | null;
+    gitBranch: string | null;
+    gitRemotes: string[];
+    gitRootDir: string | null;
+    headCommit: string | null;
+    lastActiveAtIso: string | null;
+    lastActiveAtMs: number | null;
+    messageCount: number;
+    modelLabel: string | null;
+    reasoningCount: number;
+    renderablePartCount: number;
+    sandboxProfile: string | null;
+    sessionDir: string;
+    sessionId: string;
+    summaryPath: string;
+    title: string;
+    toolCallCount: number;
+    toolResultCount: number;
+    updatesPath: string | null;
+    userMessageCount: number;
+    workspaceKey: string;
+    workspaceLabel: string;
+    worktree: string;
+};
+
+export type GrokPartType = 'reasoning' | 'text' | 'tool_call' | 'tool_result' | 'unknown';
+
+export type GrokTranscriptPart = {
+    argumentsText?: string | null;
+    outputText?: string | null;
+    partId: string;
+    raw: Record<string, JsonValue>;
+    text?: string;
+    toolCallId?: string | null;
+    toolName?: string | null;
+    type: GrokPartType;
+};
+
+export type GrokTranscriptEntry = {
+    createdAtMs: number | null;
+    entryId: string;
+    modelFingerprint?: string | null;
+    modelId?: string | null;
+    parts: GrokTranscriptPart[];
+    raw: Record<string, JsonValue>;
+    role: string;
+    timestamp: string | null;
+    type: string;
+};
+
+export type GrokSessionTranscript = {
+    entries: GrokTranscriptEntry[];
+    rawEvents: Record<string, JsonValue>[];
+    rawPayloadsOmitted?: boolean;
+    renderablePartCount: number;
+    session: GrokSessionSummary;
+};
+
+export type GrokExportOptions = {
+    includeCommentary: boolean;
+    includeMetadata: boolean;
+    includeTools: boolean;
+    outputFormat: ExportFormat;
+};

package/src/lib/grok-transcript-phase.ts

@@ -0,0 +1,52 @@
+import type { GrokTranscriptEntry, GrokTranscriptPart } from './grok-exporter-types';
+
+export type GrokAssistantMessagePhase = 'commentary' | 'final_answer' | 'unknown';
+
+export const getFinalGrokAssistantTextPartIds = (entries: GrokTranscriptEntry[]): Set<string> => {
+    const finalPartIds = new Set<string>();
+    let latestAssistantTextPartId: string | null = null;
+
+    const flushAssistantRun = () => {
+        if (latestAssistantTextPartId) {
+            finalPartIds.add(latestAssistantTextPartId);
+            latestAssistantTextPartId = null;
+        }
+    };
+
+    for (const entry of entries) {
+        if (entry.role === 'user') {
+            flushAssistantRun();
+            continue;
+        }
+
+        if (entry.role !== 'assistant') {
+            continue;
+        }
+
+        for (const part of entry.parts) {
+            if (part.type === 'tool_call') {
+                latestAssistantTextPartId = null;
+                continue;
+            }
+
+            if (part.type === 'text' && part.text?.trim()) {
+                latestAssistantTextPartId = part.partId;
+            }
+        }
+    }
+
+    flushAssistantRun();
+    return finalPartIds;
+};
+
+export const getGrokTextPartPhase = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    finalTextPartIds: Set<string>,
+): GrokAssistantMessagePhase => {
+    if (entry.role !== 'assistant') {
+        return 'unknown';
+    }
+
+    return finalTextPartIds.has(part.partId) ? 'final_answer' : 'commentary';
+};

package/src/lib/grok-transcript.ts

@@ -0,0 +1,154 @@
+import type {
+    GrokExportOptions,
+    GrokSessionSummary,
+    GrokSessionTranscript,
+    GrokTranscriptEntry,
+    GrokTranscriptPart,
+} from './grok-exporter-types';
+import {
+    cleanExtractedText,
+    cleanInlineTitle,
+    formatInlineLiteral,
+    type MetadataEntry,
+    renderCodeBlock,
+    renderDocumentTitle,
+    renderMetadataBlock,
+    renderSection,
+} from './shared';
+
+const TOOL_OUTPUT_PREVIEW_LIMIT = 4000;
+
+const getSessionTitle = (session: GrokSessionSummary): string => {
+    return cleanInlineTitle(session.title || session.sessionId);
+};
+
+const buildMetadataEntries = (session: GrokSessionSummary): MetadataEntry[] => [
+    { key: 'exported_from', value: 'grok_local_session' },
+    { key: 'session_id', value: session.sessionId },
+    { key: 'title', value: session.title },
+    { key: 'source_transcript_path', value: session.chatHistoryPath },
+    { key: 'workspace_key', value: session.workspaceKey },
+    { key: 'worktree', value: session.worktree },
+    { key: 'cwd', value: session.cwd },
+    { key: 'model', value: session.currentModelId },
+    { key: 'model_label', value: session.modelLabel },
+    { key: 'agent_name', value: session.agentName },
+    { key: 'git_branch', value: session.gitBranch },
+    { key: 'created_at_iso', value: session.createdAtIso },
+    { key: 'last_active_at_iso', value: session.lastActiveAtIso },
+    { key: 'message_count', value: session.messageCount },
+    { key: 'tool_call_count', value: session.toolCallCount },
+    { key: 'tool_result_count', value: session.toolResultCount },
+];
+
+const roleTitle = (role: string): string => {
+    if (role === 'assistant') {
+        return 'Assistant';
+    }
+
+    if (role === 'user') {
+        return 'User';
+    }
+
+    if (role === 'system') {
+        return 'System';
+    }
+
+    if (role === 'tool') {
+        return 'Tool';
+    }
+
+    return role ? cleanInlineTitle(role) : 'Message';
+};
+
+const truncateOutput = (text: string): string => {
+    if (text.length <= TOOL_OUTPUT_PREVIEW_LIMIT) {
+        return text;
+    }
+
+    return `${text.slice(0, TOOL_OUTPUT_PREVIEW_LIMIT)}\n... (truncated)`;
+};
+
+const renderTextPart = (entry: GrokTranscriptEntry, part: GrokTranscriptPart, options: GrokExportOptions): string => {
+    const text = cleanExtractedText(part.text ?? '').trim();
+    return text ? renderSection(roleTitle(entry.role), text, options.outputFormat) : '';
+};
+
+const renderReasoningPart = (part: GrokTranscriptPart, options: GrokExportOptions): string => {
+    if (!options.includeCommentary) {
+        return '';
+    }
+
+    const text = cleanExtractedText(part.text ?? '').trim();
+    return text ? renderSection('Reasoning', text, options.outputFormat) : '';
+};
+
+const renderToolCallPart = (part: GrokTranscriptPart, options: GrokExportOptions): string => {
+    if (!options.includeTools) {
+        return '';
+    }
+
+    const toolName = part.toolName ?? 'unknown';
+    const lines = [`Tool: ${formatInlineLiteral(toolName, options.outputFormat)}`];
+    if (part.toolCallId) {
+        lines.push(`Call ID: ${part.toolCallId}`);
+    }
+    if (part.argumentsText?.trim()) {
+        lines.push('', 'Input:', '', renderCodeBlock(part.argumentsText.trim(), options.outputFormat));
+    }
+
+    return renderSection('Tool Call', lines.join('\n'), options.outputFormat);
+};
+
+const renderToolResultPart = (part: GrokTranscriptPart, options: GrokExportOptions): string => {
+    if (!options.includeTools) {
+        return '';
+    }
+
+    const outputText = part.outputText?.trim();
+    if (!outputText) {
+        return '';
+    }
+
+    const lines: string[] = [];
+    if (part.toolCallId) {
+        lines.push(`Call ID: ${part.toolCallId}`, '');
+    }
+    lines.push(renderCodeBlock(truncateOutput(outputText), options.outputFormat));
+    return renderSection('Tool Output', lines.join('\n'), options.outputFormat);
+};
+
+const renderPart = (entry: GrokTranscriptEntry, part: GrokTranscriptPart, options: GrokExportOptions): string => {
+    switch (part.type) {
+        case 'text':
+            return renderTextPart(entry, part, options);
+        case 'reasoning':
+            return renderReasoningPart(part, options);
+        case 'tool_call':
+            return renderToolCallPart(part, options);
+        case 'tool_result':
+            return renderToolResultPart(part, options);
+        case 'unknown':
+            return '';
+    }
+};
+
+export const renderGrokTranscript = (transcript: GrokSessionTranscript, options: GrokExportOptions): string | null => {
+    const sections = transcript.entries.flatMap((entry) =>
+        entry.parts.map((part) => renderPart(entry, part, options)).filter(Boolean),
+    );
+    if (sections.length === 0) {
+        return null;
+    }
+
+    const parts = [
+        renderDocumentTitle(getSessionTitle(transcript.session), options.outputFormat),
+        '',
+        options.includeMetadata
+            ? renderMetadataBlock(buildMetadataEntries(transcript.session), options.outputFormat)
+            : '',
+        ...sections,
+    ].filter(Boolean);
+
+    return `${parts.join('\n').trimEnd()}\n`;
+};

package/src/lib/kiro-db.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { readdir, stat } from 'node:fs/promises';
+import { readdir, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { mapWithConcurrency } from './concurrency';
 import {
@@ -45,6 +45,11 @@ type KiroExecutionFile = {
     raw: Record<string, JsonValue>;
 };
 
+export type DeleteKiroSessionResult = {
+    deletedFiles: string[];
+    deletedSessionIds: string[];
+};
+
 type ReadSessionFileOptions = {
     includeExecutions?: boolean;
     sessionsDir: string;
@@ -932,6 +937,23 @@ const locateSessionFile = async (sessionsDir: string, sessionId: string): Promis
     return files.find((file) => path.basename(file.filePath, '.json') === sessionId) ?? null;
 };
 
+const removeKiroSessionIndexEntry = async (workspaceDir: string, sessionId: string): Promise<void> => {
+    const indexPath = path.join(workspaceDir, 'sessions.json');
+    const value = (await Bun.file(indexPath)
+        .json()
+        .catch(() => null)) as JsonValue | null;
+    if (!Array.isArray(value)) {
+        return;
+    }
+
+    const next = value.filter((item) => asString(asObject(item)?.sessionId ?? null) !== sessionId);
+    if (next.length === value.length) {
+        return;
+    }
+
+    await Bun.write(indexPath, JSON.stringify(next, null, 2));
+};
+
 export const readKiroSessionTranscript = async (
     sessionsDir: string,
     sessionId: string,
@@ -947,3 +969,32 @@ export const readKiroSessionTranscript = async (
 
     return readSessionFile(file, { includeExecutions: true, sessionsDir });
 };
+
+export const deleteKiroSession = async (sessionsDir: string, sessionId: string): Promise<DeleteKiroSessionResult> => {
+    if (!(await pathExists(sessionsDir))) {
+        return { deletedFiles: [], deletedSessionIds: [] };
+    }
+
+    const file = await locateSessionFile(sessionsDir, sessionId);
+    if (!file) {
+        return { deletedFiles: [], deletedSessionIds: [] };
+    }
+
+    const transcript = await readSessionFile(file, { includeExecutions: false, sessionsDir });
+    const executionFiles = transcript
+        ? await listExecutionFilesForSession(
+              getKiroDataDirFromSessionsDir(sessionsDir),
+              sessionId,
+              transcript.session.worktree,
+          )
+        : [];
+    const deletedFiles = [file.filePath, ...executionFiles.map((execution) => execution.filePath)];
+
+    await Promise.all(deletedFiles.map((filePath) => rm(filePath, { force: true })));
+    await removeKiroSessionIndexEntry(path.dirname(file.filePath), sessionId);
+
+    return {
+        deletedFiles,
+        deletedSessionIds: [sessionId],
+    };
+};

package/src/lib/model-label.ts

@@ -3,9 +3,17 @@ export const formatModelLabel = (value: string | null | undefined): string => {
         return 'Assistant';
     }
 
-    return value
-        .split(/[-_\s]+/u)
-        .filter(Boolean)
+    const parts = value.split(/[-_\s]+/u).filter(Boolean);
+    if (parts[0]?.toLowerCase() === 'claude') {
+        const majorIndex = parts.findIndex(
+            (part, index) => /^\d{1,2}$/u.test(part) && /^\d{1,2}$/u.test(parts[index + 1] ?? ''),
+        );
+        if (majorIndex >= 0) {
+            parts.splice(majorIndex, 2, `${parts[majorIndex]}.${parts[majorIndex + 1]}`);
+        }
+    }
+
+    return parts
         .map((part) => {
             const lower = part.toLowerCase();
             if (lower === 'gpt') {