claude-session-fork 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,158 @@
+# claude-session-fork
+
+[中文文档](./README_CN.md)
+
+Fork Claude Code sessions at any conversation point and continue in a new terminal.
+
+## Features
+
+- 🔀 **Fork at any point** - Select any message to create a branch from
+- 📜 **Session browser** - Browse all sessions with preview
+- 📝 **Visual history** - Browse conversation with code change indicators (◆)
+- 🖥️ **Multi-terminal** - Supports Terminal.app, iTerm2, VS Code, Cursor, Kiro
+- ⚡ **Auto-detect** - Automatically uses current session in Claude Code
+
+## Installation
+
+### npm (Recommended)
+
+```bash
+npm install -g claude-session-fork
+```
+
+### Homebrew (macOS)
+
+```bash
+brew tap duo121/claude-session-fork
+brew install claude-session-fork
+```
+
+### From source
+
+```bash
+git clone https://github.com/duo121/claude-session-fork.git
+cd claude-session-fork
+npm install && npm run build && npm link
+```
+
+## Uninstall
+
+### npm
+
+```bash
+npm uninstall -g claude-session-fork
+```
+
+### Homebrew
+
+```bash
+brew uninstall claude-session-fork
+brew untap duo121/claude-session-fork
+```
+
+### From source
+
+```bash
+npm unlink -g claude-session-fork
+```
+
+## Usage
+
+```bash
+# Fork current session (auto-detect in Claude Code)
+sfork
+
+# Show session list to choose from
+sfork --list
+sfork -l
+
+# Fork specific session
+sfork --session=<session-id>
+
+# Specify terminal
+sfork --terminal=iterm
+sfork --terminal=vscode
+```
+
+**Commands:** `sfork`, `csfork`, `claude-session-fork`
+
+## Workflow
+
+```
+┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+│  Session List   │ ──► │  Message List   │ ──► │  New Terminal   │
+│  (--list mode)  │     │  (select fork   │     │  (forked        │
+│                 │     │   point)        │     │   session)      │
+└─────────────────┘     └─────────────────┘     └─────────────────┘
+        │                       │
+        │ Esc                   │ Esc
+        ▼                       ▼
+      Exit                Back to Sessions
+```
+
+## Controls
+
+### Session List (--list mode)
+| Key | Action |
+|-----|--------|
+| `↑↓` | Navigate sessions |
+| `Enter` | Select session |
+| `Esc` | Exit |
+
+### Message List
+| Key | Action |
+|-----|--------|
+| `↑↓` | Navigate messages |
+| `+/-` | Expand/collapse preview (1-10 lines) |
+| `Space` | Toggle user-only filter |
+| `Enter` | Fork at selected point |
+| `Esc` | Back (list mode) / Exit |
+
+## Command Line Options
+
+```bash
+sfork                      # Fork current session
+sfork --list, -l           # Show session list
+sfork --session=<id>       # Fork specific session
+sfork --cwd=<path>         # Specify working directory
+sfork --terminal=<type>    # Terminal: auto, iterm, terminal, vscode, cursor, kiro
+sfork --help, -h           # Show help
+sfork --version, -v        # Show version
+```
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Original Session                          │
+├─────────────────────────────────────────────────────────────┤
+│  [0] You: "Help me build a REST API"                        │
+│  [1] Claude: "I'll help you create a REST API..."           │
+│  [2] You: "Add authentication"         ◄── Fork Point       │
+│  [3] Claude: "Let's add JWT authentication..."              │
+└─────────────────────────────────────────────────────────────┘
+                           │
+                           ▼ sfork (select message 2)
+                           │
+        ┌──────────────────┴──────────────────┐
+        ▼                                      ▼
+┌───────────────────┐                ┌───────────────────┐
+│  Original Window  │                │   New Terminal    │
+│  (continues)      │                │  (forked from     │
+│                   │                │   message 2)      │
+└───────────────────┘                └───────────────────┘
+```
+
+## Requirements
+
+- macOS (uses AppleScript for terminal control)
+- Claude Code CLI
+- Node.js 18+
+
+## Documentation
+
+https://claude-session-fork.vercel.app
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { render, Box, Text, useApp } from 'ink';
+import { findAllSessions, parseSession, forkSession, launchClaudeSession, openTerminalWithUI, getProjectDir } from './session.js';
+import { SessionList, MessageList } from './components.js';
+// Parse CLI arguments
+const args = process.argv.slice(2);
+const isInteractive = args.includes('--interactive');
+const sessionArg = args.find(a => a.startsWith('--session='));
+const cwdArg = args.find(a => a.startsWith('--cwd='));
+const terminalArg = args.find(a => a.startsWith('--terminal='));
+const showHelp = args.includes('--help') || args.includes('-h');
+const showVersion = args.includes('--version') || args.includes('-v');
+const showList = args.includes('--list') || args.includes('-l');
+const cwd = cwdArg ? cwdArg.split('=')[1] : process.cwd();
+const sessionId = sessionArg ? sessionArg.split('=')[1] : null;
+const terminalType = terminalArg ? terminalArg.split('=')[1] : process.env.TERM_PROGRAM;
+// Show help
+if (showHelp) {
+    console.log(`
+claude-session-fork (csfork/sfork) - Fork Claude Code sessions
+
+Usage:
+  csfork                    Fork current session (latest modified)
+  csfork --list             Open session list to choose
+  csfork --session=<id>     Fork specific session
+
+Options:
+  --session=<id>    Specify session ID
+  --list, -l        Show session list to choose from
+  --cwd=<path>      Working directory (default: current)
+  --terminal=<type> Terminal type: auto, iterm, terminal, vscode, cursor, kiro
+  -h, --help        Show this help
+  -v, --version     Show version
+
+Controls:
+  ↑↓        Navigate
+  Enter     Select / Fork
+  +/-       Expand/collapse message preview
+  Space     Toggle user-only filter
+  Esc       Back / Exit
+
+Docs: https://claude-session-fork.vercel.app
+`);
+    process.exit(0);
+}
+// Show version
+if (showVersion) {
+    console.log('1.0.0');
+    process.exit(0);
+}
+// Non-interactive mode: open UI in new terminal
+if (!isInteractive) {
+    const sessions = findAllSessions(cwd);
+    if (sessions.length === 0) {
+        console.error('No sessions found for:', cwd);
+        process.exit(1);
+    }
+    console.log(`Found ${sessions.length} session(s)`);
+    // --session=<id>: use specific session
+    // --list or -l: show session list
+    // default: use latest session (current session in Claude Code)
+    let targetSession;
+    if (sessionId) {
+        targetSession = sessionId;
+        console.log(`Using session: ${sessionId}`);
+    }
+    else if (showList) {
+        targetSession = '__list__';
+        console.log(`Opening session list...`);
+    }
+    else {
+        // Latest session = current session (most recently modified)
+        targetSession = sessions[0].id;
+        console.log(`Using current session: ${targetSession.slice(0, 8)}...`);
+    }
+    console.log(`Opening fork UI...`);
+    openTerminalWithUI(cwd, targetSession, terminalType);
+    process.exit(0);
+}
+function App() {
+    const { exit } = useApp();
+    const [step, setStep] = useState(sessionId && sessionId !== '__list__' ? 'messages' : 'sessions');
+    const [sessions, setSessions] = useState([]);
+    const [selectedSession, setSelectedSession] = useState(null);
+    const [messages, setMessages] = useState([]);
+    const [error, setError] = useState('');
+    useEffect(() => {
+        // Clear screen
+        process.stdout.write('\x1Bc');
+        const allSessions = findAllSessions(cwd);
+        setSessions(allSessions);
+        // If session ID provided, go directly to messages
+        if (sessionId && sessionId !== '__list__') {
+            const projectDir = getProjectDir(cwd);
+            const file = `${projectDir}/${sessionId}.jsonl`;
+            try {
+                const msgs = parseSession(file);
+                if (msgs.length === 0) {
+                    setError('No messages found in session');
+                    setStep('error');
+                    return;
+                }
+                setSelectedSession({ id: sessionId, file, mtime: new Date() });
+                setMessages(msgs);
+                setStep('messages');
+            }
+            catch (e) {
+                setError(`Failed to parse session: ${e}`);
+                setStep('error');
+            }
+        }
+        else if (allSessions.length === 0) {
+            setError('No sessions found for this directory');
+            setStep('error');
+        }
+    }, []);
+    const handleSessionSelect = (session) => {
+        try {
+            const msgs = parseSession(session.file);
+            if (msgs.length === 0) {
+                setError('No messages found in session');
+                setStep('error');
+                return;
+            }
+            setSelectedSession(session);
+            setMessages(msgs);
+            setStep('messages');
+        }
+        catch (e) {
+            setError(`Failed to parse session: ${e}`);
+            setStep('error');
+        }
+    };
+    const handleMessageSelect = (uuid) => {
+        if (!selectedSession)
+            return;
+        setStep('forking');
+        setTimeout(() => {
+            try {
+                process.stdout.write('\x1Bc');
+                const newId = forkSession(selectedSession.file, uuid);
+                launchClaudeSession(newId, cwd, terminalType);
+                setStep('done');
+                setTimeout(() => {
+                    exit();
+                    process.exit(0);
+                }, 100);
+            }
+            catch (e) {
+                setError(`Failed to fork: ${e}`);
+                setStep('error');
+            }
+        }, 100);
+    };
+    const handleBack = () => {
+        // Only allow back if we started from session list
+        if (!sessionId || sessionId === '__list__') {
+            setStep('sessions');
+            setSelectedSession(null);
+            setMessages([]);
+        }
+    };
+    const handleExit = () => {
+        process.stdout.write('\x1Bc');
+        exit();
+        process.exit(0);
+    };
+    if (step === 'error') {
+        return (_jsxs(Box, { paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Text, { dimColor: true, children: "Press Esc to exit" })] }));
+    }
+    if (step === 'forking') {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "yellow", children: "Creating fork..." }) }));
+    }
+    if (step === 'done') {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "green", children: "\u2713 Fork created, launching Claude..." }) }));
+    }
+    if (step === 'sessions') {
+        return (_jsx(SessionList, { sessions: sessions, onSelect: handleSessionSelect, onExit: handleExit }));
+    }
+    if (step === 'messages') {
+        // Allow back only if we came from session list
+        const canGoBack = !sessionId || sessionId === '__list__';
+        return (_jsx(MessageList, { messages: messages, onSelect: handleMessageSelect, onBack: canGoBack ? handleBack : undefined, onExit: handleExit }));
+    }
+    return null;
+}
+render(_jsx(App, {}));

package/dist/components.d.ts

@@ -0,0 +1,15 @@
+import type { Message, Session } from './session.js';
+interface SessionListProps {
+    sessions: Session[];
+    onSelect: (session: Session) => void;
+    onExit: () => void;
+}
+export declare function SessionList({ sessions, onSelect, onExit }: SessionListProps): import("react/jsx-runtime").JSX.Element;
+interface MessageListProps {
+    messages: Message[];
+    onSelect: (uuid: string) => void;
+    onBack?: () => void;
+    onExit: () => void;
+}
+export declare function MessageList({ messages: allMessages, onSelect, onBack, onExit }: MessageListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+export function SessionList({ sessions, onSelect, onExit }) {
+    const { stdout } = useStdout();
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const terminalHeight = stdout?.rows || 24;
+    const maxVisible = Math.max(3, terminalHeight - 8);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(i => Math.max(0, i - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex(i => Math.min(sessions.length - 1, i + 1));
+        }
+        if (key.return && sessions.length > 0) {
+            onSelect(sessions[selectedIndex]);
+        }
+    });
+    if (sessions.length === 0) {
+        return (_jsxs(Box, { paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "red", children: "No sessions found for this directory" }), _jsx(Text, { dimColor: true, children: "Press Esc to exit" })] }));
+    }
+    // Calculate visible window
+    let startIdx = 0;
+    let endIdx = sessions.length;
+    if (sessions.length > maxVisible) {
+        const halfWindow = Math.floor(maxVisible / 2);
+        startIdx = Math.max(0, selectedIndex - halfWindow);
+        endIdx = Math.min(sessions.length, startIdx + maxVisible);
+        if (endIdx === sessions.length) {
+            startIdx = Math.max(0, sessions.length - maxVisible);
+        }
+    }
+    const visibleSessions = sessions.slice(startIdx, endIdx);
+    const formatTime = (date) => {
+        const now = new Date();
+        const diff = now.getTime() - date.getTime();
+        const minutes = Math.floor(diff / 60000);
+        const hours = Math.floor(diff / 3600000);
+        const days = Math.floor(diff / 86400000);
+        if (minutes < 1)
+            return 'just now';
+        if (minutes < 60)
+            return `${minutes}m ago`;
+        if (hours < 24)
+            return `${hours}h ago`;
+        if (days < 7)
+            return `${days}d ago`;
+        return date.toLocaleDateString();
+    };
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { marginBottom: 0, children: [_jsx(Text, { bold: true, color: "blue", children: "Sessions" }), _jsxs(Text, { dimColor: true, children: [" (", selectedIndex + 1, "/", sessions.length, ")"] })] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select a session to fork from" }) }), startIdx > 0 && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["  \u2191 ", startIdx, " more above"] }) })), visibleSessions.map((session, visibleIdx) => {
+                const actualIndex = startIdx + visibleIdx;
+                const isSelected = actualIndex === selectedIndex;
+                const isCurrent = actualIndex === 0;
+                const preview = session.firstMessage || `Session ${session.id.slice(0, 8)}...`;
+                const time = formatTime(session.mtime);
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: isSelected ? '❯ ' : '  ' }), _jsxs(Text, { color: isSelected ? 'white' : 'gray', bold: isSelected, children: [preview.slice(0, 60), preview.length > 60 ? '...' : ''] }), isCurrent && _jsx(Text, { color: "yellow", italic: true, children: " (latest)" })] }), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["  ", time, " \u00B7 ", session.id.slice(0, 8)] }) })] }, session.id));
+            }), endIdx < sessions.length && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["  \u2193 ", sessions.length - endIdx, " more below"] }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 Move \u00B7 Enter Select \u00B7 Esc Exit" }) })] }));
+}
+export function MessageList({ messages: allMessages, onSelect, onBack, onExit }) {
+    const { stdout } = useStdout();
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [expandLines, setExpandLines] = useState(1);
+    const [showOnlyUser, setShowOnlyUser] = useState(false);
+    // Filter messages based on mode
+    const messages = showOnlyUser
+        ? allMessages.filter(m => m.type === 'user')
+        : allMessages;
+    // Reset selection when filter changes
+    useEffect(() => {
+        setSelectedIndex(Math.min(selectedIndex, Math.max(0, messages.length - 1)));
+    }, [showOnlyUser, messages.length]);
+    // Calculate layout
+    const terminalHeight = stdout?.rows || 24;
+    const layoutLines = 5;
+    const reservedForExpand = 5;
+    const availableLines = terminalHeight - layoutLines - reservedForExpand;
+    const maxVisible = Math.max(3, availableLines);
+    useInput((input, key) => {
+        if (key.escape) {
+            if (onBack) {
+                onBack();
+            }
+            else {
+                onExit();
+            }
+            return;
+        }
+        // Space: toggle user-only filter
+        if (input === ' ') {
+            setShowOnlyUser(v => !v);
+            return;
+        }
+        // +/= : increase expand lines
+        if (input === '=' || input === '+') {
+            setExpandLines(n => Math.min(n + 1, 10));
+            return;
+        }
+        // - : decrease expand lines
+        if (input === '-') {
+            setExpandLines(n => Math.max(n - 1, 1));
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(i => Math.max(0, i - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex(i => Math.min(messages.length - 1, i + 1));
+        }
+        if (key.return && messages.length > 0) {
+            onSelect(messages[selectedIndex].uuid);
+        }
+    });
+    if (messages.length === 0) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "red", children: "No messages to display" }) }));
+    }
+    // Calculate visible window
+    const totalMessages = messages.length;
+    let startIdx = 0;
+    let endIdx = totalMessages;
+    if (totalMessages > maxVisible) {
+        const halfWindow = Math.floor(maxVisible / 2);
+        startIdx = Math.max(0, selectedIndex - halfWindow);
+        endIdx = Math.min(totalMessages, startIdx + maxVisible);
+        if (endIdx === totalMessages) {
+            startIdx = Math.max(0, totalMessages - maxVisible);
+        }
+    }
+    const visibleMessages = messages.slice(startIdx, endIdx);
+    // Helper to get content lines
+    const getContentLines = (content, maxLen, numLines) => {
+        const lines = [];
+        let remaining = content;
+        for (let i = 0; i < numLines && remaining.length > 0; i++) {
+            lines.push(remaining.slice(0, maxLen));
+            remaining = remaining.slice(maxLen);
+        }
+        if (remaining.length > 0 && lines.length > 0) {
+            lines[lines.length - 1] = lines[lines.length - 1].slice(0, -3) + '...';
+        }
+        return lines;
+    };
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { marginBottom: 0, children: [_jsx(Text, { bold: true, color: "blue", children: "Fork" }), _jsxs(Text, { dimColor: true, children: [" (", selectedIndex + 1, "/", totalMessages, ")"] }), _jsxs(Text, { color: "cyan", children: [" [", expandLines, "\u884C]"] }), showOnlyUser && _jsx(Text, { color: "yellow", children: " [User Only]" })] }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["Select the point to fork from", onBack ? ' · Esc to go back' : ''] }) }), startIdx > 0 && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["  \u2191 ", startIdx, " more above"] }) })), visibleMessages.flatMap((msg, visibleIdx) => {
+                const actualIndex = startIdx + visibleIdx;
+                const isSelected = actualIndex === selectedIndex;
+                const isCurrent = actualIndex === messages.length - 1;
+                const isUser = msg.type === 'user';
+                const maxLen = 65;
+                const numLines = isSelected ? expandLines : 1;
+                const contentLines = getContentLines(msg.content, maxLen, numLines);
+                return contentLines.map((line, lineIdx) => {
+                    const isFirstLine = lineIdx === 0;
+                    return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: isFirstLine ? (isSelected ? '❯ ' : '  ') : '    ' }), isFirstLine ? (_jsx(Text, { color: isUser ? 'green' : 'magenta', bold: true, inverse: isSelected, children: isUser ? ' You ' : ' AI ' })) : (_jsx(Text, { children: "      " })), _jsx(Text, { children: " " }), isFirstLine ? (_jsx(Text, { color: msg.hasCodeChanges ? 'yellow' : 'gray', children: msg.hasCodeChanges ? '◆ ' : '  ' })) : (_jsx(Text, { children: "  " })), _jsx(Text, { color: isSelected ? 'white' : 'gray', bold: isSelected && isFirstLine, children: line }), isFirstLine && isCurrent && (_jsx(Text, { color: "yellow", italic: true, children: " (current)" }))] }, `${actualIndex}-${lineIdx}`));
+                });
+            }), endIdx < totalMessages && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["  \u2193 ", totalMessages - endIdx, " more below"] }) })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["\u2191\u2193 Move \u00B7 +/- Lines \u00B7 Space Filter \u00B7 Enter Fork \u00B7 Esc ", onBack ? 'Back' : 'Exit'] }) })] }));
+}

package/dist/session.d.ts

@@ -0,0 +1,19 @@
+export interface Message {
+    uuid: string;
+    type: 'user' | 'assistant';
+    content: string;
+    hasCodeChanges: boolean;
+}
+export interface Session {
+    id: string;
+    file: string;
+    mtime: Date;
+    firstMessage?: string;
+}
+export declare function getProjectDir(dir?: string): string;
+export declare function findLatestSession(dir?: string): Session | null;
+export declare function findAllSessions(dir?: string): Session[];
+export declare function parseSession(sessionFile: string): Message[];
+export declare function forkSession(sessionFile: string, forkUuid: string): string;
+export declare function launchClaudeSession(sessionId: string, cwd: string, terminal?: string): void;
+export declare function openTerminalWithUI(cwd: string, sessionId: string, terminal?: string): void;

package/dist/session.js

@@ -0,0 +1,238 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { spawn, execSync } from 'child_process';
+// Patterns to filter out system messages
+const filterPatterns = [
+    /^Caveat:/,
+    /^<bash-input>/,
+    /^<bash-stdout>/,
+    /^<bash-stderr>/,
+    /^<system-reminder>/,
+    /^\[Request interrupted/,
+    /^ERROR\s/,
+    /^!\s*sfork/,
+    /^Last login:/,
+];
+function getProjectHash(dir) {
+    return dir.replace(/^\//g, '-').replace(/\//g, '-');
+}
+export function getProjectDir(dir = process.cwd()) {
+    const projectHash = getProjectHash(dir);
+    return path.join(os.homedir(), '.claude', 'projects', projectHash);
+}
+export function findLatestSession(dir = process.cwd()) {
+    const sessions = findAllSessions(dir);
+    return sessions[0] || null;
+}
+export function findAllSessions(dir = process.cwd()) {
+    const projectDir = getProjectDir(dir);
+    if (!fs.existsSync(projectDir)) {
+        return [];
+    }
+    return fs.readdirSync(projectDir)
+        .filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'))
+        .map(f => {
+        const filePath = path.join(projectDir, f);
+        const id = f.replace('.jsonl', '');
+        const stat = fs.statSync(filePath);
+        // Get first user message as preview
+        let firstMessage = '';
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            for (const line of content.split('\n')) {
+                if (!line)
+                    continue;
+                try {
+                    const data = JSON.parse(line);
+                    if (data.type === 'user' && data.message) {
+                        const msg = typeof data.message.content === 'string'
+                            ? data.message.content
+                            : data.message.content?.filter?.((c) => c.type === 'text')?.map?.((c) => c.text)?.join(' ') || '';
+                        const cleaned = msg.replace(/^[\s\n\r]+/, '').replace(/\s+/g, ' ').trim();
+                        if (cleaned && cleaned !== '[Request interrupted by user]') {
+                            firstMessage = cleaned.slice(0, 60);
+                            break;
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+        return {
+            id,
+            file: filePath,
+            mtime: stat.mtime,
+            firstMessage
+        };
+    })
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+}
+export function parseSession(sessionFile) {
+    const messagesMap = new Map();
+    const codeChangesByUuid = new Set();
+    const content = fs.readFileSync(sessionFile, 'utf-8');
+    for (const line of content.split('\n')) {
+        if (!line)
+            continue;
+        try {
+            const data = JSON.parse(line);
+            // Track tool uses for code changes
+            if (data.type === 'assistant' && data.message?.content) {
+                const hasToolUse = Array.isArray(data.message.content) &&
+                    data.message.content.some((c) => c.type === 'tool_use' &&
+                        ['Edit', 'Write', 'Bash', 'MultiEdit'].includes(c.name));
+                if (hasToolUse && data.uuid) {
+                    codeChangesByUuid.add(data.uuid);
+                }
+            }
+            if ((data.type === 'user' || data.type === 'assistant') && data.uuid) {
+                let msg = '';
+                if (data.message) {
+                    msg = typeof data.message.content === 'string'
+                        ? data.message.content
+                        : data.message.content?.filter?.((c) => c.type === 'text')?.map?.((c) => c.text)?.join(' ') || '';
+                }
+                // Clean up message
+                msg = msg.replace(/^[\s\n\r]+/, '').replace(/\s+/g, ' ').trim();
+                // Filter out system messages
+                const shouldFilter = filterPatterns.some(pattern => pattern.test(msg));
+                if (msg && !shouldFilter && msg !== '[Request interrupted by user]' && msg !== 'No response requested.') {
+                    if (!messagesMap.has(data.uuid)) {
+                        messagesMap.set(data.uuid, {
+                            uuid: data.uuid,
+                            type: data.type,
+                            content: msg,
+                            hasCodeChanges: false
+                        });
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    // Mark code changes
+    for (const uuid of codeChangesByUuid) {
+        const msg = messagesMap.get(uuid);
+        if (msg) {
+            msg.hasCodeChanges = true;
+        }
+    }
+    return Array.from(messagesMap.values());
+}
+export function forkSession(sessionFile, forkUuid) {
+    const projectDir = path.dirname(sessionFile);
+    const newId = crypto.randomUUID();
+    const newFile = path.join(projectDir, `${newId}.jsonl`);
+    const content = fs.readFileSync(sessionFile, 'utf-8');
+    const lines = content.split('\n').filter(Boolean);
+    const newLines = [];
+    for (const line of lines) {
+        try {
+            const data = JSON.parse(line);
+            if (data.sessionId)
+                data.sessionId = newId;
+            newLines.push(JSON.stringify(data));
+            if (data.uuid === forkUuid)
+                break;
+        }
+        catch {
+            newLines.push(line);
+        }
+    }
+    fs.writeFileSync(newFile, newLines.join('\n') + '\n');
+    return newId;
+}
+export function launchClaudeSession(sessionId, cwd, terminal) {
+    const cmd = `cd '${cwd}' && claude --resume '${sessionId}'`;
+    const terminalLower = terminal?.toLowerCase() || '';
+    // VS Code / Cursor / Kiro - use code CLI to open terminal
+    if (terminalLower.includes('vscode') || terminalLower === 'code') {
+        execSync(`code --folder-uri "file://${cwd}" -r`);
+        // VS Code doesn't have a direct way to run command in terminal via CLI
+        // Copy command to clipboard and notify user
+        execSync(`echo "${cmd}" | pbcopy`);
+        console.log('Command copied to clipboard. Paste in VS Code terminal.');
+        return;
+    }
+    if (terminalLower.includes('cursor')) {
+        execSync(`cursor --folder-uri "file://${cwd}" -r`);
+        execSync(`echo "${cmd}" | pbcopy`);
+        console.log('Command copied to clipboard. Paste in Cursor terminal.');
+        return;
+    }
+    if (terminalLower.includes('kiro')) {
+        execSync(`kiro "${cwd}"`);
+        execSync(`echo "${cmd}" | pbcopy`);
+        console.log('Command copied to clipboard. Paste in Kiro terminal.');
+        return;
+    }
+    // iTerm2
+    const isIterm = terminalLower === 'iterm' || terminalLower === 'iterm.app' ||
+        (terminalLower !== 'terminal' && terminalLower !== 'terminal.app' && fs.existsSync('/Applications/iTerm.app'));
+    if (isIterm) {
+        const script = `
+      tell application "iTerm"
+        activate
+        create window with default profile
+        tell current session of current window
+          write text "${cmd}"
+        end tell
+      end tell
+    `;
+        execSync(`osascript -e '${script}'`);
+    }
+    else {
+        // Terminal.app
+        const script = `
+      tell application "Terminal"
+        activate
+        do script "${cmd}"
+      end tell
+    `;
+        execSync(`osascript -e '${script}'`);
+    }
+}
+export function openTerminalWithUI(cwd, sessionId, terminal) {
+    const sforkPath = process.argv[1];
+    const cmd = `node '${sforkPath}' --interactive --session='${sessionId}' --cwd='${cwd}'`;
+    const fullCmd = `cd '${cwd}' && ${cmd}`;
+    const terminalLower = terminal?.toLowerCase() || '';
+    // VS Code / Cursor / Kiro - copy command to clipboard
+    if (terminalLower.includes('vscode') || terminalLower === 'code' ||
+        terminalLower.includes('cursor') || terminalLower.includes('kiro')) {
+        execSync(`echo "${fullCmd}" | pbcopy`);
+        console.log('Command copied to clipboard. Open a terminal and paste to run.');
+        return;
+    }
+    // iTerm2
+    const isIterm = terminalLower === 'iterm' || terminalLower === 'iterm.app' ||
+        (terminalLower !== 'terminal' && terminalLower !== 'terminal.app' && fs.existsSync('/Applications/iTerm.app'));
+    if (isIterm) {
+        const script = `
+      tell application "iTerm"
+        activate
+        tell current window
+          create tab with default profile
+          tell current session
+            write text "${fullCmd}"
+          end tell
+        end tell
+      end tell
+    `;
+        spawn('osascript', ['-e', script], { detached: true, stdio: 'ignore' }).unref();
+    }
+    else {
+        // Terminal.app
+        const script = `
+      tell application "Terminal"
+        activate
+        tell application "System Events" to keystroke "t" using command down
+        delay 0.3
+        do script "${fullCmd}" in front window
+      end tell
+    `;
+        spawn('osascript', ['-e', script], { detached: true, stdio: 'ignore' }).unref();
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "claude-session-fork",
+  "version": "1.0.0",
+  "description": "Fork Claude Code sessions at any conversation point",
+  "type": "module",
+  "bin": {
+    "claude-session-fork": "./dist/cli.js",
+    "csfork": "./dist/cli.js",
+    "sfork": "./dist/cli.js"
+  },
+  "scripts": {
+    "start": "node dist/cli.js",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js || true"
+  },
+  "files": [
+    "dist",
+    "scripts/postinstall.js"
+  ],
+  "dependencies": {
+    "ink": "^5.0.1",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.10",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "fork",
+    "session",
+    "cli",
+    "ai",
+    "conversation"
+  ],
+  "author": "duo121",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/duo121/claude-session-fork.git"
+  },
+  "homepage": "https://claude-session-fork.vercel.app",
+  "bugs": {
+    "url": "https://github.com/duo121/claude-session-fork/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+// Post-install message
+console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   claude-session-fork installed! 🎉                       ║
+║                                                           ║
+║   Usage:                                                  ║
+║     cd your-project                                       ║
+║     csfork                                                ║
+║                                                           ║
+║   Commands: csfork, sfork, claude-session-fork            ║
+║   Docs: https://claude-session-fork.vercel.app            ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`);