lacy 1.8.11 → 1.8.13

package/lib/core/commands.sh

@@ -0,0 +1,297 @@
+#!/usr/bin/env bash
+
+# Shared command implementations — portable across Bash 4+ and ZSH
+# Uses lacy_print_color / lacy_print_color_n from constants.sh for output.
+# Sourced by lib/zsh/init.zsh and lib/bash/init.bash after all core modules.
+
+# === Helpers ===
+
+# Print colored indicator character + message on one line
+# Usage: _lacy_print_indicator_msg <color> <message>
+_lacy_print_indicator_msg() {
+    local color="$1" msg="$2"
+    lacy_print_color_n "$color" "  ${LACY_INDICATOR_CHAR}"
+    echo " $msg"
+}
+
+# Check if any tool from LACY_TOOL_LIST is installed
+_lacy_is_any_tool_installed() {
+    local _t
+    for _t in "${LACY_TOOL_LIST[@]}"; do
+        command -v "$_t" >/dev/null 2>&1 && return 0
+    done
+    return 1
+}
+
+# === Agent Execution ===
+
+# Execute command via AI agent — shows error hints on failure
+lacy_shell_execute_agent() {
+    local query="$1"
+
+    if ! lacy_shell_query_agent "$query"; then
+        if [[ -z "$LACY_ACTIVE_TOOL" ]] && ! _lacy_is_any_tool_installed; then
+            echo ""
+            printf '\e[38;5;196m  No AI tool detected.\e[0m Lacy needs an AI CLI to handle queries.\n'
+            echo ""
+            printf '\e[1m  Supported tools:\e[0m\n'
+            echo ""
+            printf '    \e[38;5;34m%-12s\e[0m %s\n' "lash"     "npm install -g lashcode        (recommended)"
+            printf '    \e[38;5;238m%-12s\e[0m %s\n' "claude"   "brew install claude"
+            printf '    \e[38;5;238m%-12s\e[0m %s\n' "opencode" "brew install opencode"
+            printf '    \e[38;5;238m%-12s\e[0m %s\n' "gemini"   "brew install gemini"
+            printf '    \e[38;5;238m%-12s\e[0m %s\n' "codex"    "npm install -g @openai/codex"
+            echo ""
+            printf '  \e[38;5;75mThen run:\e[0m  lacy setup\n'
+            printf '  \e[38;5;75mDocs:\e[0m      %s\n' "$LACY_DOCS_URL"
+            echo ""
+        else
+            local _tool="${LACY_ACTIVE_TOOL}"
+            if [[ -z "$_tool" ]]; then
+                local _t
+                for _t in "${LACY_TOOL_LIST[@]}"; do
+                    if command -v "$_t" >/dev/null 2>&1; then
+                        _tool="$_t"
+                        break
+                    fi
+                done
+            fi
+            echo ""
+            lacy_print_color 238 "$LACY_MSG_RECOVERY_TOOL"
+            lacy_print_color 238 "$LACY_MSG_RECOVERY_ASK"
+            lacy_print_color 238 "$LACY_MSG_RECOVERY_DOCTOR"
+            echo ""
+        fi
+    fi
+}
+
+# === Mode Command ===
+
+lacy_shell_mode() {
+    case "$1" in
+        "shell"|"s")
+            lacy_shell_set_mode "shell"
+            [[ "$LACY_SHELL_TYPE" == "zsh" ]] && lacy_shell_update_rprompt 2>/dev/null
+            echo ""
+            _lacy_print_indicator_msg "$LACY_COLOR_SHELL" "$LACY_MSG_MODE_SHELL"
+            echo ""
+            ;;
+        "agent"|"a")
+            lacy_shell_set_mode "agent"
+            [[ "$LACY_SHELL_TYPE" == "zsh" ]] && lacy_shell_update_rprompt 2>/dev/null
+            echo ""
+            _lacy_print_indicator_msg "$LACY_COLOR_AGENT" "$LACY_MSG_MODE_AGENT"
+            echo ""
+            ;;
+        "auto"|"u")
+            lacy_shell_set_mode "auto"
+            [[ "$LACY_SHELL_TYPE" == "zsh" ]] && lacy_shell_update_rprompt 2>/dev/null
+            echo ""
+            _lacy_print_indicator_msg "$LACY_COLOR_AUTO" "$LACY_MSG_MODE_AUTO"
+            echo ""
+            ;;
+        "toggle"|"t")
+            lacy_shell_toggle_mode
+            [[ "$LACY_SHELL_TYPE" == "zsh" ]] && lacy_shell_update_rprompt 2>/dev/null
+            local new_mode="$LACY_SHELL_CURRENT_MODE"
+            echo ""
+            case "$new_mode" in
+                "shell") _lacy_print_indicator_msg "$LACY_COLOR_SHELL" "$LACY_MSG_MODE_SHELL_SHORT" ;;
+                "agent") _lacy_print_indicator_msg "$LACY_COLOR_AGENT" "$LACY_MSG_MODE_AGENT_SHORT" ;;
+                "auto")  _lacy_print_indicator_msg "$LACY_COLOR_AUTO" "$LACY_MSG_MODE_AUTO_SHORT" ;;
+            esac
+            echo ""
+            ;;
+        "status")
+            lacy_shell_mode_status
+            ;;
+        *)
+            echo ""
+            echo "Usage: mode [shell|agent|auto|toggle|status]"
+            echo ""
+            echo -n "Current: "
+            case "$LACY_SHELL_CURRENT_MODE" in
+                "shell") lacy_print_color "$LACY_COLOR_SHELL" "SHELL" ;;
+                "agent") lacy_print_color "$LACY_COLOR_AGENT" "AGENT" ;;
+                "auto")  lacy_print_color "$LACY_COLOR_AUTO" "AUTO" ;;
+            esac
+            echo ""
+            echo "Colors:"
+            _lacy_print_indicator_msg "$LACY_COLOR_SHELL" "$LACY_MSG_COLOR_SHELL"
+            _lacy_print_indicator_msg "$LACY_COLOR_AGENT" "$LACY_MSG_COLOR_AGENT"
+            echo ""
+            ;;
+    esac
+}
+
+# === Tool Command ===
+
+lacy_shell_tool() {
+    case "$1" in
+        "")
+            echo ""
+            if [[ "$LACY_ACTIVE_TOOL" == "custom" ]]; then
+                echo "Active tool: custom (${LACY_CUSTOM_TOOL_CMD:-not configured})"
+            elif [[ -z "$LACY_ACTIVE_TOOL" ]]; then
+                local _detected=""
+                local _t
+                for _t in "${LACY_TOOL_LIST[@]}"; do
+                    if command -v "$_t" >/dev/null 2>&1; then
+                        _detected="$_t"
+                        break
+                    fi
+                done
+                if [[ -n "$_detected" ]]; then
+                    echo "Active tool: auto-detect (using $_detected)"
+                else
+                    echo "Active tool: auto-detect (no tools found)"
+                fi
+            else
+                echo "Active tool: ${LACY_ACTIVE_TOOL}"
+            fi
+            echo ""
+            echo "Available tools:"
+            local t
+            for t in "${LACY_TOOL_LIST[@]}"; do
+                if command -v "$t" >/dev/null 2>&1; then
+                    lacy_print_color_n 34 "  ✓"
+                    echo " $t"
+                else
+                    lacy_print_color_n 238 "  ○"
+                    echo " $t (not installed)"
+                fi
+            done
+            if [[ -n "$LACY_CUSTOM_TOOL_CMD" ]]; then
+                lacy_print_color_n 34 "  ✓"
+                echo " custom ($LACY_CUSTOM_TOOL_CMD)"
+            else
+                lacy_print_color_n 238 "  ○"
+                echo " custom (not configured)"
+            fi
+            echo ""
+            echo "Usage: tool set <name>"
+            echo "       tool set custom \"command -flags\""
+            echo ""
+            ;;
+        set)
+            if [[ -z "$2" ]]; then
+                echo "Usage: tool set <name>"
+                echo "Options: lash, claude, opencode, gemini, codex, hermes, copilot, goose, amp, aider, custom, auto"
+                echo "  tool set custom \"command -flags\""
+                return 1
+            fi
+            if [[ "$2" == "auto" ]]; then
+                lacy_preheat_cleanup
+                LACY_ACTIVE_TOOL=""
+                export LACY_ACTIVE_TOOL
+                echo "Tool set to: auto-detect"
+            elif [[ "$2" == "custom" ]]; then
+                if [[ -z "$3" ]]; then
+                    echo "Usage: tool set custom \"command -flags\""
+                    echo "Example: tool set custom \"claude --dangerously-skip-permissions -p\""
+                    return 1
+                fi
+                lacy_preheat_cleanup
+                LACY_ACTIVE_TOOL="custom"
+                LACY_CUSTOM_TOOL_CMD="$3"
+                export LACY_ACTIVE_TOOL LACY_CUSTOM_TOOL_CMD
+                echo "Tool set to: custom ($LACY_CUSTOM_TOOL_CMD)"
+            else
+                lacy_preheat_cleanup
+                LACY_ACTIVE_TOOL="$2"
+                export LACY_ACTIVE_TOOL
+                echo "Tool set to: $2"
+            fi
+            ;;
+        *)
+            echo "Usage: tool [set <name>]"
+            echo "Options: lash, claude, opencode, gemini, codex, hermes, copilot, goose, amp, aider, custom, auto"
+            echo "  tool set custom \"command -flags\""
+            ;;
+    esac
+}
+
+# === Spinner Command ===
+
+lacy_shell_spinner() {
+    case "$1" in
+        "")
+            echo ""
+            echo "Active spinner: ${LACY_SPINNER_STYLE:-braille}"
+            echo ""
+            echo "Available animations:"
+            lacy_list_spinner_animations
+            echo ""
+            echo "Usage: spinner set <name>"
+            echo "       spinner preview [name|all]"
+            echo ""
+            ;;
+        set)
+            if [[ -z "$2" ]]; then
+                echo "Usage: spinner set <name>"
+                echo "Available: ${LACY_SPINNER_ANIMATIONS[*]} random"
+                return 1
+            fi
+            if [[ "$2" == "random" ]] || _lacy_in_list "$2" "${LACY_SPINNER_ANIMATIONS[@]}"; then
+                LACY_SPINNER_STYLE="$2"
+                export LACY_SPINNER_STYLE
+                echo "Spinner set to: $2"
+            else
+                echo "Unknown animation: $2"
+                echo "Available: ${LACY_SPINNER_ANIMATIONS[*]} random"
+                return 1
+            fi
+            ;;
+        preview)
+            if [[ "$2" == "all" ]]; then
+                echo "Previewing all animations (Ctrl+C to stop)"
+                echo ""
+                lacy_preview_all_spinners 5
+            else
+                local style="${2:-${LACY_SPINNER_STYLE:-braille}}"
+                if [[ "$style" != "random" ]] && ! _lacy_in_list "$style" "${LACY_SPINNER_ANIMATIONS[@]}"; then
+                    echo "Unknown animation: $style"
+                    return 1
+                fi
+                local _saved="$LACY_SPINNER_STYLE"
+                LACY_SPINNER_STYLE="$style"
+                echo "Previewing: $style (Ctrl+C to stop)"
+                lacy_start_spinner
+                sleep 3
+                lacy_stop_spinner
+                LACY_SPINNER_STYLE="$_saved"
+            fi
+            ;;
+        *)
+            echo "Usage: spinner [set <name> | preview [name|all]]"
+            ;;
+    esac
+}
+
+# === Conversation Management ===
+
+lacy_shell_clear_conversation() {
+    rm -f "$LACY_SHELL_CONVERSATION_FILE"
+    echo "$LACY_MSG_CONVERSATION_CLEARED"
+}
+
+lacy_shell_show_conversation() {
+    if [[ -f "$LACY_SHELL_CONVERSATION_FILE" ]]; then
+        cat "$LACY_SHELL_CONVERSATION_FILE"
+    else
+        echo "$LACY_MSG_NO_CONVERSATION"
+    fi
+}
+
+# === Session Command Override ===
+
+# Override lacy command to handle session subcommands without subprocess
+lacy() {
+    local cmd="${1:-}"
+    cmd="${cmd#/}"  # strip optional leading slash (/new → new)
+    case "$cmd" in
+        new|reset|clear) lacy_session_new ;;
+        resume)          lacy_session_resume ;;
+        *)               command lacy "$@" ;;
+    esac
+}

