loki-mode 5.29.0 → 5.31.0

package/README.md

@@ -82,8 +82,44 @@ jobs:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           mode: review          # review, fix, or test
           provider: claude      # claude, codex, or gemini
-          max_iterations: 3     # higher = more thorough
-          budget_limit: '5.00'  # max cost in USD
+          max_iterations: 3     # sets LOKI_MAX_ITERATIONS env var
+          budget_limit: '5.00'  # max cost in USD (maps to --budget flag)
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+```
+
+**Prerequisites:**
+- An API key for your chosen provider (set as a repository secret):
+  - Claude: `ANTHROPIC_API_KEY`
+  - Codex: `OPENAI_API_KEY`
+  - Gemini: `GOOGLE_API_KEY`
+- The action automatically installs `loki-mode` and `@anthropic-ai/claude-code` (for the Claude provider)
+
+**Action Inputs:**
+
+| Input | Default | Description |
+|-------|---------|-------------|
+| `mode` | `review` | `review`, `fix`, or `test` |
+| `provider` | `claude` | `claude`, `codex`, or `gemini` |
+| `budget_limit` | `5.00` | Max cost in USD (maps to `--budget` CLI flag) |
+| `budget` | | Alias for `budget_limit` |
+| `max_iterations` | `3` | Sets `LOKI_MAX_ITERATIONS` env var |
+| `github_token` | (required) | GitHub token for PR comments |
+| `prd_file` | | Path to PRD file relative to repo root |
+| `auto_confirm` | `true` | Skip confirmation prompts (always true in CI) |
+| `install_claude` | `true` | Auto-install Claude Code CLI if not present |
+| `node_version` | `20` | Node.js version |
+
+**Using with a PRD file (fix/test modes):**
+
+```yaml
+- uses: asklokesh/loki-mode@v5
+  with:
+    mode: fix
+    prd_file: 'docs/my-prd.md'
+    github_token: ${{ secrets.GITHUB_TOKEN }}
+  env:
+    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
 ```
 
 **Modes:**

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with zero human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v5.29.0
+# Loki Mode v5.31.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -62,7 +62,11 @@ REFLECT: Did it work? Update CONTINUITY.md with outcome.
    v
 VERIFY: Run tests. Check build. Validate against spec.
    |
-   +--[PASS]--> Mark task complete. Return to REASON.
+   +--[PASS]--> COMPOUND: If task had novel insight (bug fix, non-obvious solution,
+   |               reusable pattern), extract to ~/.loki/solutions/{category}/{slug}.md
+   |               with YAML frontmatter (title, tags, symptoms, root_cause, prevention).
+   |               See skills/compound-learning.md for format.
+   |               Then mark task complete. Return to REASON.
    |
    +--[FAIL]--> Capture error in "Mistakes & Learnings".
                Rollback if needed. Retry with new approach.
@@ -119,7 +123,8 @@ These rules are ABSOLUTE. Violating them is a critical failure.
 ```
 BOOTSTRAP ──[project initialized]──> DISCOVERY
 DISCOVERY ──[PRD analyzed, requirements clear]──> ARCHITECTURE
-ARCHITECTURE ──[design approved, specs written]──> INFRASTRUCTURE
+ARCHITECTURE ──[design approved, specs written]──> DEEPEN_PLAN (standard/complex only)
+DEEPEN_PLAN ──[plan enhanced by 4 research agents]──> INFRASTRUCTURE
 INFRASTRUCTURE ──[cloud/DB ready]──> DEVELOPMENT
 DEVELOPMENT ──[features complete, unit tests pass]──> QA
 QA ──[all tests pass, security clean]──> DEPLOYMENT
@@ -177,6 +182,8 @@ GROWTH ──[continuous improvement loop]──> GROWTH
    - Debugging? Load troubleshooting.md
    - Deploying? Load production.md
    - Parallel features? Load parallel-workflows.md
+   - Architecture planning? Load compound-learning.md (deepen-plan)
+   - Post-verification? Load compound-learning.md (knowledge extraction)
 3. Read the selected module(s)
 4. Execute with that context
 5. When task category changes: Load new modules (old context discarded)
@@ -260,4 +267,4 @@ Auto-detected or force with `LOKI_COMPLEXITY`:
 
 ---
 
-**v5.29.0 | Demo, quick mode, init, cost dashboard, 12 templates, GitHub Action | ~270 lines core**
+**v5.31.0 | Shell completions, GitHub Action enhancements, auto-confirm | ~280 lines core**

package/VERSION

@@ -1 +1 @@
-5.29.0
+5.31.0

package/autonomy/loki

