claude-deck 0.1.0

package/dist/parser/session-parser.js

@@ -0,0 +1,229 @@
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { estimateCost } from "./cost.js";
+const MAX_TOOL_INPUT_LENGTH = 2000;
+const MAX_TOOL_RESPONSE_LENGTH = 2000;
+function truncate(s, max) {
+    return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+}
+/** Strip XML system tags that get injected into user messages */
+function cleanPrompt(text) {
+    // Remove common system-injected XML blocks
+    return text
+        .replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, "")
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
+        .replace(/<command-name>[\s\S]*?<\/command-name>/g, "")
+        .replace(/<command-message>[\s\S]*?<\/command-message>/g, "")
+        .replace(/<command-args>[\s\S]*?<\/command-args>/g, "")
+        .replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g, "")
+        .trim();
+}
+export async function parseSessionJsonl(jsonlPath, sessionId, project, projectHash, jsonlMtime) {
+    const toolCalls = [];
+    const messages = [];
+    const compactions = [];
+    const modelCounts = new Map();
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheCreateTokens = 0;
+    let totalCost = 0;
+    let firstPrompt = null;
+    let startedAt = null;
+    let endedAt = null;
+    let turnCount = 0;
+    let lastRole = null;
+    let peakContextTokens = 0;
+    // Map tool_use_id → index in toolCalls for linking results
+    const toolUseIdMap = new Map();
+    // Track seen message IDs to avoid duplicate content extraction (tool_use blocks, text, turns)
+    // but NOT usage — usage is summed from every record to match claude /stats accounting.
+    const seenMessageIds = new Set();
+    const rl = createInterface({
+        input: createReadStream(jsonlPath),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue; // skip malformed lines
+        }
+        const ts = record.timestamp ?? "";
+        if (ts && !startedAt)
+            startedAt = ts;
+        if (ts)
+            endedAt = ts;
+        if (record.type === "assistant") {
+            const rec = record;
+            const msg = rec.message;
+            const msgId = msg.id;
+            const alreadySeen = msgId ? seenMessageIds.has(msgId) : false;
+            if (msgId)
+                seenMessageIds.add(msgId);
+            // Track model (only once per message)
+            if (msg.model && !alreadySeen) {
+                modelCounts.set(msg.model, (modelCounts.get(msg.model) ?? 0) + 1);
+            }
+            // Accumulate usage from every record (matches claude /stats accounting)
+            let turnCost = 0;
+            if (msg.usage) {
+                inputTokens += msg.usage.input_tokens ?? 0;
+                outputTokens += msg.usage.output_tokens ?? 0;
+                cacheReadTokens += msg.usage.cache_read_input_tokens ?? 0;
+                cacheCreateTokens += msg.usage.cache_creation_input_tokens ?? 0;
+                turnCost = estimateCost(msg.model ?? "claude-sonnet-4-6", msg.usage);
+                totalCost += turnCost;
+                // Track peak context fill (total tokens sent in a single API call)
+                const turnContext = (msg.usage.input_tokens ?? 0) +
+                    (msg.usage.cache_read_input_tokens ?? 0) +
+                    (msg.usage.cache_creation_input_tokens ?? 0);
+                if (turnContext > peakContextTokens)
+                    peakContextTokens = turnContext;
+            }
+            // Extract tool use blocks (deduplicate by tool_use_id to avoid duplicates)
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === "tool_use") {
+                        const tb = block;
+                        if (!toolUseIdMap.has(tb.id)) {
+                            const tc = {
+                                toolUseId: tb.id,
+                                toolName: tb.name,
+                                toolInput: truncate(JSON.stringify(tb.input), MAX_TOOL_INPUT_LENGTH),
+                                toolResponse: null,
+                                status: "pending",
+                                timestamp: ts,
+                                subagentId: null,
+                            };
+                            toolUseIdMap.set(tb.id, toolCalls.length);
+                            toolCalls.push(tc);
+                        }
+                    }
+                }
+                // Extract text for messages (only once per message)
+                if (!alreadySeen) {
+                    const text = extractText(msg.content);
+                    if (text.trim()) {
+                        messages.push({
+                            role: "assistant",
+                            content: text,
+                            timestamp: ts,
+                            model: msg.model ?? null,
+                            costUsd: turnCost,
+                        });
+                    }
+                }
+            }
+            // Track turns (only once per message ID)
+            if (!alreadySeen && lastRole !== "assistant")
+                turnCount++;
+            if (!alreadySeen)
+                lastRole = "assistant";
+        }
+        else if (record.type === "user") {
+            const rec = record;
+            // External user message
+            if (rec.userType === "external") {
+                const rawText = typeof rec.message?.content === "string"
+                    ? rec.message.content
+                    : extractText(rec.message?.content ?? []);
+                const text = cleanPrompt(rawText);
+                if (text) {
+                    messages.push({ role: "user", content: text, timestamp: ts, model: null, costUsd: null });
+                    if (!firstPrompt)
+                        firstPrompt = text;
+                }
+            }
+            // Tool result — match via top-level toolUseID or message.content tool_result blocks
+            if (rec.toolUseResult && rec.toolUseID) {
+                const idx = toolUseIdMap.get(rec.toolUseID);
+                if (idx !== undefined) {
+                    toolCalls[idx].status = "success";
+                    toolCalls[idx].toolResponse = truncate(JSON.stringify(rec.toolUseResult), MAX_TOOL_RESPONSE_LENGTH);
+                }
+            }
+            // Also check message.content for tool_result blocks (primary path for most tools)
+            const userContent = rec.message?.content;
+            if (Array.isArray(userContent)) {
+                for (const block of userContent) {
+                    if (block.type === "tool_result") {
+                        const idx = toolUseIdMap.get(block.tool_use_id);
+                        if (idx !== undefined && !toolCalls[idx].toolResponse) {
+                            toolCalls[idx].status = "success";
+                            toolCalls[idx].toolResponse = truncate(typeof block.content === "string"
+                                ? block.content
+                                : JSON.stringify(block.content ?? ""), MAX_TOOL_RESPONSE_LENGTH);
+                        }
+                    }
+                }
+            }
+            if (rec.userType === "external") {
+                lastRole = "user";
+            }
+        }
+        else if (record.type === "system" &&
+            record.subtype === "compact_boundary") {
+            const rec = record;
+            if (rec.compactMetadata) {
+                compactions.push({
+                    timestamp: ts,
+                    trigger: rec.compactMetadata.trigger ?? "auto",
+                    preTokens: rec.compactMetadata.preTokens ?? 0,
+                });
+            }
+        }
+    }
+    // Determine primary model
+    let primaryModel = null;
+    let maxCount = 0;
+    for (const [model, count] of modelCounts) {
+        if (count > maxCount) {
+            primaryModel = model;
+            maxCount = count;
+        }
+    }
+    // Calculate duration
+    let durationMs = null;
+    if (startedAt && endedAt) {
+        durationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+    }
+    return {
+        id: sessionId,
+        project,
+        projectHash,
+        firstPrompt,
+        model: primaryModel,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreateTokens,
+        estimatedCostUsd: totalCost,
+        messageCount: messages.length,
+        toolCallCount: toolCalls.length,
+        subagentCount: 0, // filled in by index.ts after subagent parsing
+        turnCount,
+        peakContextTokens,
+        startedAt,
+        endedAt,
+        durationMs,
+        jsonlPath,
+        jsonlMtime,
+        toolCalls,
+        messages,
+        subagents: [],
+        compactions,
+    };
+}

