sessioner 0.1.0

package/lib/sessions/extract-messages.d.ts

@@ -0,0 +1,5 @@
+import type { Session } from '../types.js';
+export declare const extractMessages: (session: Session) => Promise<{
+    total: number;
+    lines: [number, string][];
+}>;

package/lib/sessions/extract-messages.js

@@ -0,0 +1,43 @@
+import { readFile } from 'node:fs/promises';
+export const extractMessages = async (session) => {
+    const raw = await readFile(session.file, 'utf-8');
+    const rawLines = raw.split('\n');
+    const lines = [];
+    let ordinal = 0;
+    for (const line of rawLines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.type !== 'user' && parsed.type !== 'assistant')
+                continue;
+            const role = parsed.type === 'user' ? '[ YOU ]' : '[ LLM ]';
+            const content = parsed.message?.content ?? [];
+            let text = '';
+            for (const block of content) {
+                if (block.type === 'text' && block.text) {
+                    text = block.text;
+                    break;
+                }
+                if (block.type === 'tool_result' && block.content) {
+                    if (typeof block.content === 'string') {
+                        text = block.content;
+                        break;
+                    }
+                    if (Array.isArray(block.content)) {
+                        const sub = block.content.find((item) => item.text);
+                        if (sub)
+                            text = sub.text;
+                        break;
+                    }
+                }
+            }
+            text = text.replace(/\r?\n/g, ' ').trim().replace(/ {2,}/g, ' ');
+            if (text)
+                lines.push([ordinal, `${role} ${text}`]);
+            ordinal++;
+        }
+        catch { }
+    }
+    return { total: ordinal, lines: lines.reverse() };
+};

package/lib/sessions/get-entries.d.ts

@@ -0,0 +1 @@
+export declare const getEntries: (dir: string) => Promise<Map<string, Date>>;

package/lib/sessions/get-entries.js

@@ -0,0 +1,25 @@
+import { readdir, stat } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+export const getEntries = async (dir) => {
+    try {
+        const names = await readdir(dir);
+        const jsonl = names.filter((name) => name.endsWith('.jsonl'));
+        const files = await Promise.all(jsonl.map(async (name) => {
+            const path = join(dir, name);
+            const { mtime } = await stat(path);
+            return { file: path, mtime };
+        }));
+        files.sort((first, second) => second.mtime.getTime() - first.mtime.getTime());
+        const entries = new Map();
+        for (const { file, mtime } of files) {
+            const id = basename(file, '.jsonl');
+            if (id.startsWith('agent-'))
+                continue;
+            entries.set(file, mtime);
+        }
+        return entries;
+    }
+    catch {
+        return new Map();
+    }
+};

package/lib/sessions/list-sessions.d.ts

@@ -0,0 +1,2 @@
+import type { ListResult } from '../types.js';
+export declare const listSessions: (path?: string, base?: string) => Promise<ListResult>;

package/lib/sessions/list-sessions.js

@@ -0,0 +1,29 @@
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { formatDate } from '../helpers/format-date.js';
+import { extractFirstUserMessage } from './extract-first-user-message.js';
+import { getEntries } from './get-entries.js';
+const defaultBase = join(homedir(), '.claude', 'projects');
+export const listSessions = async (path, base) => {
+    const projectDir = join(base ?? defaultBase, (path ?? process.cwd()).replace(/[^a-zA-Z0-9]/g, '-'));
+    const entries = await getEntries(projectDir);
+    const sessions = [];
+    const empty = [];
+    const results = await Promise.all([...entries].map(async ([file, mtime]) => {
+        const message = await extractFirstUserMessage(file);
+        return { file, mtime, message };
+    }));
+    for (const { file, mtime, message } of results) {
+        if (!message) {
+            empty.push(file);
+            continue;
+        }
+        sessions.push({
+            id: basename(file, '.jsonl'),
+            date: formatDate(mtime),
+            message,
+            file,
+        });
+    }
+    return { sessions, empty };
+};

package/lib/sessions/parse-line.d.ts

@@ -0,0 +1,2 @@
+import type { Message } from '../types.js';
+export declare const parseLine: (line: string) => Message | null;

package/lib/sessions/parse-line.js

@@ -0,0 +1,8 @@
+export const parseLine = (line) => {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+};

package/lib/sessions/rewrite-jsonl.d.ts

@@ -0,0 +1 @@
+export declare const rewriteJsonl: (content: string, sessionId: string) => string;

package/lib/sessions/rewrite-jsonl.js

