loki-mode 5.30.0 → 5.32.0

package/autonomy/loki

@@ -306,7 +306,7 @@ show_help() {
     echo "  stop             Stop execution immediately"
     echo "  pause            Pause after current session"
     echo "  resume           Resume paused execution"
-    echo "  status           Show current status"
+    echo "  status [--json]  Show current status (--json for machine-readable)"
     echo "  logs             Show recent log output"
     echo "  dashboard [cmd]  Dashboard server (start|stop|status|url|open)"
     echo "  provider [cmd]   Manage AI provider (show|set|list|info)"
@@ -317,11 +317,13 @@ show_help() {
     echo "  voice [cmd]      Voice input for PRD creation (status|listen|dictate|speak|start)"
     echo "  import           Import GitHub issues as tasks"
     echo "  config [cmd]     Manage configuration (show|init|edit|path)"
+    echo "  completions [bash|zsh]  Output shell completion scripts"
     echo "  memory [cmd]     Cross-project learnings (list|show|search|stats)"
     echo "  compound [cmd]   Knowledge compounding (list|show|search|run|stats)"
     echo "  council [cmd]    Completion council (status|verdicts|convergence|force-review|report)"
     echo "  dogfood          Show self-development statistics"
     echo "  reset [target]   Reset session state (all|retries|failed)"
+    echo "  doctor [--json]  Check system prerequisites"
     echo "  version          Show version"
     echo "  help             Show this help"
     echo ""
@@ -389,12 +391,22 @@ cmd_start() {
                 echo "  --sandbox             Run in Docker sandbox"
                 echo "  --skip-memory         Skip loading memory context at startup"
                 echo "  --budget USD          Cost budget limit (auto-pause when exceeded)"
+                echo "  --yes, -y             Skip confirmation prompts (auto-confirm)"
+                echo ""
+                echo "Environment Variables:"
+                echo "  LOKI_PRD_FILE         Path to PRD file (alternative to positional arg)"
+                echo "  LOKI_AUTO_CONFIRM     Set to 'true'/'false' to control prompts (takes precedence over CI)"
+                echo "  CI                    Fallback: auto-confirms when 'true' and LOKI_AUTO_CONFIRM is unset"
+                echo "  LOKI_MAX_ITERATIONS   Max iteration count"
+                echo "  LOKI_BUDGET_LIMIT     Cost budget limit in USD"
                 echo ""
                 echo "Examples:"
                 echo "  loki start                      # Interactive or resume existing"
                 echo "  loki start ./prd.md             # Start with PRD file"
                 echo "  loki start ./prd.md --parallel  # Parallel mode with worktrees"
                 echo "  loki start --provider codex     # Use OpenAI Codex CLI"
+                echo "  loki start --yes                # Skip confirmation prompt"
+                echo "  LOKI_PRD_FILE=./prd.md loki start  # PRD via env var"
                 exit 0
                 ;;
             --provider)
@@ -444,6 +456,10 @@ cmd_start() {
                 export LOKI_SKIP_MEMORY=true
                 shift
                 ;;
+            --yes|-y)
+                export LOKI_AUTO_CONFIRM=true
+                shift
+                ;;
             --budget)
                 if [[ -n "${2:-}" ]]; then
                     if ! echo "$2" | grep -qE '^[0-9]+(\.[0-9]+)?$'; then
@@ -477,19 +493,32 @@ cmd_start() {
         esac
     done
 
+    # Support LOKI_PRD_FILE environment variable as fallback
+    if [ -z "$prd_file" ] && [ -n "${LOKI_PRD_FILE:-}" ]; then
+        prd_file="$LOKI_PRD_FILE"
+    fi
+
     if [ -n "$prd_file" ]; then
         args+=("$prd_file")
     else
         # No PRD file specified -- warn and confirm before consuming API credits
-        echo -e "${YELLOW}Warning: No PRD file specified.${NC}"
-        echo "Loki Mode will start autonomous execution in the current directory"
-        echo "without a requirements document."
-        echo ""
-        echo -e "This will consume API credits. Continue? [y/N] \c"
-        read -r confirm
-        if [[ ! "$confirm" =~ ^[Yy] ]]; then
-            echo "Aborted. Usage: loki start <path-to-prd.md>"
-            exit 0
+        # Auto-confirm in CI environments or when LOKI_AUTO_CONFIRM is set
+        # LOKI_AUTO_CONFIRM takes precedence when explicitly set;
+        # fall back to CI env var only when LOKI_AUTO_CONFIRM is unset
+        local _auto_confirm="${LOKI_AUTO_CONFIRM:-${CI:-false}}"
+        if [[ "$_auto_confirm" == "true" ]]; then
+            echo -e "${YELLOW}Warning: No PRD file specified. Auto-confirming (CI mode).${NC}"
+        else
+            echo -e "${YELLOW}Warning: No PRD file specified.${NC}"
+            echo "Loki Mode will start autonomous execution in the current directory"
+            echo "without a requirements document."
+            echo ""
+            echo -e "This will consume API credits. Continue? [y/N] \c"
+            read -r confirm
+            if [[ ! "$confirm" =~ ^[Yy] ]]; then
+                echo "Aborted. Usage: loki start <path-to-prd.md>"
+                exit 0
+            fi
         fi
     fi
 
@@ -861,6 +890,167 @@ cmd_status() {
     fi
 }
 
+# JSON output for loki status --json
+cmd_status_json() {
+    local skill_dir="$SKILL_DIR"
+    local loki_dir="$LOKI_DIR"
+    local dashboard_port="${LOKI_DASHBOARD_PORT:-57374}"
+    local env_provider="${LOKI_PROVIDER:-claude}"
+
+    python3 -c "
+import json, os, sys, time
+
+skill_dir = sys.argv[1]
+loki_dir = sys.argv[2]
+dashboard_port = sys.argv[3]
+env_provider = sys.argv[4]
+result = {}
+
+# Version
+version_file = os.path.join(skill_dir, 'VERSION')
+if os.path.isfile(version_file):
+    with open(version_file) as f:
+        result['version'] = f.read().strip()
+else:
+    result['version'] = 'unknown'
+
+# Check if session exists
+if not os.path.isdir(loki_dir):
+    result['status'] = 'inactive'
+    result['phase'] = None
+    result['iteration'] = 0
+    result['provider'] = env_provider
+    result['dashboard_url'] = None
+    result['pid'] = None
+    result['elapsed_time'] = 0
+    result['task_counts'] = {'total': 0, 'completed': 0, 'failed': 0, 'pending': 0}
+    print(json.dumps(result, indent=2))
+    sys.exit(0)
+
+# Status from signals and session.json
+if os.path.isfile(os.path.join(loki_dir, 'PAUSE')):
+    result['status'] = 'paused'
+elif os.path.isfile(os.path.join(loki_dir, 'STOP')):
+    result['status'] = 'stopped'
+else:
+    session_file = os.path.join(loki_dir, 'session.json')
+    if os.path.isfile(session_file):
+        try:
+            with open(session_file) as f:
+                session = json.load(f)
+            result['status'] = session.get('status', 'unknown')
+        except Exception:
+            result['status'] = 'unknown'
+    else:
+        result['status'] = 'unknown'
+
+# Phase and iteration from dashboard-state.json
+ds_file = os.path.join(loki_dir, 'dashboard-state.json')
+if os.path.isfile(ds_file):
+    try:
+        with open(ds_file) as f:
+            ds = json.load(f)
+        result['phase'] = ds.get('phase', ds.get('currentPhase'))
+        result['iteration'] = ds.get('iteration', ds.get('currentIteration', 0))
+    except Exception:
+        result['phase'] = None
+        result['iteration'] = 0
+else:
+    orch_file = os.path.join(loki_dir, 'state', 'orchestrator.json')
+    if os.path.isfile(orch_file):
+        try:
+            with open(orch_file) as f:
+                orch = json.load(f)
+            result['phase'] = orch.get('currentPhase')
+            result['iteration'] = orch.get('currentIteration', 0)
+        except Exception:
+            result['phase'] = None
+            result['iteration'] = 0
+    else:
+        result['phase'] = None
+        result['iteration'] = 0
+
+# Provider
+provider_file = os.path.join(loki_dir, 'state', 'provider')
+if os.path.isfile(provider_file):
+    with open(provider_file) as f:
+        result['provider'] = f.read().strip()
+else:
+    result['provider'] = env_provider
+
+# PID
+pid_file = os.path.join(loki_dir, 'loki.pid')
+if os.path.isfile(pid_file):
+    try:
+        with open(pid_file) as f:
+            result['pid'] = int(f.read().strip())
+    except (ValueError, Exception):
+        result['pid'] = None
+else:
+    result['pid'] = None
+
+# Elapsed time from session.json
+session_file = os.path.join(loki_dir, 'session.json')
+if os.path.isfile(session_file):
+    try:
+        with open(session_file) as f:
+            session = json.load(f)
+        start_time = session.get('start_time', session.get('startTime'))
+        if start_time:
+            if isinstance(start_time, (int, float)):
+                result['elapsed_time'] = int(time.time() - start_time)
+            else:
+                from datetime import datetime
+                dt = datetime.fromisoformat(start_time.replace('Z', '+00:00'))
+                result['elapsed_time'] = int(time.time() - dt.timestamp())
+        else:
+            result['elapsed_time'] = 0
+    except Exception:
+        result['elapsed_time'] = 0
+else:
+    result['elapsed_time'] = 0
+
+# Dashboard URL
+dashboard_pid_file = os.path.join(loki_dir, 'dashboard', 'dashboard.pid')
+dashboard_url = None
+if os.path.isfile(dashboard_pid_file):
+    try:
+        with open(dashboard_pid_file) as f:
+            dpid = int(f.read().strip())
+        os.kill(dpid, 0)
+        dashboard_url = 'http://127.0.0.1:' + dashboard_port + '/'
+    except (ProcessLookupError, PermissionError, ValueError, Exception):
+        pass
+result['dashboard_url'] = dashboard_url
+
+# Task counts from queue files
+task_counts = {'total': 0, 'completed': 0, 'failed': 0, 'pending': 0}
+queue_dir = os.path.join(loki_dir, 'queue')
+if os.path.isdir(queue_dir):
+    for name, key in [('pending.json', 'pending'), ('completed.json', 'completed'), ('failed.json', 'failed')]:
+        fpath = os.path.join(queue_dir, name)
+        if os.path.isfile(fpath):
+            try:
+                with open(fpath) as f:
+                    data = json.load(f)
+                if isinstance(data, list):
+                    task_counts[key] = len(data)
+                elif isinstance(data, dict) and 'tasks' in data:
+                    task_counts[key] = len(data['tasks'])
+            except Exception:
+                pass
+    task_counts['total'] = task_counts['pending'] + task_counts['completed'] + task_counts['failed']
+result['task_counts'] = task_counts
+
+print(json.dumps(result, indent=2))
+" "$skill_dir" "$loki_dir" "$dashboard_port" "$env_provider"
+
+    if [ $? -ne 0 ]; then
+        echo '{"error": "Failed to generate JSON status. Ensure python3 is available."}' >&2
+        return 1
+    fi
+}
+
 # Provider management
 cmd_provider() {
     local subcommand="${1:-show}"
@@ -2268,6 +2458,290 @@ cmd_config_path() {
     echo "Create a config file with: loki config init"
 }
 
+# Check system prerequisites
+cmd_doctor() {
+    local json_output=false
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --json)
+                json_output=true
+                shift
+                ;;
+            --help|-h)
+                echo -e "${BOLD}loki doctor${NC} - Check system prerequisites"
+                echo ""
+                echo "Usage: loki doctor [--json]"
+                echo ""
+                echo "Options:"
+                echo "  --json    Output machine-readable JSON"
+                echo ""
+                echo "Checks: node, python3, jq, git, curl, bash version,"
+                echo "        claude/codex/gemini CLIs, and disk space."
+                return 0
+                ;;
+            *)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Usage: loki doctor [--json]"
+                return 1
+                ;;
+        esac
+    done
+
+    if [ "$json_output" = true ]; then
+        cmd_doctor_json
+        return $?
+    fi
+
+    echo -e "${BOLD}Loki Mode Doctor${NC}"
+    echo ""
+    echo "Checking system prerequisites..."
+    echo ""
+
+    local pass_count=0
+    local fail_count=0
+    local warn_count=0
+
+    # Helper: check command exists and optionally check version
+    doctor_check() {
+        local name="$1"
+        local cmd="$2"
+        local required="$3"  # required, recommended, optional
+        local min_version="${4:-}"
+
+        if ! command -v "$cmd" &> /dev/null; then
+            if [ "$required" = "required" ]; then
+                echo -e "  ${RED}FAIL${NC}  $name - not found"
+                fail_count=$((fail_count + 1))
+            elif [ "$required" = "recommended" ]; then
+                echo -e "  ${YELLOW}WARN${NC}  $name - not found (recommended)"
+                warn_count=$((warn_count + 1))
+            else
+                echo -e "  ${YELLOW}WARN${NC}  $name - not found (optional)"
+                warn_count=$((warn_count + 1))
+            fi
+            return 1
+        fi
+
+        local version=""
+        case "$cmd" in
+            node)
+                version=$(node --version 2>/dev/null | tr -d 'v')
+                ;;
+            python3)
+                version=$(python3 --version 2>/dev/null | awk '{print $2}')
+                ;;
+            git)
+                version=$(git --version 2>/dev/null | awk '{print $3}')
+                ;;
+            bash)
+                version=$("$cmd" --version 2>/dev/null | head -1 | sed 's/.*version \([0-9.]*\).*/\1/')
+                ;;
+            jq)
+                version=$(jq --version 2>/dev/null | tr -d 'jq-')
+                ;;
+            curl)
+                version=$(curl --version 2>/dev/null | head -1 | awk '{print $2}')
+                ;;
+            claude)
+                version=$(claude --version 2>/dev/null | head -1 | sed 's/[^0-9.]//g' | head -1)
+                ;;
+            codex)
+                version=$(codex --version 2>/dev/null | head -1 | sed 's/[^0-9.]//g' | head -1)
+                ;;
+            gemini)
+                version=$(gemini --version 2>/dev/null | head -1 | sed 's/[^0-9.]//g' | head -1)
+                ;;
+        esac
+
+        local version_display=""
+        if [ -n "$version" ]; then
+            version_display=" (v$version)"
+        fi
+
+        # Simple major version check if min_version is specified
+        if [ -n "$min_version" ] && [ -n "$version" ]; then
+            local cur_major cur_minor min_major min_minor
+            cur_major=$(echo "$version" | cut -d. -f1)
+            min_major=$(echo "$min_version" | cut -d. -f1)
+            cur_minor=$(echo "$version" | cut -d. -f2)
+            min_minor=$(echo "$min_version" | cut -d. -f2)
+
+            if [ "$cur_major" -lt "$min_major" ] 2>/dev/null || \
+               { [ "$cur_major" -eq "$min_major" ] 2>/dev/null && [ "$cur_minor" -lt "$min_minor" ] 2>/dev/null; }; then
+                if [ "$required" = "required" ]; then
+                    echo -e "  ${RED}FAIL${NC}  $name$version_display - requires >= $min_version"
+                    fail_count=$((fail_count + 1))
+                else
+                    echo -e "  ${YELLOW}WARN${NC}  $name$version_display - recommended >= $min_version"
+                    warn_count=$((warn_count + 1))
+                fi
+                return 1
+            fi
+        fi
+
+        echo -e "  ${GREEN}PASS${NC}  $name$version_display"
+        pass_count=$((pass_count + 1))
+        return 0
+    }
+
+    echo -e "${CYAN}Required:${NC}"
+    doctor_check "Node.js (>= 18)"    node     required    18.0
+    doctor_check "Python 3 (>= 3.8)"  python3  required    3.8
+    doctor_check "jq"                  jq       required
+    doctor_check "git"                 git      required
+    doctor_check "curl"                curl     required
+    echo ""
+
+    echo -e "${CYAN}AI Providers:${NC}"
+    doctor_check "Claude CLI"          claude   optional
+    doctor_check "Codex CLI"           codex    optional
+    doctor_check "Gemini CLI"          gemini   optional
+    echo ""
+
+    echo -e "${CYAN}System:${NC}"
+    doctor_check "bash (>= 4.0)"      bash     recommended  4.0
+
+    # Disk space check
+    local disk_avail
+    if command -v df &> /dev/null; then
+        # Get available space in GB (works on macOS and Linux)
+        disk_avail=$(df -g "$HOME" 2>/dev/null | tail -1 | awk '{print $4}')
+        if [ -z "$disk_avail" ]; then
+            # Linux fallback (df -g may not work)
+            disk_avail=$(df -BG "$HOME" 2>/dev/null | tail -1 | awk '{print $4}' | tr -d 'G')
+        fi
+        if [ -n "$disk_avail" ] && [ "$disk_avail" -gt 0 ] 2>/dev/null; then
+            if [ "$disk_avail" -lt 1 ]; then
+                echo -e "  ${RED}FAIL${NC}  Disk space: ${disk_avail}GB available (need >= 1GB)"
+                fail_count=$((fail_count + 1))
+            elif [ "$disk_avail" -lt 5 ]; then
+                echo -e "  ${YELLOW}WARN${NC}  Disk space: ${disk_avail}GB available (low)"
+                warn_count=$((warn_count + 1))
+            else
+                echo -e "  ${GREEN}PASS${NC}  Disk space: ${disk_avail}GB available"
+                pass_count=$((pass_count + 1))
+            fi
+        else
+            echo -e "  ${YELLOW}WARN${NC}  Disk space: unable to determine"
+            warn_count=$((warn_count + 1))
+        fi
+    fi
+    echo ""
+
+    # Summary
+    echo -e "${BOLD}Summary:${NC} ${GREEN}$pass_count passed${NC}, ${RED}$fail_count failed${NC}, ${YELLOW}$warn_count warnings${NC}"
+    echo ""
+
+    if [ "$fail_count" -gt 0 ]; then
+        echo -e "${RED}Some required prerequisites are missing.${NC}"
+        echo "Install missing dependencies and run 'loki doctor' again."
+        return 1
+    elif [ "$warn_count" -gt 0 ]; then
+        echo -e "${YELLOW}All required checks passed with some warnings.${NC}"
+        return 0
+    else
+        echo -e "${GREEN}All checks passed. System is ready for Loki Mode.${NC}"
+        return 0
+    fi
+}
+
+# JSON output for loki doctor --json
+cmd_doctor_json() {
+    python3 -c "
+import json, os, subprocess, sys, shutil
+
+def get_version(cmd, args=None):
+    try:
+        if args is None:
+            args = ['--version']
+        result = subprocess.run([cmd] + args, capture_output=True, text=True, timeout=5)
+        output = result.stdout.strip() or result.stderr.strip()
+        # Extract version number
+        import re
+        match = re.search(r'(\d+\.\d+[\.\d]*)', output)
+        return match.group(1) if match else None
+    except (FileNotFoundError, subprocess.TimeoutExpired, Exception):
+        return None
+
+def check_tool(name, cmd, required, min_version=None):
+    found = shutil.which(cmd) is not None
+    version = get_version(cmd) if found else None
+    status = 'pass'
+
+    if not found:
+        status = 'fail' if required == 'required' else 'warn'
+    elif min_version and version:
+        cur_parts = [int(x) for x in version.split('.')[:2]]
+        min_parts = [int(x) for x in min_version.split('.')[:2]]
+        while len(cur_parts) < 2: cur_parts.append(0)
+        while len(min_parts) < 2: min_parts.append(0)
+        if cur_parts < min_parts:
+            status = 'fail' if required == 'required' else 'warn'
+
+    return {
+        'name': name,
+        'command': cmd,
+        'found': found,
+        'version': version,
+        'required': required,
+        'min_version': min_version,
+        'status': status,
+        'path': shutil.which(cmd)
+    }
+
+checks = []
+checks.append(check_tool('Node.js', 'node', 'required', '18.0'))
+checks.append(check_tool('Python 3', 'python3', 'required', '3.8'))
+checks.append(check_tool('jq', 'jq', 'required'))
+checks.append(check_tool('git', 'git', 'required'))
+checks.append(check_tool('curl', 'curl', 'required'))
+checks.append(check_tool('bash', 'bash', 'recommended', '4.0'))
+checks.append(check_tool('Claude CLI', 'claude', 'optional'))
+checks.append(check_tool('Codex CLI', 'codex', 'optional'))
+checks.append(check_tool('Gemini CLI', 'gemini', 'optional'))
+
+# Disk space
+disk_gb = None
+try:
+    stat = os.statvfs(os.path.expanduser('~'))
+    disk_gb = round((stat.f_bavail * stat.f_frsize) / (1024**3), 1)
+except Exception:
+    pass
+
+disk_status = 'pass'
+if disk_gb is not None:
+    if disk_gb < 1:
+        disk_status = 'fail'
+    elif disk_gb < 5:
+        disk_status = 'warn'
+
+pass_count = sum(1 for c in checks if c['status'] == 'pass')
+fail_count = sum(1 for c in checks if c['status'] == 'fail')
+warn_count = sum(1 for c in checks if c['status'] == 'warn')
+
+if disk_status == 'pass': pass_count += 1
+elif disk_status == 'fail': fail_count += 1
+elif disk_status == 'warn': warn_count += 1
+
+result = {
+    'checks': checks,
+    'disk': {
+        'available_gb': disk_gb,
+        'status': disk_status
+    },
+    'summary': {
+        'passed': pass_count,
+        'failed': fail_count,
+        'warnings': warn_count,
+        'ok': fail_count == 0
+    }
+}
+
+print(json.dumps(result, indent=2))
+"
+}
+
 # Show version
 cmd_version() {
     echo "Loki Mode v$(get_version)"
@@ -3509,7 +3983,7 @@ main() {
             cmd_resume
             ;;
         status)
-            cmd_status
+            cmd_status "$@"
             ;;
         dashboard)
             cmd_dashboard "$@"
