claude-tw

#!/bin/bash

# Claude-TaskWarrior Integration
# Main CLI interface for TaskWarrior-Claude Code integration
# Usage: claude-tw [command] [options]

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIG_FILE="$HOME/.claude-taskwarrior.conf"
SYNC_SCRIPT="$SCRIPT_DIR/sync.js"
SESSION_FILE="/tmp/claude-tw-session.json"

# Default configuration
DEFAULT_PROJECT="claude-session"
DEFAULT_AUTO_SYNC="true"
DEFAULT_BACKUP_DIR="$HOME/.claude-taskwarrior-backups"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Initialize configuration if it doesn't exist
init_config() {
    if [[ ! -f "$CONFIG_FILE" ]]; then
        echo "# Claude-TaskWarrior Configuration" > "$CONFIG_FILE"
        echo "PROJECT=$DEFAULT_PROJECT" >> "$CONFIG_FILE"
        echo "AUTO_SYNC=$DEFAULT_AUTO_SYNC" >> "$CONFIG_FILE"
        echo "BACKUP_DIR=$DEFAULT_BACKUP_DIR" >> "$CONFIG_FILE"
        echo "CREATED=$(date)" >> "$CONFIG_FILE"
        
        mkdir -p "$DEFAULT_BACKUP_DIR"
        echo -e "${GREEN}✓${NC} Configuration initialized at $CONFIG_FILE"
    fi
    
    # Load configuration
    source "$CONFIG_FILE"
}

# Load current session state
load_session() {
    if [[ -f "$SESSION_FILE" ]]; then
        SESSION_ACTIVE=$(jq -r '.active // false' "$SESSION_FILE" 2>/dev/null || echo "false")
        SESSION_PROJECT=$(jq -r '.project // "claude-session"' "$SESSION_FILE" 2>/dev/null || echo "claude-session")
        SESSION_START=$(jq -r '.start_time // ""' "$SESSION_FILE" 2>/dev/null || echo "")
    else
        SESSION_ACTIVE="false"
        SESSION_PROJECT="$PROJECT"
        SESSION_START=""
    fi
}

# Save session state
save_session() {
    local active="$1"
    local project="$2"
    local start_time="$3"
    
    cat > "$SESSION_FILE" << EOF
{
    "active": $active,
    "project": "$project",
    "start_time": "$start_time",
    "last_sync": "$(date -Iseconds)"
}
EOF
}

# Start a new session
start_session() {
    local project_name="${1:-$PROJECT}"
    
    init_config
    
    echo -e "${BLUE}🚀 Starting Claude-TaskWarrior session...${NC}"
    
    # Create backup
    backup_tasks "$project_name"
    
    # Import existing TaskWarrior tasks
    if task project:"$project_name" export &>/dev/null; then
        local task_count=$(task project:"$project_name" count 2>/dev/null || echo "0")
        if [[ "$task_count" -gt 0 ]]; then
            echo -e "${YELLOW}📥 Found $task_count existing tasks in TaskWarrior${NC}"
            node "$SYNC_SCRIPT" export "$project_name" > "/tmp/claude-import-$$.json"
            echo -e "${GREEN}✓${NC} Exported existing tasks for Claude import"
            echo -e "${BLUE}💡 Claude can import these with: TodoWrite$(cat /tmp/claude-import-$$.json)${NC}"
        fi
    fi
    
    # Save session state
    save_session "true" "$project_name" "$(date -Iseconds)"
    
    echo -e "${GREEN}✓${NC} Session started for project: $project_name"
    echo -e "${BLUE}💡 Use 'claude-tw sync' to sync Claude todos to TaskWarrior${NC}"
    echo -e "${BLUE}💡 Use 'claude-tw status' to check session status${NC}"
}

# Sync Claude todos to TaskWarrior
sync_todos() {
    load_session
    
    if [[ "$SESSION_ACTIVE" != "true" ]]; then
        echo -e "${RED}❌ No active session. Start one with: claude-tw start${NC}"
        exit 1
    fi
    
    local todos_json="$1"
    
    if [[ -z "$todos_json" ]]; then
        echo -e "${YELLOW}⚠️  No todos provided. Usage: claude-tw sync '[{\"id\":\"...\"}]'${NC}"
        exit 1
    fi
    
    echo -e "${BLUE}🔄 Syncing todos to TaskWarrior...${NC}"
    
    # Backup before sync
    backup_tasks "$SESSION_PROJECT"
    
    # Clear existing project tasks and import new ones
    if task project:"$SESSION_PROJECT" count &>/dev/null && [[ $(task project:"$SESSION_PROJECT" count) -gt 0 ]]; then
        echo "yes" | task project:"$SESSION_PROJECT" delete &>/dev/null
    fi
    
    # Import new todos
    node "$SYNC_SCRIPT" import "$SESSION_PROJECT" "$todos_json"
    
    local task_count=$(task project:"$SESSION_PROJECT" count 2>/dev/null || echo "0")
    echo -e "${GREEN}✓${NC} Synced $task_count tasks to TaskWarrior project: $SESSION_PROJECT"
    
    # Update session
    save_session "true" "$SESSION_PROJECT" "$SESSION_START"
}