@@ -0,0 +1,34 @@
+import { randomUUID } from 'node:crypto';
+export const rewriteJsonl = (content, sessionId) => {
+    const lines = content.split('\n');
+    const uuidMap = new Map();
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.uuid)
+                uuidMap.set(parsed.uuid, randomUUID());
+        }
+        catch { }
+    }
+    return lines
+        .map((line) => {
+        if (!line.trim())
+            return line;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.uuid)
+                parsed.uuid = uuidMap.get(parsed.uuid);
+            if (parsed.parentUuid)
+                parsed.parentUuid = uuidMap.get(parsed.parentUuid) ?? randomUUID();
+            if (parsed.sessionId)
+                parsed.sessionId = sessionId;
+            return JSON.stringify(parsed);
+        }
+        catch {
+            return line;
+        }
+    })
+        .join('\n');
+};

package/lib/sessions/stats.d.ts

@@ -0,0 +1,3 @@
+import type { Session, SessionStats } from '../types.js';
+export declare const stats: (session: Session) => Promise<SessionStats>;
+export declare const projectStats: (sessions: Session[]) => Promise<SessionStats>;

package/lib/sessions/stats.js

@@ -0,0 +1,146 @@
+import { readFile } from 'node:fs/promises';
+import { countSubagents } from './count-subagents.js';
+const TOKENS_PER_MILLION = 1_000_000;
+const PRICING = {
+    opus: { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+    sonnet: { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+    haiku: { input: 0.8, output: 4, cacheWrite: 1.0, cacheRead: 0.08 },
+    unknown: { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+};
+const detectModel = (modelString) => {
+    if (modelString.includes('opus'))
+        return 'opus';
+    if (modelString.includes('haiku'))
+        return 'haiku';
+    if (modelString.includes('sonnet'))
+        return 'sonnet';
+    return 'unknown';
+};
+const computeCost = (tokens, model) => {
+    const pricing = PRICING[model];
+    return ((tokens.input * pricing.input +
+        tokens.output * pricing.output +
+        tokens.cacheCreation * pricing.cacheWrite +
+        tokens.cacheRead * pricing.cacheRead) /
+        TOKENS_PER_MILLION);
+};
+export const stats = async (session) => {
+    const raw = await readFile(session.file, 'utf-8');
+    const lines = raw.split('\n');
+    const tokens = {
+        input: 0,
+        output: 0,
+        cacheCreation: 0,
+        cacheRead: 0,
+    };
+    const perModel = new Map();
+    const tools = new Map();
+    let userCount = 0;
+    let assistantCount = 0;
+    let first = '';
+    let last = '';
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.timestamp) {
+                if (!first)
+                    first = parsed.timestamp;
+                last = parsed.timestamp;
+            }
+            if (parsed.type === 'user')
+                userCount++;
+            if (parsed.type === 'assistant')
+                assistantCount++;
+            if (parsed.type === 'assistant' && parsed.message?.usage) {
+                const usage = parsed.message.usage;
+                const model = detectModel(parsed.message.model ?? '');
+                const input = usage.input_tokens ?? 0;
+                const output = usage.output_tokens ?? 0;
+                const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+                const cacheRead = usage.cache_read_input_tokens ?? 0;
+                tokens.input += input;
+                tokens.output += output;
+                tokens.cacheCreation += cacheCreation;
+                tokens.cacheRead += cacheRead;
+                const existing = perModel.get(model) ?? {
+                    input: 0,
+                    output: 0,
+                    cacheCreation: 0,
+                    cacheRead: 0,
+                };
+                existing.input += input;
+                existing.output += output;
+                existing.cacheCreation += cacheCreation;
+                existing.cacheRead += cacheRead;
+                perModel.set(model, existing);
+            }
+            if (parsed.type === 'assistant' &&
+                Array.isArray(parsed.message?.content)) {
+                for (const block of parsed.message.content) {
+                    if (block.type !== 'tool_use')
+                        continue;
+                    const name = block.name ?? 'unknown';
+                    tools.set(name, (tools.get(name) ?? 0) + 1);
+                }
+            }
+        }
+        catch { }
+    }
+    const cost = new Map();
+    let totalCost = 0;
+    for (const [model, modelTokens] of perModel) {
+        const modelCost = computeCost(modelTokens, model);
+        cost.set(model, modelCost);
+        totalCost += modelCost;
+    }
+    const subagents = await countSubagents(session);
+    return {
+        tokens,
+        cost,
+        totalCost,
+        tools,
+        duration: { first, last },
+        messages: { user: userCount, assistant: assistantCount },
+        subagents,
+    };
+};
+export const projectStats = async (sessions) => {
+    const totals = {
+        tokens: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+        cost: new Map(),
+        totalCost: 0,
+        tools: new Map(),
+        duration: { first: '', last: '' },
+        messages: { user: 0, assistant: 0 },
+        subagents: 0,
+    };
+    for (const session of sessions) {
+        const result = await stats(session);
+        totals.tokens.input += result.tokens.input;
+        totals.tokens.output += result.tokens.output;
+        totals.tokens.cacheCreation += result.tokens.cacheCreation;
+        totals.tokens.cacheRead += result.tokens.cacheRead;
+        totals.messages.user += result.messages.user;
+        totals.messages.assistant += result.messages.assistant;
+        totals.subagents += result.subagents;
+        totals.totalCost += result.totalCost;
+        for (const [model, modelCost] of result.cost) {
+            totals.cost.set(model, (totals.cost.get(model) ?? 0) + modelCost);
+        }
+        for (const [tool, count] of result.tools) {
+            totals.tools.set(tool, (totals.tools.get(tool) ?? 0) + count);
+        }
+        if (result.duration.first) {
+            if (!totals.duration.first ||
+                result.duration.first < totals.duration.first)
+                totals.duration.first = result.duration.first;
+        }
+        if (result.duration.last) {
+            if (!totals.duration.last || result.duration.last > totals.duration.last)
+                totals.duration.last = result.duration.last;
+        }
+    }
+    return totals;
+};