package/dist/parser/subagent-parser.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedSubagent, ParsedToolCall } from "../types.js";
+export declare function parseSubagentJsonl(jsonlPath: string, agentId: string, sessionId: string): Promise<{
+    subagent: ParsedSubagent;
+    toolCalls: ParsedToolCall[];
+}>;

package/dist/parser/subagent-parser.js

@@ -0,0 +1,150 @@
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { estimateCost } from "./cost.js";
+const MAX_TOOL_INPUT_LENGTH = 2000;
+const MAX_TOOL_RESPONSE_LENGTH = 2000;
+function truncate(s, max) {
+    return s.length > max ? s.slice(0, max) + "..." : s;
+}
+export async function parseSubagentJsonl(jsonlPath, agentId, sessionId) {
+    const toolCalls = [];
+    const toolUseIdMap = new Map();
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheCreateTokens = 0;
+    let totalCost = 0;
+    let agentType = null;
+    let prompt = null;
+    let lastAssistantText = null;
+    let startedAt = null;
+    let endedAt = null;
+    const modelCounts = new Map();
+    const seenMessageIds = new Set();
+    const rl = createInterface({
+        input: createReadStream(jsonlPath),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const ts = record.timestamp ?? "";
+        if (ts && !startedAt)
+            startedAt = ts;
+        if (ts)
+            endedAt = ts;
+        if (record.type === "assistant") {
+            const rec = record;
+            const msg = rec.message;
+            const msgId = msg.id;
+            const alreadySeen = msgId ? seenMessageIds.has(msgId) : false;
+            if (msgId)
+                seenMessageIds.add(msgId);
+            if (msg.model && !alreadySeen) {
+                modelCounts.set(msg.model, (modelCounts.get(msg.model) ?? 0) + 1);
+            }
+            // Accumulate usage from every record (matches claude /stats accounting)
+            if (msg.usage) {
+                inputTokens += msg.usage.input_tokens ?? 0;
+                outputTokens += msg.usage.output_tokens ?? 0;
+                cacheReadTokens += msg.usage.cache_read_input_tokens ?? 0;
+                cacheCreateTokens += msg.usage.cache_creation_input_tokens ?? 0;
+                totalCost += estimateCost(msg.model ?? "claude-sonnet-4-6", msg.usage);
+            }
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === "tool_use") {
+                        const tb = block;
+                        if (!toolUseIdMap.has(tb.id)) {
+                            const tc = {
+                                toolUseId: tb.id,
+                                toolName: tb.name,
+                                toolInput: truncate(JSON.stringify(tb.input), MAX_TOOL_INPUT_LENGTH),
+                                toolResponse: null,
+                                status: "pending",
+                                timestamp: ts,
+                                subagentId: agentId,
+                            };
+                            toolUseIdMap.set(tb.id, toolCalls.length);
+                            toolCalls.push(tc);
+                        }
+                    }
+                    else if (block.type === "text" && "text" in block) {
+                        lastAssistantText = block.text;
+                    }
+                }
+            }
+        }
+        else if (record.type === "user") {
+            const rec = record;
+            // Try to extract agent type and prompt from the first user message
+            if (!prompt && rec.userType === "external") {
+                const content = typeof rec.message?.content === "string"
+                    ? rec.message.content
+                    : Array.isArray(rec.message?.content)
+                        ? rec.message.content
+                            .filter((b) => b.type === "text")
+                            .map((b) => b.text)
+                            .join("\n")
+                        : "";
+                if (content)
+                    prompt = content.slice(0, 500);
+            }
+            // Tool result
+            if (rec.toolUseResult && rec.toolUseID) {
+                const idx = toolUseIdMap.get(rec.toolUseID);
+                if (idx !== undefined) {
+                    toolCalls[idx].status = "success";
+                    toolCalls[idx].toolResponse = truncate(JSON.stringify(rec.toolUseResult), MAX_TOOL_RESPONSE_LENGTH);
+                }
+            }
+        }
+    }
+    // Try to infer agent type from the agent ID path or prompt
+    if (!agentType && prompt) {
+        const lower = prompt.toLowerCase();
+        if (lower.includes("explore") || lower.includes("search"))
+            agentType = "Explore";
+        else if (lower.includes("plan"))
+            agentType = "Plan";
+        else
+            agentType = "general-purpose";
+    }
+    // Determine primary model
+    let model = null;
+    let maxCount = 0;
+    for (const [m, count] of modelCounts) {
+        if (count > maxCount) {
+            model = m;
+            maxCount = count;
+        }
+    }
+    let durationMs = null;
+    if (startedAt && endedAt) {
+        durationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+    }
+    return {
+        subagent: {
+            id: agentId,
+            agentType,
+            model,
+            prompt,
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            cacheCreateTokens,
+            estimatedCostUsd: totalCost,
+            toolCallCount: toolCalls.length,
+            durationMs,
+            resultSummary: lastAssistantText?.slice(0, 500) ?? null,
+        },
+        toolCalls,
+    };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+import type Database from "better-sqlite3";
+export declare function startServer(db: Database.Database, claudeDir: string, port: number): Promise<string>;