@@ -317,7 +317,9 @@ 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)"
@@ -388,12 +390,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' to skip confirmation prompts"
+                echo "  CI                    When 'true', auto-confirms prompts"
+                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)
@@ -443,6 +455,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
@@ -476,19 +492,29 @@ 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
+        if [[ "${LOKI_AUTO_CONFIRM:-}" == "true" ]] || [[ "${CI:-}" == "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
 
@@ -3546,6 +3572,9 @@ main() {
         memory)
             cmd_memory "$@"
             ;;
+        compound)
+            cmd_compound "$@"
+            ;;
         council)
             cmd_council "$@"
             ;;
@@ -3564,6 +3593,9 @@ main() {
         version|--version|-v)
             cmd_version
             ;;
+	completions)
+            cmd_completions "$@"
+            ;;
         help|--help|-h)
             show_help
             ;;
@@ -3841,9 +3873,13 @@ for filename in ['patterns.jsonl', 'mistakes.jsonl', 'successes.jsonl']:
             local type="${2:-}"
 
             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
+                if [[ "${LOKI_AUTO_CONFIRM:-}" == "true" ]] || [[ "${CI:-}" == "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"
@@ -4541,6 +4577,282 @@ except Exception as e:
     esac
 }
 
+# Knowledge Compounding - Structured Solutions (v5.30.0)
+# Inspired by Compound Engineering Plugin's docs/solutions/ with YAML frontmatter
+cmd_compound() {
+    local subcommand="${1:-help}"
+    shift 2>/dev/null || true
+
+    local solutions_dir="${HOME}/.loki/solutions"
+
+    case "$subcommand" in
+        list|ls)
+            echo -e "${BOLD}Compound Solutions${NC}"
+            echo ""
+
+            if [ ! -d "$solutions_dir" ]; then
+                echo "  No solutions yet. Solutions are created automatically during"
+                echo "  Loki sessions or manually with 'loki compound run'."
+                echo ""
+                echo "  Location: $solutions_dir"
+                return
+            fi
+
+            local total=0
+            for category in security performance architecture testing debugging deployment general; do
+                local cat_dir="$solutions_dir/$category"
+                if [ -d "$cat_dir" ]; then
+                    local count=$(find "$cat_dir" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+                    if [ "$count" -gt 0 ]; then
+                        printf "  %-16s ${GREEN}%d${NC} solutions\n" "$category" "$count"
+                        total=$((total + count))
+                    fi
+                fi
+            done
+
+            if [ "$total" -eq 0 ]; then
+                echo "  No solutions yet."
+            else
+                echo ""
+                echo "  Total: ${total} solutions"
+            fi
+            echo ""
+            echo "  Location: $solutions_dir"
+            echo ""
+            echo "  Use 'loki compound show <category>' to view solutions"
+            ;;
+
+        show)
+            local category="${1:-}"
+            if [ -z "$category" ]; then
+                echo -e "${RED}Error: Specify a category${NC}"
+                echo "Categories: security, performance, architecture, testing, debugging, deployment, general"
+                return 1
+            fi
+
+            local cat_dir="$solutions_dir/$category"
+            if [ ! -d "$cat_dir" ]; then
+                echo "No solutions in category: $category"
+                return
+            fi
+
+            echo -e "${BOLD}Solutions: $category${NC}"
+            echo ""
+
+            for file in "$cat_dir"/*.md; do
+                [ -f "$file" ] || continue
+                # Extract title from YAML frontmatter
+                local title=$(grep '^title:' "$file" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                local confidence=$(grep '^confidence:' "$file" 2>/dev/null | head -1 | sed 's/confidence: *//')
+                local project=$(grep '^source_project:' "$file" 2>/dev/null | head -1 | sed 's/source_project: *"//;s/"$//')
+                echo -e "  ${GREEN}*${NC} ${title:-$(basename "$file" .md)}"
+                [ -n "$confidence" ] && echo -e "    confidence: ${confidence}  project: ${project:-unknown}"
+            done
+            echo ""
+            ;;
+
+        search)
+            local query="${1:-}"
+            if [ -z "$query" ]; then
+                echo -e "${RED}Error: Specify a search query${NC}"
+                echo "Usage: loki compound search <query>"
+                return 1
+            fi
+
+            echo -e "${BOLD}Searching solutions for: ${query}${NC}"
+            echo ""
+
+            if [ ! -d "$solutions_dir" ]; then
+                echo "No solutions directory found."
+                return
+            fi
+
+            local found=0
+            while IFS= read -r file; do
+                local title=$(grep '^title:' "$file" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                local category=$(grep '^category:' "$file" 2>/dev/null | head -1 | sed 's/category: *//')
+                echo -e "  [${CYAN}${category}${NC}] ${title:-$(basename "$file" .md)}"
+                echo -e "    ${DIM}${file}${NC}"
+                found=$((found + 1))
+            done < <(grep -rl "$query" "$solutions_dir" 2>/dev/null || true)
+
+            if [ "$found" -eq 0 ]; then
+                echo "  No solutions matching: $query"
+            else
+                echo ""
+                echo "  Found: ${found} solutions"
+            fi
+            ;;
+
+        run)
+            echo -e "${BOLD}Compounding learnings into solutions...${NC}"
+            echo ""
+
+            local learnings_dir="${HOME}/.loki/learnings"
+            if [ ! -d "$learnings_dir" ]; then
+                echo "  No learnings directory found at: $learnings_dir"
+                echo "  Run a Loki session first to generate learnings."
+                return
+            fi
+
+            python3 << 'COMPOUND_RUN_SCRIPT'
+import json, os, re
+from datetime import datetime, timezone
+from collections import defaultdict
+learnings_dir = os.path.expanduser("~/.loki/learnings")
+solutions_dir = os.path.expanduser("~/.loki/solutions")
+CATEGORIES = ["security", "performance", "architecture", "testing", "debugging", "deployment", "general"]
+CATEGORY_KEYWORDS = {
+    "security": ["auth", "login", "password", "token", "injection", "xss", "csrf", "cors", "secret", "encrypt", "permission"],
+    "performance": ["cache", "query", "n+1", "memory", "leak", "slow", "timeout", "pool", "index", "optimize", "bundle"],
+    "architecture": ["pattern", "solid", "coupling", "abstraction", "module", "interface", "design", "refactor", "structure"],
+    "testing": ["test", "mock", "fixture", "coverage", "assert", "spec", "e2e", "playwright", "jest", "flaky"],
+    "debugging": ["debug", "error", "trace", "log", "stack", "crash", "exception", "breakpoint", "inspect"],
+    "deployment": ["deploy", "docker", "ci", "cd", "pipeline", "kubernetes", "nginx", "ssl", "domain", "env", "config"],
+}
+def load_jsonl(filepath):
+    entries = []
+    if not os.path.exists(filepath): return entries
+    with open(filepath, 'r') as f:
+        for line in f:
+            try:
+                entry = json.loads(line)
+                if 'description' in entry: entries.append(entry)
+            except: continue
+    return entries
+def classify_category(description):
+    desc_lower = description.lower()
+    scores = {cat: sum(1 for kw in kws if kw in desc_lower) for cat, kws in CATEGORY_KEYWORDS.items()}
+    best = max(scores, key=scores.get)
+    return best if scores[best] > 0 else "general"
+def slugify(text):
+    return re.sub(r'[^a-z0-9]+', '-', text.lower().strip()).strip('-')[:80]
+def solution_exists(solutions_dir, title_slug):
+    for cat in CATEGORIES:
+        cat_dir = os.path.join(solutions_dir, cat)
+        if os.path.exists(cat_dir) and os.path.exists(os.path.join(cat_dir, f"{title_slug}.md")):
+            return True
+    return False
+patterns = load_jsonl(os.path.join(learnings_dir, "patterns.jsonl"))
+mistakes = load_jsonl(os.path.join(learnings_dir, "mistakes.jsonl"))
+successes = load_jsonl(os.path.join(learnings_dir, "successes.jsonl"))
+print(f"  Loaded: {len(patterns)} patterns, {len(mistakes)} mistakes, {len(successes)} successes")
+grouped = defaultdict(list)
+for entry in patterns + mistakes + successes:
+    grouped[classify_category(entry.get('description', ''))].append(entry)
+created = 0
+now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+for category, entries in grouped.items():
+    if len(entries) < 2: continue
+    cat_dir = os.path.join(solutions_dir, category)
+    os.makedirs(cat_dir, exist_ok=True)
+    best_entry = max(entries, key=lambda e: len(e.get('description', '')))
+    title = best_entry['description'][:120]
+    slug = slugify(title)
+    if solution_exists(solutions_dir, slug): continue
+    all_words = ' '.join(e.get('description', '') for e in entries).lower()
+    tags = []
+    for kw_list in CATEGORY_KEYWORDS.values():
+        for kw in kw_list:
+            if kw in all_words and kw not in tags: tags.append(kw)
+    tags = tags[:8]
+    symptoms = [e.get('description', '')[:200] for e in entries
+                if any(w in e.get('description', '').lower() for w in ['error', 'fail', 'bug', 'crash', 'issue'])][:4]
+    if not symptoms: symptoms = [entries[0].get('description', '')[:200]]
+    solution_lines = [f"- {e.get('description', '')}" for e in entries
+                      if not any(w in e.get('description', '').lower() for w in ['error', 'fail', 'bug', 'crash'])]
+    if not solution_lines: solution_lines = [f"- {entries[0].get('description', '')}"]
+    project = best_entry.get('project', os.path.basename(os.getcwd()))
+    filepath = os.path.join(cat_dir, f"{slug}.md")
+    with open(filepath, 'w') as f:
+        f.write(f"---\ntitle: \"{title}\"\ncategory: {category}\ntags: [{', '.join(tags)}]\nsymptoms:\n")
+        for s in symptoms: f.write(f'  - "{s}"\n')
+        f.write(f'root_cause: "Identified from {len(entries)} related learnings"\n')
+        f.write(f'prevention: "See solution details below"\nconfidence: {min(0.5 + 0.1 * len(entries), 0.95):.2f}\n')
+        f.write(f'source_project: "{project}"\ncreated: "{now}"\napplied_count: 0\n---\n\n')
+        f.write("## Solution\n\n" + '\n'.join(solution_lines) + '\n\n')
+        f.write(f"## Context\n\nCompounded from {len(entries)} learnings from project: {project}\n")
+    created += 1
+    print(f"  Created: {category}/{slug}.md")
+if created > 0: print(f"\n  Compounded {created} new solution files to {solutions_dir}")
+else: print("  No new solutions to compound (need 2+ related learnings per category)")
+COMPOUND_RUN_SCRIPT
+            ;;
+
+        stats)
+            echo -e "${BOLD}Compound Solution Statistics${NC}"
+            echo ""
+
+            if [ ! -d "$solutions_dir" ]; then
+                echo "  No solutions directory found."
+                return
+            fi
+
+            local total=0
+            local newest=""
+            local oldest=""
+
+            for category in security performance architecture testing debugging deployment general; do
+                local cat_dir="$solutions_dir/$category"
+                if [ -d "$cat_dir" ]; then
+                    local count=$(find "$cat_dir" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+                    total=$((total + count))
+                fi
+            done
+
+            echo "  Total solutions: ${total}"
+
+            if [ "$total" -gt 0 ]; then
+                # Find newest and oldest
+                newest=$(find "$solutions_dir" -name "*.md" -exec stat -f '%m %N' {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-)
+                oldest=$(find "$solutions_dir" -name "*.md" -exec stat -f '%m %N' {} \; 2>/dev/null | sort -n | head -1 | cut -d' ' -f2-)
+
+                if [ -n "$newest" ]; then
+                    local newest_title=$(grep '^title:' "$newest" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                    echo "  Newest: ${newest_title:-$(basename "$newest" .md)}"
+                fi
+                if [ -n "$oldest" ]; then
+                    local oldest_title=$(grep '^title:' "$oldest" 2>/dev/null | head -1 | sed 's/title: *"//;s/"$//')
+                    echo "  Oldest: ${oldest_title:-$(basename "$oldest" .md)}"
+                fi
+            fi
+
+            echo ""
+            echo "  Location: $solutions_dir"
+            ;;
+
+        help|--help|-h)
+            echo -e "${BOLD}loki compound${NC} - Knowledge compounding system"
+            echo ""
+            echo "Extracts structured solutions from cross-project learnings."
+            echo "Solutions are stored as markdown files with YAML frontmatter"
+            echo "at ~/.loki/solutions/{category}/ and fed back into future planning."
+            echo ""
+            echo "Usage: loki compound <command>"
+            echo ""
+            echo "Commands:"
+            echo "  list              List all solutions by category"
+            echo "  show <category>   Show solutions in a category"
+            echo "  search <query>    Search across all solutions"
+            echo "  run               Manually compound current learnings into solutions"
+            echo "  stats             Solution statistics"
+            echo "  help              Show this help"
+            echo ""
+            echo "Categories: security, performance, architecture, testing,"
+            echo "            debugging, deployment, general"
+            echo ""
+            echo "Solutions are created automatically at session end and"
+            echo "loaded during the REASON phase for relevant tasks."
+            ;;
+
+        *)
+            echo -e "${RED}Unknown compound command: $subcommand${NC}"
+            echo "Run 'loki compound help' for usage."
+            return 1
+            ;;
+    esac
+}
+
 # Completion Council management
 cmd_council() {
     local subcommand="${1:-status}"
@@ -5608,4 +5920,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 "$@"