package/lib/types.d.ts

@@ -0,0 +1,100 @@
+export type MessageContent = {
+    type: string;
+    text?: string;
+};
+export type Message = {
+    type: string;
+    message?: {
+        content: MessageContent[];
+    };
+};
+export type Session = {
+    id: string;
+    date: string;
+    message: string;
+    file: string;
+};
+export type Action = 'open' | 'fork' | 'merge' | 'prune' | 'trim' | 'rename' | 'delete' | 'stats' | 'back' | 'exit';
+export type StyledLabelOptions = {
+    label: string;
+    icon: string;
+    iconColor?: string;
+};
+export type SelectOption<T> = {
+    value: T;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+    separator?: boolean;
+    icon?: string;
+    iconColor?: string;
+    number?: number;
+};
+export type SelectConfig<T> = {
+    message: string;
+    options: SelectOption<T>[];
+    initialValue?: T;
+    numbered?: boolean;
+    shortcuts?: Map<string, number>;
+};
+export type ListResult = {
+    sessions: Session[];
+    empty: string[];
+};
+export type IndexEntry = {
+    sessionId: string;
+    firstPrompt: string;
+    [key: string]: unknown;
+};
+export type SessionIndex = {
+    version: number;
+    entries: IndexEntry[];
+    [key: string]: unknown;
+};
+export type RenameCache = Record<string, string>;
+export type ContentBlock = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export type UserLine = {
+    type: 'user';
+    message: {
+        content: ContentBlock[];
+    };
+    [key: string]: unknown;
+};
+export type ModelName = 'opus' | 'sonnet' | 'haiku' | 'unknown';
+export type TokenUsage = {
+    input: number;
+    output: number;
+    cacheCreation: number;
+    cacheRead: number;
+};
+export type SessionStats = {
+    tokens: TokenUsage;
+    cost: Map<ModelName, number>;
+    totalCost: number;
+    tools: Map<string, number>;
+    duration: {
+        first: string;
+        last: string;
+    };
+    messages: {
+        user: number;
+        assistant: number;
+    };
+    subagents: number;
+};
+export type PruneStats = {
+    toolBlocks: number;
+    shortMessages: number;
+    emptyMessages: number;
+    systemTags: number;
+};
+export type PruneOptions = {
+    toolBlocks: boolean;
+    shortMessages: boolean;
+    emptyMessages: boolean;
+    systemTags: boolean;
+};

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/ui/custom-select.d.ts

@@ -0,0 +1,2 @@
+import type { SelectConfig } from '../types.js';
+export declare const select: <T>(config: SelectConfig<T>) => Promise<T | symbol | undefined>;

package/lib/ui/custom-select.js

