Extracting Session Data

#!/bin/bash
# extract-data.sh - Extract structured data from Claude Code session logs
# Usage: ./extract-data.sh --type TYPE [--session SESSION_ID] [options]
#
# Extracts specific data types from one or more session log files

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Check dependencies
if ! command -v jq &> /dev/null; then
    echo "Error: jq is required but not installed. Install with: brew install jq" >&2
    exit 1
fi

# Default options
EXTRACT_TYPE=""
SESSION_ID=""
PROJECT_DIR="${PWD}"
OUTPUT_FORMAT="text"
LIMIT=""

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --type)
            EXTRACT_TYPE="$2"
            shift 2
            ;;
        --session)
            SESSION_ID="$2"
            shift 2
            ;;
        --project)
            PROJECT_DIR="$2"
            shift 2
            ;;
        --format)
            OUTPUT_FORMAT="$2"
            shift 2
            ;;
        --limit)
            LIMIT="$2"
            shift 2
            ;;
        --help)
            echo "Usage: $0 --type TYPE [options]"
            echo ""
            echo "Required:"
            echo "  --type TYPE           Data to extract: metadata, user-prompts, tool-usage,"
            echo "                        errors, thinking, text-responses, statistics, all"
            echo ""
            echo "Options:"
            echo "  --session ID          Extract from specific session (default: all sessions)"
            echo "  --project DIR         Project directory (default: current directory)"
            echo "  --format FORMAT       Output format: text (default), json, csv"
            echo "  --limit N             Limit output to first N items"
            echo "  --help                Show this help message"
            echo ""
            echo "Examples:"
            echo "  $0 --type statistics                    # Stats for all sessions"
            echo "  $0 --type errors --session abc123       # Errors from specific session"
            echo "  $0 --type tool-usage --format json      # Tool usage in JSON format"
            exit 0
            ;;
        *)
            echo "Error: Unknown argument: $1" >&2
            exit 1
            ;;
    esac
done

# Validate required arguments
if [ -z "${EXTRACT_TYPE}" ]; then
    echo "Error: --type is required" >&2
    echo "Run '$0 --help' for usage information" >&2
    exit 1
fi

# Get session files
if [ -n "${SESSION_ID}" ]; then
    # Single session
    SESSION_FILE=$("${SCRIPT_DIR}/locate-logs.sh" "${PROJECT_DIR}" "${SESSION_ID}")
    if [ ! -f "${SESSION_FILE}" ]; then
        echo "Error: Session file not found: ${SESSION_FILE}" >&2
        exit 1
    fi
    SESSION_FILES=("${SESSION_FILE}")