package/dist/server/index.js

@@ -0,0 +1,52 @@
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import fastifyCors from "@fastify/cors";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { registerSessionRoutes } from "./routes/sessions.js";
+import { registerStatsRoutes } from "./routes/stats.js";
+import { registerSyncRoutes } from "./routes/sync.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export async function startServer(db, claudeDir, port) {
+    const app = Fastify({ logger: false });
+    await app.register(fastifyCors, { origin: true });
+    // API routes
+    registerSessionRoutes(app, db);
+    registerStatsRoutes(app, db);
+    registerSyncRoutes(app, db, claudeDir);
+    // Serve dashboard static files
+    // In dev: dashboard files are in ../dashboard relative to dist/server/
+    // When published: dashboard/ is at package root
+    const dashboardPaths = [
+        join(__dirname, "..", "..", "dashboard"), // from dist/server/
+        join(__dirname, "..", "dashboard"), // fallback
+    ];
+    let dashboardDir = null;
+    for (const p of dashboardPaths) {
+        if (existsSync(p)) {
+            dashboardDir = p;
+            break;
+        }
+    }
+    if (dashboardDir) {
+        await app.register(fastifyStatic, {
+            root: dashboardDir,
+            prefix: "/",
+            wildcard: false,
+        });
+        // SPA fallback — serve index.html for non-API routes
+        app.setNotFoundHandler(async (_req, reply) => {
+            return reply.sendFile("index.html", dashboardDir);
+        });
+    }
+    else {
+        app.get("/", async () => {
+            return {
+                message: "Claude Deck API is running. Dashboard not found — run 'npm run build:ui' first.",
+            };
+        });
+    }
+    const address = await app.listen({ port, host: "0.0.0.0" });
+    return address;
+}