# Export TaskWarrior tasks for Claude
export_todos() {
    load_session
    
    if [[ "$SESSION_ACTIVE" != "true" ]]; then
        echo -e "${RED}❌ No active session. Start one with: claude-tw start${NC}"
        exit 1
    fi
    
    local task_count=$(task project:"$SESSION_PROJECT" count 2>/dev/null || echo "0")
    
    if [[ "$task_count" -eq 0 ]]; then
        echo -e "${YELLOW}⚠️  No tasks found in project: $SESSION_PROJECT${NC}"
        echo "[]"
        exit 0
    fi
    
    echo -e "${BLUE}📤 Exporting $task_count tasks from TaskWarrior...${NC}" >&2
    node "$SYNC_SCRIPT" export "$SESSION_PROJECT"
}

# Show session status
show_status() {
    load_session
    
    echo -e "${BLUE}📊 Claude-TaskWarrior Status${NC}"
    echo "=================================="
    
    if [[ "$SESSION_ACTIVE" == "true" ]]; then
        echo -e "Status: ${GREEN}Active${NC}"
        echo "Project: $SESSION_PROJECT"
        echo "Started: $SESSION_START"
        
        local task_count=$(task project:"$SESSION_PROJECT" count 2>/dev/null || echo "0")
        local pending_count=$(task project:"$SESSION_PROJECT" status:pending count 2>/dev/null || echo "0")
        local completed_count=$(task project:"$SESSION_PROJECT" status:completed count 2>/dev/null || echo "0")
        
        echo "Tasks: $task_count total, $pending_count pending, $completed_count completed"
        
        if [[ "$task_count" -gt 0 ]]; then
            echo ""
            echo -e "${BLUE}Recent tasks:${NC}"
            task project:"$SESSION_PROJECT" limit:5 2>/dev/null || echo "No tasks found"
        fi
    else
        echo -e "Status: ${YELLOW}Inactive${NC}"
        echo "Use 'claude-tw start' to begin a new session"
    fi
}

# Create backup of current tasks
backup_tasks() {
    local project_name="$1"
    local backup_file="$BACKUP_DIR/backup-$(date +%Y%m%d-%H%M%S).json"
    
    if task project:"$project_name" export &>/dev/null; then
        task project:"$project_name" export > "$backup_file" 2>/dev/null
        echo -e "${GREEN}✓${NC} Backup created: $backup_file"
    fi
}

# End current session
end_session() {
    load_session
    
    if [[ "$SESSION_ACTIVE" != "true" ]]; then
        echo -e "${YELLOW}⚠️  No active session to end${NC}"
        exit 0
    fi
    
    echo -e "${BLUE}🏁 Ending Claude-TaskWarrior session...${NC}"
    
    # Final backup
    backup_tasks "$SESSION_PROJECT"
    
    # Show final summary
    local task_count=$(task project:"$SESSION_PROJECT" count 2>/dev/null || echo "0")
    local completed_count=$(task project:"$SESSION_PROJECT" status:completed count 2>/dev/null || echo "0")
    
    echo -e "${GREEN}✓${NC} Session completed"
    echo "Final stats: $completed_count of $task_count tasks completed"
    
    # Clear session
    rm -f "$SESSION_FILE"
}

# Show help
show_help() {
    echo "Claude-TaskWarrior Integration CLI"
    echo ""
    echo "USAGE:"
    echo "    claude-tw <command> [options]"
    echo ""
    echo "COMMANDS:"
    echo "    start [project]     Start new session (default project: claude-session)"
    echo "    sync '<json>'       Sync Claude todos to TaskWarrior"
    echo "    export              Export TaskWarrior tasks for Claude import"
    echo "    status              Show current session status"
    echo "    end                 End current session"
    echo "    backup              Create manual backup"
    echo "    config              Show configuration"
    echo "    help                Show this help"
    echo ""
    echo "EXAMPLES:"
    echo "    claude-tw start                           # Start session with default project"
    echo "    claude-tw start chrome-launch            # Start session with custom project"
    echo "    claude-tw sync '[{\"id\":\"1\",\"content\":\"Task\"}]'  # Sync todos"
    echo "    claude-tw export                          # Export for Claude"
    echo ""
    echo "FILES:"
    echo "    Config: $CONFIG_FILE"
    echo "    Session: $SESSION_FILE"
    echo "    Backups: $BACKUP_DIR"
}

# Main command dispatcher
main() {
    case "$1" in
        start)
            start_session "$2"
            ;;
        sync)
            sync_todos "$2"
            ;;
        export)
            export_todos
            ;;
        status)
            show_status
            ;;
        end)
            end_session
            ;;
        backup)
            load_session
            backup_tasks "${SESSION_PROJECT:-$DEFAULT_PROJECT}"
            ;;
        config)
            init_config
            echo "Configuration file: $CONFIG_FILE"
            cat "$CONFIG_FILE"
            ;;
        help|--help|-h)
            show_help
            ;;
        *)
            echo -e "${RED}❌ Unknown command: $1${NC}"
            echo "Use 'claude-tw help' for usage information"
            exit 1
            ;;
    esac
}

# Check dependencies
check_dependencies() {
    local missing_deps=()
    
    if ! command -v task &> /dev/null; then
        missing_deps+=("taskwarrior")
    fi
    
    if ! command -v node &> /dev/null; then
        missing_deps+=("nodejs")
    fi
    
    if ! command -v jq &> /dev/null; then
        missing_deps+=("jq")
    fi
    
    if [[ ${#missing_deps[@]} -gt 0 ]]; then
        echo -e "${RED}❌ Missing dependencies: ${missing_deps[*]}${NC}"
        echo "Install them with: sudo apt install ${missing_deps[*]}"
        exit 1
    fi
}

# Initialize
check_dependencies
init_config

# Run main function
main "$@"