else
    # All sessions
    LOGS_DIR=$("${SCRIPT_DIR}/locate-logs.sh" "${PROJECT_DIR}")
    if [ ! -d "${LOGS_DIR}" ]; then
        echo "Error: Logs directory not found: ${LOGS_DIR}" >&2
        exit 1
    fi

    SESSION_FILES=()
    while IFS= read -r file; do
        SESSION_FILES+=("$file")
    done < <(find "${LOGS_DIR}" -maxdepth 1 -name "*.jsonl" -type f)

    if [ ${#SESSION_FILES[@]} -eq 0 ]; then
        echo "Error: No session files found in: ${LOGS_DIR}" >&2
        exit 1
    fi
fi

# Apply limit if specified
apply_limit() {
    if [ -n "${LIMIT}" ]; then
        head -n "${LIMIT}"
    else
        cat
    fi
}

# Extract metadata
extract_metadata() {
    local file="$1"
    local session_id=$(basename "${file}" .jsonl)

    local first_line=$(head -1 "${file}")
    local last_line=$(tail -1 "${file}")

    echo "Session ID: ${session_id}"
    echo "First Timestamp: $(echo "${first_line}" | jq -r '.timestamp // "unknown"')"
    echo "Last Timestamp: $(echo "${last_line}" | jq -r '.timestamp // "unknown"')"
    echo "Git Branch: $(echo "${first_line}" | jq -r '.gitBranch // "unknown"')"
    echo "Working Directory: $(echo "${first_line}" | jq -r '.cwd // "unknown"')"
    echo "Total Lines: $(wc -l < "${file}" | tr -d ' ')"
    echo ""
}

# Extract user prompts
extract_user_prompts() {
    local file="$1"
    grep '"type":"user"' "${file}" | jq -r '.message.content' | apply_limit
}

# Extract tool usage statistics
extract_tool_usage() {
    local file="$1"
    grep '"type":"assistant"' "${file}" | \
        jq -r '.message.content[]? | select(.type=="tool_use") | .name' | \
        sort | uniq -c | sort -rn | \
        awk '{printf "%-30s %d\n", $2, $1}' | \
        apply_limit
}

# Extract errors
extract_errors() {
    local file="$1"
    grep '"is_error":true' "${file}" | \
        jq -r '[.timestamp, .message.content[]? | select(.is_error==true) | .content] | @tsv' | \
        apply_limit
}

# Extract thinking blocks
extract_thinking() {
    local file="$1"
    grep '"type":"assistant"' "${file}" | \
        jq -r '.message.content[]? | select(.type=="thinking") | .thinking' | \
        apply_limit
}

# Extract text responses
extract_text_responses() {
    local file="$1"
    grep '"type":"assistant"' "${file}" | \
        jq -r '.message.content[]? | select(.type=="text") | .text' | \
        apply_limit
}

# Extract statistics
extract_statistics() {
    local file="$1"
    local session_id=$(basename "${file}" .jsonl)
    local total_lines=$(wc -l < "${file}" | tr -d ' ')
    local user_msgs=$(grep -c '"type":"user"' "${file}" 2>/dev/null || echo "0")
    local assistant_msgs=$(grep -c '"type":"assistant"' "${file}" 2>/dev/null || echo "0")
    local tool_calls=$(grep '"type":"assistant"' "${file}" | jq -r '.message.content[]? | select(.type=="tool_use") | .name' 2>/dev/null | wc -l | tr -d ' ')
    local errors=$(grep -c '"is_error":true' "${file}" 2>/dev/null || echo "0")
    local thinking_blocks=$(grep '"type":"assistant"' "${file}" | jq -r '.message.content[]? | select(.type=="thinking")' 2>/dev/null | wc -l | tr -d ' ')

    echo "Session: ${session_id}"
    echo "  Total Lines: ${total_lines}"
    echo "  User Messages: ${user_msgs}"
    echo "  Assistant Messages: ${assistant_msgs}"
    echo "  Tool Calls: ${tool_calls}"
    echo "  Errors: ${errors}"
    echo "  Thinking Blocks: ${thinking_blocks}"
    echo ""
}

# Process each session file
for session_file in "${SESSION_FILES[@]}"; do
    case ${EXTRACT_TYPE} in
        metadata)
            extract_metadata "${session_file}"
            ;;
        user-prompts)
            extract_user_prompts "${session_file}"
            ;;
        tool-usage)
            echo "=== Tool Usage: $(basename "${session_file}" .jsonl) ==="
            extract_tool_usage "${session_file}"
            echo ""
            ;;
        errors)
            echo "=== Errors: $(basename "${session_file}" .jsonl) ==="
            extract_errors "${session_file}"
            echo ""
            ;;
        thinking)
            echo "=== Thinking Blocks: $(basename "${session_file}" .jsonl) ==="
            extract_thinking "${session_file}"
            echo ""
            ;;
        text-responses)
            extract_text_responses "${session_file}"
            ;;
        statistics)
            extract_statistics "${session_file}"
            ;;
        all)
            echo "========================================"
            echo "Session: $(basename "${session_file}" .jsonl)"
            echo "========================================"
            echo ""
            extract_metadata "${session_file}"
            extract_statistics "${session_file}"
            echo "--- Tool Usage ---"
            extract_tool_usage "${session_file}"
            echo ""
            echo "--- Errors ---"
            extract_errors "${session_file}"
            echo ""
            ;;
        *)
            echo "Error: Unknown extraction type: ${EXTRACT_TYPE}" >&2
            echo "Valid types: metadata, user-prompts, tool-usage, errors, thinking, text-responses, statistics, all" >&2
            exit 1
            ;;
    esac
done

#!/bin/bash
# filter-sessions.sh - Filter Claude Code sessions by various criteria
# Usage: ./filter-sessions.sh [options]
#
# Filters session logs based on date, branch, size, errors, or content

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Check dependencies
if ! command -v jq &> /dev/null; then
    echo "Error: jq is required but not installed. Install with: brew install jq" >&2
    exit 1
fi