package/dist/server/routes/sessions.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type Database from "better-sqlite3";
+export declare function registerSessionRoutes(app: FastifyInstance, db: Database.Database): void;

package/dist/server/routes/sessions.js

@@ -0,0 +1,31 @@
+import { listSessions, getSession, getTimeline, getSubagents, getSessionInsights, } from "../../db/queries.js";
+export function registerSessionRoutes(app, db) {
+    app.get("/api/sessions", async (req) => {
+        const q = req.query;
+        return listSessions(db, {
+            project: q.project,
+            model: q.model,
+            after: q.after,
+            before: q.before,
+            sort: q.sort,
+            limit: q.limit ? parseInt(q.limit) : undefined,
+            offset: q.offset ? parseInt(q.offset) : undefined,
+        });
+    });
+    app.get("/api/sessions/:id", async (req) => {
+        const session = getSession(db, req.params.id);
+        if (!session) {
+            return { error: "Session not found" };
+        }
+        return session;
+    });
+    app.get("/api/sessions/:id/timeline", async (req) => {
+        return getTimeline(db, req.params.id);
+    });
+    app.get("/api/sessions/:id/subagents", async (req) => {
+        return getSubagents(db, req.params.id);
+    });
+    app.get("/api/sessions/:id/insights", async (req) => {
+        return getSessionInsights(db, req.params.id);
+    });
+}

package/dist/server/routes/stats.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type Database from "better-sqlite3";
+export declare function registerStatsRoutes(app: FastifyInstance, db: Database.Database): void;

package/dist/server/routes/stats.js

@@ -0,0 +1,11 @@
+import { getStats } from "../../db/queries.js";
+export function registerStatsRoutes(app, db) {
+    app.get("/api/stats", async (req) => {
+        const q = req.query;
+        return getStats(db, {
+            after: q.after,
+            before: q.before,
+            model: q.model,
+        });
+    });
+}

package/dist/server/routes/sync.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type Database from "better-sqlite3";
+export declare function registerSyncRoutes(app: FastifyInstance, db: Database.Database, claudeDir: string): void;

package/dist/server/routes/sync.js

@@ -0,0 +1,11 @@
+import { syncAll } from "../../parser/index.js";
+import { getSyncStatus } from "../../db/queries.js";
+export function registerSyncRoutes(app, db, claudeDir) {
+    app.post("/api/sync", async () => {
+        const result = await syncAll(db, claudeDir);
+        return result;
+    });
+    app.get("/api/sync/status", async () => {
+        return getSyncStatus(db);
+    });
+}