@@ -0,0 +1,113 @@
+import { SelectPrompt } from '@clack/core';
+import { limitOptions, S_BAR, S_BAR_END, S_RADIO_ACTIVE, S_RADIO_INACTIVE, symbol, } from '@clack/prompts';
+import { colorize, cyan, DEFAULT_ICON_COLOR, dim, gray, green, strikethrough, } from '../helpers/ansi.js';
+const style = (option, active) => {
+    if (option.separator)
+        return '';
+    const label = option.label;
+    if (option.disabled) {
+        const bullet = option.icon ?? S_RADIO_INACTIVE;
+        const hint = option.hint ? ` ${dim(`(${option.hint})`)}` : '';
+        return `${gray(bullet)} ${gray(label)}${hint}`;
+    }
+    const numStr = option.number !== undefined ? `[${option.number}] ` : '';
+    if (active) {
+        const bullet = option.icon ?? S_RADIO_ACTIVE;
+        const hint = option.hint ? ` ${dim(`(${option.hint})`)}` : '';
+        const styledBullet = option.icon
+            ? colorize(bullet, option.iconColor ?? DEFAULT_ICON_COLOR)
+            : green(bullet);
+        const numLabel = option.number !== undefined ? `${dim(`[${option.number}]`)} ` : '';
+        return `${styledBullet} ${numLabel}${label}${hint}`;
+    }
+    const bullet = option.icon ?? S_RADIO_INACTIVE;
+    const color = option.icon ? (option.iconColor ?? DEFAULT_ICON_COLOR) : null;
+    const styledBullet = color ? colorize(bullet, color) : dim(bullet);
+    return `${styledBullet} ${dim(`${numStr}${label}`)}`;
+};
+export const select = (config) => {
+    const numberMap = new Map();
+    if (config.numbered) {
+        let num = 1;
+        for (let index = 0; index < config.options.length; index++) {
+            const option = config.options[index];
+            if (!option || option.separator || option.disabled)
+                continue;
+            if (option.label === 'Exit') {
+                option.number = 0;
+                numberMap.set(0, index);
+            }
+            else {
+                option.number = num;
+                numberMap.set(num, index);
+                num++;
+            }
+        }
+    }
+    const prompt = new SelectPrompt({
+        options: config.options,
+        initialValue: config.initialValue,
+        render() {
+            const header = `${gray(S_BAR)}\n${symbol(this.state)}  ${config.message}\n`;
+            switch (this.state) {
+                case 'submit': {
+                    const selected = this.options[this.cursor];
+                    if (!selected)
+                        return header;
+                    return `${header}${gray(S_BAR)}  ${dim(selected.label)}`;
+                }
+                case 'cancel': {
+                    const selected = this.options[this.cursor];
+                    if (!selected)
+                        return header;
+                    return `${header}${gray(S_BAR)}  ${strikethrough(dim(selected.label))}\n${gray(S_BAR)}`;
+                }
+                default: {
+                    const prefix = `${cyan(S_BAR)}  `;
+                    const end = cyan(S_BAR_END);
+                    const headerLines = header.split('\n').length;
+                    const lines = limitOptions({
+                        cursor: this.cursor,
+                        options: this.options,
+                        maxItems: undefined,
+                        style,
+                        columnPadding: prefix.length,
+                        rowPadding: headerLines + 2,
+                    });
+                    return `${header}${prefix}${lines.join(`\n${prefix}`)}\n${end}\n`;
+                }
+            }
+        },
+    });
+    const hasNumbered = config.numbered && numberMap.size > 0;
+    const shortcuts = config.shortcuts;
+    const hasShortcuts = shortcuts && shortcuts.size > 0;
+    if (hasNumbered || hasShortcuts) {
+        let submitting = false;
+        prompt.on('key', (char) => {
+            if (submitting || char === undefined)
+                return;
+            let targetIndex;
+            if (hasNumbered) {
+                const digit = parseInt(char);
+                if (!isNaN(digit))
+                    targetIndex = numberMap.get(digit);
+            }
+            if (targetIndex === undefined && hasShortcuts) {
+                targetIndex = shortcuts.get(char);
+            }
+            if (targetIndex === undefined)
+                return;
+            const selected = config.options[targetIndex];
+            if (!selected)
+                return;
+            submitting = true;
+            prompt.cursor = targetIndex;
+            prompt.value = selected.value;
+            setImmediate(() => {
+                process.stdin.emit('keypress', '\r', { name: 'return' });
+            });
+        });
+    }
+    return prompt.prompt();
+};

package/lib/ui/select.d.ts

@@ -0,0 +1,10 @@
+import type { Action, PruneStats, Session } from '../types.js';
+export declare const selectMain: (project: string, base: string, emptyCount?: number) => Promise<"sessions" | "stats" | "clean" | null>;
+export declare const select: (sessions: Session[], project: string, base: string) => Promise<Session | "exit" | null>;
+export declare const selectAction: (session: Session, project: string, base: string, previewLines: string[], subagentCount: number) => Promise<Action | null>;
+export declare const selectMultiple: (sessions: Session[], project: string, base: string) => Promise<Session[] | null>;
+export declare const promptTitle: (fields?: Record<string, string>) => Promise<string | null>;
+export declare const promptConfirm: (message: string) => Promise<boolean | null>;
+export declare const selectPruneOptions: (stats: PruneStats, fields?: Record<string, string>) => Promise<Set<keyof PruneStats> | "exit" | null>;
+export declare const selectTrimLine: (messages: [number, string][], fields?: Record<string, string>) => Promise<number | null>;
+export declare const showProjectStats: (lines: string[], fields: Record<string, string>) => Promise<void>;