# Default options
PROJECT_DIR="${PWD}"
SINCE=""
UNTIL=""
BRANCH=""
MIN_SIZE=""
MAX_SIZE=""
MIN_LINES=""
MAX_LINES=""
HAS_ERRORS=""
KEYWORD=""
OUTPUT_FORMAT="list"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --project)
            PROJECT_DIR="$2"
            shift 2
            ;;
        --since)
            SINCE="$2"
            shift 2
            ;;
        --until)
            UNTIL="$2"
            shift 2
            ;;
        --branch)
            BRANCH="$2"
            shift 2
            ;;
        --min-size)
            MIN_SIZE="$2"
            shift 2
            ;;
        --max-size)
            MAX_SIZE="$2"
            shift 2
            ;;
        --min-lines)
            MIN_LINES="$2"
            shift 2
            ;;
        --max-lines)
            MAX_LINES="$2"
            shift 2
            ;;
        --has-errors)
            HAS_ERRORS="true"
            shift
            ;;
        --keyword)
            KEYWORD="$2"
            shift 2
            ;;
        --format)
            OUTPUT_FORMAT="$2"
            shift 2
            ;;
        --help)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --project DIR         Project directory (default: current directory)"
            echo "  --since DATE          Sessions modified since date (YYYY-MM-DD or 'N days ago')"
            echo "  --until DATE          Sessions modified until date (YYYY-MM-DD)"
            echo "  --branch BRANCH       Filter by git branch name"
            echo "  --min-size SIZE       Minimum file size (e.g., 1M, 500K)"
            echo "  --max-size SIZE       Maximum file size"
            echo "  --min-lines N         Minimum line count"
            echo "  --max-lines N         Maximum line count"
            echo "  --has-errors          Only sessions with errors"
            echo "  --keyword WORD        Sessions containing keyword"
            echo "  --format FORMAT       Output format: list (default), paths, json"
            echo "  --help                Show this help message"
            echo ""
            echo "Examples:"
            echo "  $0 --since '2 days ago'                # Recent sessions"
            echo "  $0 --branch main --has-errors          # Errors on main branch"
            echo "  $0 --min-lines 500 --keyword 'test'    # Large sessions with 'test'"
            exit 0
            ;;
        *)
            echo "Error: Unknown argument: $1" >&2
            exit 1
            ;;
    esac
done

# Get logs directory
LOGS_DIR=$("${SCRIPT_DIR}/locate-logs.sh" "${PROJECT_DIR}")

if [ ! -d "${LOGS_DIR}" ]; then
    echo "Error: Logs directory not found: ${LOGS_DIR}" >&2
    exit 1
fi

# Find all session files
ALL_FILES=()
while IFS= read -r file; do
    ALL_FILES+=("$file")
done < <(find "${LOGS_DIR}" -maxdepth 1 -name "*.jsonl" -type f)

if [ ${#ALL_FILES[@]} -eq 0 ]; then
    echo "No session files found" >&2
    exit 0
fi

# Convert date string to timestamp for comparison
date_to_timestamp() {
    local date_str="$1"
    if [[ "${date_str}" =~ ago ]]; then
        # Handle relative dates like "2 days ago"
        date -j -v-$(echo "${date_str}" | sed 's/ ago//') +%s 2>/dev/null || date -d "${date_str}" +%s 2>/dev/null
    else
        # Handle absolute dates like "2025-10-24"
        date -j -f "%Y-%m-%d" "${date_str}" +%s 2>/dev/null || date -d "${date_str}" +%s 2>/dev/null
    fi
}

# Convert size string to bytes
size_to_bytes() {
    local size_str="$1"
    local num=$(echo "${size_str}" | sed 's/[^0-9.]//g')
    local unit=$(echo "${size_str}" | sed 's/[0-9.]//g' | tr '[:lower:]' '[:upper:]')

    case ${unit} in
        K|KB)
            echo $(echo "${num} * 1024" | bc | cut -d'.' -f1)
            ;;
        M|MB)
            echo $(echo "${num} * 1024 * 1024" | bc | cut -d'.' -f1)
            ;;
        G|GB)
            echo $(echo "${num} * 1024 * 1024 * 1024" | bc | cut -d'.' -f1)
            ;;
        *)
            echo "${num}"
            ;;
    esac
}

# Filter sessions
declare -a FILTERED_FILES