@@ -3565,9 +4039,15 @@ main() {
         voice)
             cmd_voice "$@"
             ;;
+        doctor)
+            cmd_doctor "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;
+	completions)
+            cmd_completions "$@"
+            ;;
         help|--help|-h)
             show_help
             ;;
@@ -3843,11 +4323,19 @@ for filename in ['patterns.jsonl', 'mistakes.jsonl', 'successes.jsonl']:
 
         clear)
             local type="${2:-}"
+            local confirm=""
 
             if [ -z "$type" ]; then
-                echo -e "${YELLOW}This will delete ALL cross-project learnings.${NC}"
-                echo -n "Are you sure? (yes/no): "
-                read -r confirm
+                # LOKI_AUTO_CONFIRM takes precedence when explicitly set;
+                # fall back to CI env var only when LOKI_AUTO_CONFIRM is unset
+                local _auto_confirm="${LOKI_AUTO_CONFIRM:-${CI:-false}}"
+                if [[ "$_auto_confirm" == "true" ]]; then
+                    confirm="yes"
+                else
+                    echo -e "${YELLOW}This will delete ALL cross-project learnings.${NC}"
+                    echo -n "Are you sure? (yes/no): "
+                    read -r confirm
+                fi
                 if [ "$confirm" = "yes" ]; then
                     rm -rf "$learnings_dir"
                     mkdir -p "$learnings_dir"
