loki-mode 5.28.1 → 5.30.0

package/README.md

@@ -6,6 +6,7 @@
 [![npm downloads](https://img.shields.io/npm/dw/loki-mode)](https://www.npmjs.com/package/loki-mode)
 [![GitHub stars](https://img.shields.io/github/stars/asklokesh/loki-mode)](https://github.com/asklokesh/loki-mode)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub Marketplace](https://img.shields.io/badge/Marketplace-Loki%20Mode-purple?logo=github)](https://github.com/marketplace/actions/loki-mode-code-review)
 [![Claude Code](https://img.shields.io/badge/Claude-Code-orange)](https://claude.ai)
 [![Agent Types](https://img.shields.io/badge/Agent%20Types-41-blue)]()
 [![Loki Mode](https://img.shields.io/badge/Loki%20Mode-98.78%25%20Pass%401-blueviolet)](benchmarks/results/)
@@ -55,7 +56,45 @@ claude --dangerously-skip-permissions
 # Then say: Loki Mode with PRD at ./my-prd.md
 ```
 
-Also available via **Homebrew**, **Docker**, **VS Code Extension**, and **direct shell script**. See the [Installation Guide](docs/INSTALLATION.md) for all 6 installation methods and detailed instructions.
+### Option 3: GitHub Action
+
+Add automated AI code review to your pull requests:
+
+```yaml
+# .github/workflows/loki-review.yml
+name: Loki Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: asklokesh/loki-mode@v5
+        with:
+          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
+```
+
+**Modes:**
+
+| Mode | Description |
+|------|-------------|
+| `review` | Analyze PR diff, post structured review as PR comment |
+| `fix` | Automatically fix issues found in the codebase |
+| `test` | Run autonomous test generation and validation |
+
+Also available via **Homebrew**, **Docker**, **VS Code Extension**, and **direct shell script**. See the [Installation Guide](docs/INSTALLATION.md) for all 7 installation methods and detailed instructions.
 
 ### Multi-Provider Support (v5.0.0)
 

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.28.1
+# Loki Mode v5.30.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.28.1 | Demo, quick mode, init, cost dashboard, 12 templates, GitHub Action | ~270 lines core**
+**v5.30.0 | Compound learning, specialist reviewers, deepen-plan | ~280 lines core**

package/VERSION

@@ -1 +1 @@
-5.28.1
+5.30.0

package/autonomy/loki

@@ -318,6 +318,7 @@ show_help() {
     echo "  import           Import GitHub issues as tasks"
     echo "  config [cmd]     Manage configuration (show|init|edit|path)"
     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)"
@@ -506,33 +507,14 @@ cmd_start() {
     local effective_provider="${provider:-${LOKI_PROVIDER:-claude}}"
 
     # Handle sandbox mode - delegate to sandbox.sh
-    # Skip if we're already inside a container (/.dockerenv exists)
-    if [[ "${LOKI_SANDBOX_MODE:-}" == "true" ]] && [[ ! -f /.dockerenv ]]; then
+    # Skip if we're already inside a sandbox (IS_SANDBOX=1 or /.dockerenv exists)
+    if [[ "${LOKI_SANDBOX_MODE:-}" == "true" ]] && [[ "${IS_SANDBOX:-}" != "1" ]] && [[ ! -f /.dockerenv ]]; then
         if [ ! -f "$SANDBOX_SH" ]; then
             echo -e "${RED}Error: sandbox.sh not found at $SANDBOX_SH${NC}"
             exit 1
         fi
 
-        # Check Docker availability
-        if ! command -v docker &> /dev/null; then
-            echo -e "${RED}Error: Docker not found${NC}"
-            echo ""
-            echo "Docker is required for sandbox mode. Install it:"
-            echo "  macOS:  brew install --cask docker"
-            echo "  Linux:  curl -fsSL https://get.docker.com | sh"
-            exit 1
-        fi
-
-        if ! docker info &> /dev/null 2>&1; then
-            echo -e "${RED}Error: Docker daemon not running${NC}"
-            echo ""
-            echo "Start Docker:"
-            echo "  macOS:  Open Docker Desktop app"
-            echo "  Linux:  sudo systemctl start docker"
-            exit 1
-        fi
-
-        echo -e "${GREEN}Starting Loki Mode in Docker sandbox...${NC}"
+        echo -e "${GREEN}Starting Loki Mode in sandbox...${NC}"
         # Load memory context before sandbox start (errors don't block startup)
         load_memory_context "$prd_file" || true
         emit_event session cli start "provider=$effective_provider" "sandbox=true" "prd_path=${prd_file:-}"
@@ -2795,6 +2777,7 @@ broadcast_notification() {
 }
 
 # Sandbox management (delegates to sandbox.sh)
+# sandbox.sh handles detection: Docker Desktop Sandbox > Docker Container > Worktree
 cmd_sandbox() {
     local subcommand="${1:-help}"
     shift || true
@@ -2805,28 +2788,7 @@ cmd_sandbox() {
         exit 1
     fi
 
-    # Check Docker availability
-    if ! command -v docker &> /dev/null; then
-        echo -e "${RED}Error: Docker not found${NC}"
-        echo ""
-        echo "Docker is required for sandbox mode. Install it:"
-        echo "  macOS:  brew install --cask docker"
-        echo "  Linux:  curl -fsSL https://get.docker.com | sh"
-        echo ""
-        echo "After installation, start Docker Desktop or the Docker daemon."
-        exit 1
-    fi
-
-    if ! docker info &> /dev/null 2>&1; then
-        echo -e "${RED}Error: Docker daemon not running${NC}"
-        echo ""
-        echo "Start Docker:"
-        echo "  macOS:  Open Docker Desktop app"
-        echo "  Linux:  sudo systemctl start docker"
-        exit 1
-    fi
-
-    # Delegate to sandbox.sh
+    # Delegate to sandbox.sh (it handles Docker/worktree detection internally)
     exec "$SANDBOX_SH" "$subcommand" "$@"
 }
 
@@ -3585,6 +3547,9 @@ main() {
         memory)
             cmd_memory "$@"
             ;;
+        compound)
+            cmd_compound "$@"
+            ;;
         council)
             cmd_council "$@"
             ;;
@@ -4580,6 +4545,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}"