for file in "${ALL_FILES[@]}"; do
    INCLUDE=true

    # Time filter
    if [ -n "${SINCE}" ] || [ -n "${UNTIL}" ]; then
        FILE_TIMESTAMP=$(stat -f%m "${file}" 2>/dev/null || stat -c%Y "${file}" 2>/dev/null)

        if [ -n "${SINCE}" ]; then
            SINCE_TIMESTAMP=$(date_to_timestamp "${SINCE}")
            if [ "${FILE_TIMESTAMP}" -lt "${SINCE_TIMESTAMP}" ]; then
                INCLUDE=false
            fi
        fi

        if [ -n "${UNTIL}" ]; then
            UNTIL_TIMESTAMP=$(date_to_timestamp "${UNTIL}")
            if [ "${FILE_TIMESTAMP}" -gt "${UNTIL_TIMESTAMP}" ]; then
                INCLUDE=false
            fi
        fi
    fi

    # Branch filter
    if [ -n "${BRANCH}" ] && [ "${INCLUDE}" = true ]; then
        FILE_BRANCH=$(head -1 "${file}" | jq -r '.gitBranch // "unknown"' 2>/dev/null)
        if [ "${FILE_BRANCH}" != "${BRANCH}" ]; then
            INCLUDE=false
        fi
    fi

    # Size filter
    if [ "${INCLUDE}" = true ] && { [ -n "${MIN_SIZE}" ] || [ -n "${MAX_SIZE}" ]; }; then
        FILE_SIZE=$(stat -f%z "${file}" 2>/dev/null || stat -c%s "${file}" 2>/dev/null)

        if [ -n "${MIN_SIZE}" ]; then
            MIN_BYTES=$(size_to_bytes "${MIN_SIZE}")
            if [ "${FILE_SIZE}" -lt "${MIN_BYTES}" ]; then
                INCLUDE=false
            fi
        fi

        if [ -n "${MAX_SIZE}" ]; then
            MAX_BYTES=$(size_to_bytes "${MAX_SIZE}")
            if [ "${FILE_SIZE}" -gt "${MAX_BYTES}" ]; then
                INCLUDE=false
            fi
        fi
    fi

    # Line count filter
    if [ "${INCLUDE}" = true ] && { [ -n "${MIN_LINES}" ] || [ -n "${MAX_LINES}" ]; }; then
        LINE_COUNT=$(wc -l < "${file}" | tr -d ' ')

        if [ -n "${MIN_LINES}" ] && [ "${LINE_COUNT}" -lt "${MIN_LINES}" ]; then
            INCLUDE=false
        fi

        if [ -n "${MAX_LINES}" ] && [ "${LINE_COUNT}" -gt "${MAX_LINES}" ]; then
            INCLUDE=false
        fi
    fi

    # Errors filter
    if [ "${HAS_ERRORS}" = true ] && [ "${INCLUDE}" = true ]; then
        ERROR_COUNT=$(grep -c '"is_error":true' "${file}" 2>/dev/null || echo "0")
        if [ "${ERROR_COUNT}" -eq 0 ]; then
            INCLUDE=false
        fi
    fi

    # Keyword filter
    if [ -n "${KEYWORD}" ] && [ "${INCLUDE}" = true ]; then
        if ! grep -q "${KEYWORD}" "${file}" 2>/dev/null; then
            INCLUDE=false
        fi
    fi

    # Add to filtered list
    if [ "${INCLUDE}" = true ]; then
        FILTERED_FILES+=("${file}")
    fi
done