@@ -5888,4 +6376,54 @@ for line in sys.stdin:
     esac
 }
 
+# Output shell completion scripts
+cmd_completions() {
+    local shell="${1:-bash}"
+    local skill_dir
+    
+    # Find the skill directory (where autonomy/loki is located)
+    skill_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+    local completions_dir="$skill_dir/completions"
+    
+    case "$shell" in
+        bash)
+            if [ -f "$completions_dir/loki.bash" ]; then
+                cat "$completions_dir/loki.bash"
+            else
+                echo -e "${RED}Error: Bash completion script not found at $completions_dir/loki.bash${NC}" >&2
+                exit 1
+            fi
+            ;;
+        zsh)
+            if [ -f "$completions_dir/_loki" ]; then
+                cat "$completions_dir/_loki"
+            else
+                echo -e "${RED}Error: Zsh completion script not found at $completions_dir/_loki${NC}" >&2
+                exit 1
+            fi
+            ;;
+        *)
+            echo -e "${BOLD}Loki Shell Completions${NC}"
+            echo ""
+            echo "Output shell completion scripts for bash or zsh."
+            echo ""
+            echo "Usage: loki completions <shell>"
+            echo ""
+            echo "Shells:"
+            echo "  bash    Bash completion script"
+            echo "  zsh     Zsh completion script"
+            echo ""
+            echo "Installation:"
+            echo ""
+            echo "Bash:"
+            echo "  eval \"\$(loki completions bash)\" >> ~/.bashrc"
+            echo ""
+            echo "Zsh:"
+            echo "  eval \"\$(loki completions zsh)\" >> ~/.zshrc"
+            echo ""
+            exit 1
+            ;;
+    esac
+}
+
 main "$@"