package/lib/core/config.sh

@@ -0,0 +1,340 @@
+#!/usr/bin/env bash
+
+# Configuration management for Lacy Shell
+# Shared across Bash 4+ and ZSH
+
+# Default configuration
+declare -A LACY_SHELL_CONFIG 2>/dev/null || true
+# LACY_SHELL_CONFIG_FILE is defined in constants.sh
+
+# ============================================================================
+# Config Parsing Helpers (reduces code duplication)
+# ============================================================================
+
+# Simple YAML parser for shell (handles basic key: value)
+lacy_shell_parse_yaml_value() {
+    local file="$1"
+    local key="$2"
+
+    grep "^[[:space:]]*${key}:" "$file" 2>/dev/null | head -1 | sed 's/^[^:]*:[[:space:]]*//' | tr -d '"' | tr -d "'"
+}
+
+# Clean a config value (remove quotes, comments, whitespace)
+lacy_shell_clean_config_value() {
+    local value="$1"
+    echo "$value" | sed 's/#.*//' | tr -d '"' | tr -d "'" | xargs
+}
+
+# Parse a key-value line from config and export if valid
+# Usage: lacy_shell_export_config_value <key> <value> <key_map>
+# key_map format: "config_key1:ENV_VAR1,config_key2:ENV_VAR2"
+lacy_shell_export_config_value() {
+    local key="$1"
+    local value="$2"
+    local key_map="$3"
+
+    # Clean the value
+    value=$(lacy_shell_clean_config_value "$value")
+
+    # Skip empty or null values
+    if [[ -z "$value" ]] || [[ "$value" == "null" ]]; then
+        return 1
+    fi
+
+    # Split key_map by comma and iterate
+    local IFS_save="$IFS"
+    IFS=','
+    local -a mappings
+    if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+        mappings=( ${(s:,:)key_map} )
+    else
+        read -ra mappings <<< "$key_map"
+    fi
+    IFS="$IFS_save"
+
+    local mapping config_key env_var
+    for mapping in "${mappings[@]}"; do
+        config_key="${mapping%%:*}"
+        env_var="${mapping#*:}"
+        if [[ "$key" == "$config_key" ]]; then
+            export "$env_var"="$value"
+            return 0
+        fi
+    done
+    return 1
+}
+
+# Load configuration from file
+lacy_shell_load_config() {
+    # Set defaults from constants
+    LACY_SHELL_CURRENT_MODE="$LACY_SHELL_DEFAULT_MODE"
+
+    # Ensure config directory exists
+    mkdir -p "$LACY_SHELL_HOME"
+
+    # Create default config if it doesn't exist
+    if [[ ! -f "$LACY_SHELL_CONFIG_FILE" ]]; then
+        lacy_shell_create_default_config
+        LACY_CONFIG_CACHE_VALID=false
+    fi
+
+    # Check if we can use cached config (cache must be newer than config)
+    if [[ "$LACY_CONFIG_CACHE_VALID" == true ]] && \
+       [[ -f "$LACY_SHELL_CONFIG_CACHE_FILE" ]] && \
+       [[ ! "$LACY_SHELL_CONFIG_FILE" -nt "$LACY_SHELL_CONFIG_CACHE_FILE" ]]; then
+        # Use cached config - much faster
+        source "$LACY_SHELL_CONFIG_CACHE_FILE"
+        return
+    fi
+
+    # Parse configuration using optimized single-pass parsing
+    if [[ -f "$LACY_SHELL_CONFIG_FILE" ]]; then
+        # Define key mappings for each section
+        local api_keys_map="openai:LACY_SHELL_API_OPENAI,anthropic:LACY_SHELL_API_ANTHROPIC"
+        local model_map="provider:LACY_SHELL_PROVIDER,name:LACY_SHELL_MODEL_NAME"
+        local agent_map="command:LACY_SHELL_AGENT_COMMAND,context_mode:LACY_SHELL_AGENT_CONTEXT_MODE,needs_api_keys:LACY_SHELL_AGENT_NEEDS_API_KEYS"
+        local agent_tools_map="active:LACY_ACTIVE_TOOL,custom_command:LACY_CUSTOM_TOOL_CMD"
+        local preheat_map="eager:LACY_PREHEAT_EAGER,server_port:LACY_PREHEAT_SERVER_PORT"
+        local context_map="output:_LACY_CTX_OUTPUT_ENABLED,output_lines:_LACY_CTX_OUTPUT_MAX_LINES"
+        local spinner_map="style:LACY_SPINNER_STYLE"
+
+        # Track current section
+        local current_section=""
+
+        local line key value
+        while IFS= read -r line; do
+            # Detect section headers
+            if [[ "$line" =~ ^api_keys: ]]; then
+                current_section="api_keys"
+                continue
+            elif [[ "$line" =~ ^model: ]]; then
+                current_section="model"
+                continue
+            elif [[ "$line" =~ ^agent_tools: ]]; then
+                current_section="agent_tools"
+                continue
+            elif [[ "$line" =~ ^preheat: ]]; then
+                current_section="preheat"
+                continue
+            elif [[ "$line" =~ ^context: ]]; then
+                current_section="context"
+                continue
+            elif [[ "$line" =~ ^spinner: ]]; then
+                current_section="spinner"
+                continue
+            elif [[ "$line" =~ ^agent: ]]; then
+                current_section="agent"
+                continue
+            elif [[ "$line" =~ ^[^[:space:]] ]] && [[ ! "$line" =~ ^# ]]; then
+                # New section started (not indented, not a comment)
+                current_section=""
+            fi
+
+            # Parse key-value pairs within sections
+            if [[ -n "$current_section" ]] && [[ "$line" =~ ^[[:space:]]+([^:]+):[[:space:]]*(.+) ]]; then
+                if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+                    key="${match[1]}"
+                    value="${match[2]}"
+                else
+                    key="${BASH_REMATCH[1]}"
+                    value="${BASH_REMATCH[2]}"
+                fi
+
+                # Use appropriate key map based on section
+                case "$current_section" in
+                    "api_keys")
+                        lacy_shell_export_config_value "$key" "$value" "$api_keys_map"
+                        ;;
+                    "model")
+                        lacy_shell_export_config_value "$key" "$value" "$model_map"
+                        ;;
+                    "agent")
+                        lacy_shell_export_config_value "$key" "$value" "$agent_map"
+                        ;;
+                    "agent_tools")
+                        lacy_shell_export_config_value "$key" "$value" "$agent_tools_map"
+                        ;;
+                    "preheat")
+                        lacy_shell_export_config_value "$key" "$value" "$preheat_map"
+                        ;;
+                    "context")
+                        lacy_shell_export_config_value "$key" "$value" "$context_map"
+                        ;;
+                    "spinner")
+                        lacy_shell_export_config_value "$key" "$value" "$spinner_map"
+                        ;;
+                esac
+            fi
+        done < "$LACY_SHELL_CONFIG_FILE"
+
+        # Check for MCP configuration (simplified)
+        local mcp_line servers_line
+        mcp_line=$(grep "^mcp:" "$LACY_SHELL_CONFIG_FILE" 2>/dev/null || true)
+        servers_line=$(grep "^[[:space:]]*servers:" "$LACY_SHELL_CONFIG_FILE" 2>/dev/null || true)
+        if [[ -n "$mcp_line" ]] && [[ -n "$servers_line" ]]; then
+            LACY_SHELL_MCP_SERVERS="configured"
+            LACY_SHELL_MCP_SERVERS_JSON='[{"name":"filesystem","command":"npx","args":["@modelcontextprotocol/server-filesystem"]}]'
+        else
+            LACY_SHELL_MCP_SERVERS=""
+            LACY_SHELL_MCP_SERVERS_JSON=""
+        fi
+
+        # Cache the parsed configuration for fast future loads
+        # Use printf %q to safely escape values (prevents injection when sourced)
+        {
+            echo "# Generated config cache - do not edit"
+            printf 'LACY_SHELL_CURRENT_MODE=%q\n' "$LACY_SHELL_CURRENT_MODE"
+            printf 'LACY_SHELL_API_OPENAI=%q\n' "$LACY_SHELL_API_OPENAI"
+            printf 'LACY_SHELL_API_ANTHROPIC=%q\n' "$LACY_SHELL_API_ANTHROPIC"
+            printf 'LACY_SHELL_PROVIDER=%q\n' "$LACY_SHELL_PROVIDER"
+            printf 'LACY_SHELL_MODEL_NAME=%q\n' "$LACY_SHELL_MODEL_NAME"
+            printf 'LACY_ACTIVE_TOOL=%q\n' "$LACY_ACTIVE_TOOL"
+            printf 'LACY_CUSTOM_TOOL_CMD=%q\n' "$LACY_CUSTOM_TOOL_CMD"
+            printf 'LACY_SHELL_MCP_SERVERS=%q\n' "$LACY_SHELL_MCP_SERVERS"
+            printf 'LACY_SHELL_MCP_SERVERS_JSON=%q\n' "$LACY_SHELL_MCP_SERVERS_JSON"
+            printf '_LACY_CTX_OUTPUT_ENABLED=%q\n' "${_LACY_CTX_OUTPUT_ENABLED:-true}"
+            printf '_LACY_CTX_OUTPUT_MAX_LINES=%q\n' "${_LACY_CTX_OUTPUT_MAX_LINES:-50}"
+            printf 'LACY_SPINNER_STYLE=%q\n' "${LACY_SPINNER_STYLE:-random}"
+        } > "$LACY_SHELL_CONFIG_CACHE_FILE"
+
+        LACY_CONFIG_CACHE_VALID=true
+
+        # Export variables for global access
+        export LACY_SHELL_MCP_SERVERS
+        export LACY_SHELL_MCP_SERVERS_JSON
+    fi
+
+    # Also check environment variables as fallback
+    if [[ -z "$LACY_SHELL_API_OPENAI" ]] && [[ -n "$OPENAI_API_KEY" ]]; then
+        export LACY_SHELL_API_OPENAI="$OPENAI_API_KEY"
+    fi
+    if [[ -z "$LACY_SHELL_API_ANTHROPIC" ]] && [[ -n "$ANTHROPIC_API_KEY" ]]; then
+        export LACY_SHELL_API_ANTHROPIC="$ANTHROPIC_API_KEY"
+    fi
+
+    # Provider/model overrides via env
+    if [[ -z "$LACY_SHELL_PROVIDER" ]] && [[ -n "$LACY_SHELL_DEFAULT_PROVIDER" ]]; then
+        export LACY_SHELL_PROVIDER="$LACY_SHELL_DEFAULT_PROVIDER"
+    fi
+    if [[ -z "$LACY_SHELL_MODEL_NAME" ]] && [[ -n "$LACY_SHELL_DEFAULT_MODEL" ]]; then
+        export LACY_SHELL_MODEL_NAME="$LACY_SHELL_DEFAULT_MODEL"
+    fi
+
+    # Agent CLI defaults (if not configured, use defaults from constants)
+    : "${LACY_SHELL_AGENT_COMMAND:="$LACY_SHELL_DEFAULT_AGENT_COMMAND"}"
+    : "${LACY_SHELL_AGENT_CONTEXT_MODE:="$LACY_SHELL_DEFAULT_AGENT_CONTEXT_MODE"}"
+    : "${LACY_SHELL_AGENT_NEEDS_API_KEYS:="$LACY_SHELL_DEFAULT_AGENT_NEEDS_API_KEYS"}"
+    export LACY_SHELL_AGENT_COMMAND LACY_SHELL_AGENT_CONTEXT_MODE LACY_SHELL_AGENT_NEEDS_API_KEYS
+
+    # Active AI tool (empty = auto-detect)
+    export LACY_ACTIVE_TOOL
+    export LACY_CUSTOM_TOOL_CMD
+
+    # Initialize current mode from default
+    LACY_SHELL_CURRENT_MODE="$LACY_SHELL_DEFAULT_MODE"
+
+    # Export configuration
+    export LACY_SHELL_CURRENT_MODE
+}
+
+# Create default configuration file
+lacy_shell_create_default_config() {
+    cat > "$LACY_SHELL_CONFIG_FILE" << 'EOF'
+# Lacy Shell Configuration
+# Edit this file to customize your settings
+
+# API Keys for AI providers
+api_keys:
+  openai: # Add your OpenAI API key here
+  anthropic: # Add your Anthropic API key here
+
+# Operating modes
+modes:
+  default: auto  # Options: shell, agent, auto
+
+# Smart auto-detection settings
+auto_detection:
+  enabled: true
+  confidence_threshold: 0.7
+
+# MCP (Model Context Protocol) configuration
+mcp:
+  enabled: false
+  servers:
+    - name: filesystem
+      command: npx
+      args: ["@modelcontextprotocol/server-filesystem", "/"]
+    - name: web
+      command: npx
+      args: ["@modelcontextprotocol/server-web"]
+
+# Appearance
+appearance:
+  show_mode_indicator: true
+  mode_colors:
+    shell: green
+    agent: blue
+    auto: yellow
+
+# Model selection (used when agent CLI is not installed)
+
+
+# AI CLI tool selection
+# Lacy auto-detects installed tools, or you can set one explicitly
+agent_tools:
+  # Options: lash, claude, opencode, gemini, codex, hermes, copilot, amp, custom, or empty for auto-detect
+  active:
+  # Custom command (used when active: custom)
+  # custom_command: "your-command -flags"
+
+# Preheat: keep agents warm between queries (lash, opencode)
+# preheat:
+#   eager: false          # Start background server on plugin load
+#   server_port: 4096     # Port for background server
+
+# Terminal context: output capture (tmux, screen, iTerm2, Terminal.app)
+# context:
+#   output: true          # Capture terminal screen at query time
+#   output_lines: 50      # Max lines to include (truncates from top)
+
+# Spinner animation style
+# Options: braille (default), dots, ascii (no Unicode), braillewave, dna, scan,
+#          rain, scanline, pulse, snake, sparkle, cascade, columns, orbit, breathe,
+#          waverows, checkerboard, helix, fillsweep, diagswipe,
+#          random (picks a different one each query)
+# spinner:
+#   style: random
+
+# Agent CLI configuration (legacy)
+# Configure which CLI tool to use for AI queries
+agent:
+  # Command to run. Variables: {query}, {context_file}
+  command: "lash run --prompt {query}"
+  # How to pass context: stdin or file
+  context_mode: stdin
+  # Set to true if the CLI needs API keys from lacy
+  needs_api_keys: false
+EOF
+
+    echo "Created default configuration at: $LACY_SHELL_CONFIG_FILE"
+}
+
+# Check if API keys are available
+lacy_shell_check_api_keys() {
+    if [[ -n "$LACY_SHELL_API_OPENAI" ]] || [[ -n "$LACY_SHELL_API_ANTHROPIC" ]]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Get active API provider
+lacy_shell_get_api_provider() {
+    if [[ -n "$LACY_SHELL_API_OPENAI" ]]; then
+        echo "openai"
+    elif [[ -n "$LACY_SHELL_API_ANTHROPIC" ]]; then
+        echo "anthropic"
+    else
+        echo "none"
+    fi
+}