# Output results
if [ ${#FILTERED_FILES[@]} -eq 0 ]; then
    echo "No sessions match the specified criteria" >&2
    exit 0
fi

case ${OUTPUT_FORMAT} in
    paths)
        for file in "${FILTERED_FILES[@]}"; do
            echo "${file}"
        done
        ;;
    json)
        echo "["
        FIRST=true
        for file in "${FILTERED_FILES[@]}"; do
            SESSION_ID=$(basename "${file}" .jsonl)
            FILE_SIZE=$(du -h "${file}" | cut -f1)
            LINE_COUNT=$(wc -l < "${file}" | tr -d ' ')
            MODIFIED_DATE=$(stat -f%Sm -t "%Y-%m-%d %H:%M:%S" "${file}" 2>/dev/null || stat -c%y "${file}" 2>/dev/null | cut -d'.' -f1)
            GIT_BRANCH=$(head -1 "${file}" | jq -r '.gitBranch // "unknown"' 2>/dev/null || echo "unknown")

            if [ "${FIRST}" = true ]; then
                FIRST=false
            else
                echo ","
            fi
            echo "  {"
            echo "    \"sessionId\": \"${SESSION_ID}\","
            echo "    \"path\": \"${file}\","
            echo "    \"size\": \"${FILE_SIZE}\","
            echo "    \"lines\": ${LINE_COUNT},"
            echo "    \"modifiedDate\": \"${MODIFIED_DATE}\","
            echo "    \"gitBranch\": \"${GIT_BRANCH}\""
            echo -n "  }"
        done
        echo ""
        echo "]"
        ;;
    list|*)
        echo "Found ${#FILTERED_FILES[@]} matching session(s):"
        echo ""
        for file in "${FILTERED_FILES[@]}"; do
            SESSION_ID=$(basename "${file}" .jsonl)
            FILE_SIZE=$(du -h "${file}" | cut -f1)
            LINE_COUNT=$(wc -l < "${file}" | tr -d ' ')
            MODIFIED_DATE=$(stat -f%Sm -t "%Y-%m-%d %H:%M:%S" "${file}" 2>/dev/null || stat -c%y "${file}" 2>/dev/null | cut -d'.' -f1)
            GIT_BRANCH=$(head -1 "${file}" | jq -r '.gitBranch // "unknown"' 2>/dev/null || echo "unknown")

            echo "Session: ${SESSION_ID}"
            echo "  Path: ${file}"
            echo "  Size: ${FILE_SIZE}"
            echo "  Lines: ${LINE_COUNT}"
            echo "  Modified: ${MODIFIED_DATE}"
            echo "  Branch: ${GIT_BRANCH}"
            echo ""
        done
        ;;
esac

#!/bin/bash
# list-sessions.sh - List available Claude Code sessions with metadata
# Usage: ./list-sessions.sh [project-directory] [options]
#
# Lists all session log files with metadata (ID, size, date, branch, lines)

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Default options
OUTPUT_FORMAT="table"  # table, json, csv
SORT_BY="date"         # date, size, lines

# Parse arguments
PROJECT_DIR="${PWD}"
while [[ $# -gt 0 ]]; do
    case $1 in
        --format)
            OUTPUT_FORMAT="$2"
            shift 2
            ;;
        --sort)
            SORT_BY="$2"
            shift 2
            ;;
        --help)
            echo "Usage: $0 [project-directory] [options]"
            echo ""
            echo "Options:"
            echo "  --format FORMAT    Output format: table (default), json, csv"
            echo "  --sort FIELD       Sort by: date (default), size, lines"
            echo "  --help             Show this help message"
            echo ""
            echo "Examples:"
            echo "  $0                              # List sessions for current directory"
            echo "  $0 /path/to/project             # List sessions for specific project"
            echo "  $0 --format json --sort size    # JSON output sorted by size"
            exit 0
            ;;
        *)
            PROJECT_DIR="$1"
            shift
            ;;
    esac
done

# Get logs directory
LOGS_DIR=$("${SCRIPT_DIR}/locate-logs.sh" "${PROJECT_DIR}")

if [ ! -d "${LOGS_DIR}" ]; then
    echo "Error: Logs directory not found: ${LOGS_DIR}" >&2
    exit 1
fi

# Check for session files
SESSION_FILES=$(find "${LOGS_DIR}" -maxdepth 1 -name "*.jsonl" -type f 2>/dev/null || true)

if [ -z "${SESSION_FILES}" ]; then
    echo "No session log files found in: ${LOGS_DIR}" >&2
    exit 0
fi

# Extract metadata for each session
declare -a SESSIONS

while IFS= read -r file; do
    SESSION_ID=$(basename "${file}" .jsonl)
    FILE_SIZE=$(du -h "${file}" | cut -f1)
    FILE_SIZE_BYTES=$(stat -f%z "${file}" 2>/dev/null || stat -c%s "${file}" 2>/dev/null)
    LINE_COUNT=$(wc -l < "${file}" | tr -d ' ')
    MODIFIED_DATE=$(stat -f%Sm -t "%Y-%m-%d %H:%M:%S" "${file}" 2>/dev/null || stat -c%y "${file}" 2>/dev/null | cut -d'.' -f1)

    # Try to extract git branch from first line
    GIT_BRANCH=$(head -1 "${file}" | jq -r '.gitBranch // "unknown"' 2>/dev/null || echo "unknown")

    SESSIONS+=("${SESSION_ID}|${FILE_SIZE}|${FILE_SIZE_BYTES}|${LINE_COUNT}|${MODIFIED_DATE}|${GIT_BRANCH}")
done <<< "${SESSION_FILES}"

# Sort sessions
case ${SORT_BY} in
    date)
        IFS=$'\n' SORTED=($(sort -t'|' -k5 -r <<< "${SESSIONS[*]}"))
        ;;
    size)
        IFS=$'\n' SORTED=($(sort -t'|' -k3 -rn <<< "${SESSIONS[*]}"))
        ;;
    lines)
        IFS=$'\n' SORTED=($(sort -t'|' -k4 -rn <<< "${SESSIONS[*]}"))
        ;;
    *)
        SORTED=("${SESSIONS[@]}")
        ;;
esac

# Output in requested format
case ${OUTPUT_FORMAT} in
    json)
        echo "["
        FIRST=true
        for session in "${SORTED[@]}"; do
            IFS='|' read -r id size size_bytes lines date branch <<< "${session}"
            if [ "${FIRST}" = true ]; then
                FIRST=false
            else
                echo ","
            fi
            echo "  {"
            echo "    \"sessionId\": \"${id}\","
            echo "    \"size\": \"${size}\","
            echo "    \"sizeBytes\": ${size_bytes},"
            echo "    \"lines\": ${lines},"
            echo "    \"modifiedDate\": \"${date}\","
            echo "    \"gitBranch\": \"${branch}\""
            echo -n "  }"
        done
        echo ""
        echo "]"
        ;;
    csv)
        echo "SessionID,Size,SizeBytes,Lines,ModifiedDate,GitBranch"
        for session in "${SORTED[@]}"; do
            IFS='|' read -r id size size_bytes lines date branch <<< "${session}"
            echo "${id},${size},${size_bytes},${lines},${date},${branch}"
        done
        ;;
    table|*)
        printf "%-40s %-10s %-10s %-20s %-20s\n" "SESSION_ID" "SIZE" "LINES" "MODIFIED" "BRANCH"
        printf "%-40s %-10s %-10s %-20s %-20s\n" "----------------------------------------" "----------" "----------" "--------------------" "--------------------"
        for session in "${SORTED[@]}"; do
            IFS='|' read -r id size size_bytes lines date branch <<< "${session}"
            printf "%-40s %-10s %-10s %-20s %-20s\n" "${id}" "${size}" "${lines}" "${date}" "${branch}"
        done
        ;;
esac

#!/bin/bash
# locate-logs.sh - Find Claude Code session log paths
# Usage: ./locate-logs.sh [project-directory] [session-id]
#
# Returns the path to session logs directory or specific session log file
# If no arguments provided, uses current working directory

set -e

# Calculate project identifier from working directory
calculate_project_dir() {
    local work_dir="$1"
    echo "${work_dir}" | sed 's/\//\-/g'
}

# Get session logs directory
get_logs_directory() {
    local work_dir="${1:-${PWD}}"
    local project_id=$(calculate_project_dir "${work_dir}")
    echo "${HOME}/.claude/projects/${project_id}"
}

# Get specific session log file
get_session_file() {
    local work_dir="$1"
    local session_id="$2"
    local logs_dir=$(get_logs_directory "${work_dir}")
    echo "${logs_dir}/${session_id}.jsonl"
}

# Main logic
if [ $# -eq 0 ]; then
    # No arguments: return logs directory for current working directory
    get_logs_directory "${PWD}"
elif [ $# -eq 1 ]; then
    # One argument: treat as project directory
    get_logs_directory "$1"
elif [ $# -eq 2 ]; then
    # Two arguments: project directory + session ID
    get_session_file "$1" "$2"
else
    echo "Error: Invalid arguments" >&2
    echo "Usage: $0 [project-directory] [session-id]" >&2
    echo "" >&2
    echo "Examples:" >&2
    echo "  $0                           # Logs dir for current directory" >&2
    echo "  $0 /path/to/project          # Logs dir for specific project" >&2
    echo "  $0 /path/to/project abc123   # Specific session log file" >&2
    exit 1
fi