claude-all-config 3.6.4 → 3.7.1

package/CLAUDE.md

@@ -61,7 +61,7 @@ Use Task tool with these agent types:
 - `cost-watchdog` - Cloud bill monitoring, anomaly detection, savings recommendations
 - `learning-loop` - After each task, extract lessons + persist to memory MCP
 
-### Skills (63)
+### Skills (82)
 Located in `~/.claude/skills/`. Use Skill tool to invoke. Highlights:
 - `systematic-debugging`, `root-cause-tracing` (used by debugger agent)
 - `tech-debt-hunter`, `code-refactoring` (used by refactor-master)

package/VERSION

@@ -1 +1 @@
-3.6.4
+3.7.1

package/gemini-all

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+#
+# gemini-all — Gemini CLI launcher with ClaudeAll superpowers loaded.
+#
+# What it does:
+#   1. Source ~/.gemini/.env (and ~/.claude/.env as fallback) so MCP servers
+#      see your CONTEXT7_API_KEY / EXA_API_KEY / Z_AI_API_KEY / etc.
+#   2. Default to YOLO mode (--yolo / -y) for autonomous operation.
+#   3. Pass through all args to gemini.
+#
+# Usage:
+#   gemini-all                     # interactive YOLO session
+#   gemini-all "your prompt"       # one-shot with prompt
+#   gemini-all --no-yolo           # disable auto-approve
+#   gemini-all -y -- ...           # explicit YOLO with extra args
+#
+# Override with env vars:
+#   GEMINI_BIN=/path/to/gemini gemini-all
+#   GEMINI_NO_YOLO=1 gemini-all      # disable yolo for this run
+
+set -u
+
+# ─── Source env files (most-specific first) ───────────────────────────────
+load_env() {
+    local f="$1"
+    if [ -f "$f" ]; then
+        set -a
+        # shellcheck disable=SC1090
+        . "$f" 2>/dev/null || true
+        set +a
+    fi
+}
+
+# Gemini-specific overrides take precedence over the shared Claude env.
+load_env "$HOME/.claude/.env"
+load_env "$HOME/.gemini/.env"
+
+# ─── Locate gemini binary ─────────────────────────────────────────────────
+GEMINI_CMD="${GEMINI_BIN:-gemini}"
+if ! command -v "$GEMINI_CMD" &>/dev/null; then
+    echo "❌ gemini CLI not found in PATH." >&2
+    echo "   Install: npm install -g @google/gemini-cli" >&2
+    echo "   Or set GEMINI_BIN=/path/to/gemini" >&2
+    exit 127
+fi
+
+# ─── YOLO mode (default ON, opt-out with --no-yolo or GEMINI_NO_YOLO=1) ────
+YOLO_FLAG="--yolo"
+ARGS=()
+for a in "$@"; do
+    case "$a" in
+        --no-yolo)        YOLO_FLAG="" ;;
+        -y|--yolo)        YOLO_FLAG="--yolo" ;;
+        *)                ARGS+=("$a") ;;
+    esac
+done
+[ -n "${GEMINI_NO_YOLO:-}" ] && YOLO_FLAG=""
+
+# ─── Show what we loaded (only when verbose) ──────────────────────────────
+if [ -n "${GEMINI_ALL_VERBOSE:-}" ]; then
+    echo "🤖 gemini-all"
+    echo "   Binary:  $(command -v "$GEMINI_CMD")"
+    echo "   YOLO:    ${YOLO_FLAG:-OFF}"
+    echo "   Env:    $(printenv | grep -cE '^(CONTEXT7|EXA|Z_AI|MINIMAX|TELEGRAM)_') vars loaded"
+fi
+
+# ─── Exec ─────────────────────────────────────────────────────────────────
+if [ -n "$YOLO_FLAG" ]; then
+    exec "$GEMINI_CMD" "$YOLO_FLAG" "${ARGS[@]}"
+else
+    exec "$GEMINI_CMD" "${ARGS[@]}"
+fi

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "claude-all-config",
-  "version": "3.6.4",
+  "version": "3.7.1",
   "description": "🦾 MONSTER ENGINEER v2 - Ultimate AI CLI with 63 Skills, 12 Superpowers, 14 Agents. Multi-Agent Orchestration, Cost-Aware, Security Scorecard, Parallel-First.",
   "main": "index.js",
   "bin": {
     "claude-all": "./claude-all",
     "claude-all-skills": "./bin/skills-cli.js",
     "claude-all-update": "./update.sh",
-    "claude-all-mcp": "./bin/mcp-install.js"
+    "claude-all-mcp": "./bin/mcp-install.js",
+    "gemini-all": "./gemini-all"
   },
   "scripts": {
     "postinstall": "node postinstall.js || bash install.sh",
@@ -86,6 +87,7 @@
     "AGENT.md",
     "CLAUDE.md",
     "claude-all",
+    "gemini-all",
     "install.sh",
     "install-termux.sh",
     "install-universal.sh",
@@ -121,7 +123,7 @@
       "codex",
       "trae"
     ],
-    "skillsCount": 67,
+    "skillsCount": 82,
     "agentsCount": 22,
     "commandsCount": 3
   },

package/postinstall.js

@@ -278,46 +278,48 @@ function installGemini() {
   const mcpSrc = path.join(PKG_DIR, 'mcp.json');
   const mcpDest = path.join(GEMINI_DIR, 'mcp.json');
   if (fs.existsSync(mcpSrc)) {
-    fs.copyFileSync(mcpSrc, mcpDest);
-    fs.chmodSync(mcpDest, 0o600);
-    console.log(`   🔧 MCP config (7 servers)`);
+    try {
+      fs.copyFileSync(mcpSrc, mcpDest);
+      try { fs.chmodSync(mcpDest, 0o600); } catch {}
+      console.log(`   🔧 MCP config (11 servers)`);
+    } catch (e) {
+      console.log(`   ⚠️  MCP config skipped (${e.code || 'error'})`);
+    }
   }
 
-  // GEMINI.md - Global instructions (like CLAUDE.md)
-  const geminiMd = `# Gemini Superpowers - MONSTER ENGINEER Mode
-
-You are **MONSTER ENGINEER** - Gemini CLI enhanced with ClaudeAll superpowers.
-
-## 👑 Identity: Raja Terakhir (Ultimate Technical Authority)
-
-You are expert-level in ALL engineering disciplines:
-- **Software Engineer** - Architecture, design patterns, clean code, all languages
-- **Security Engineer** - Pentesting, hardening, zero-trust, vulnerability assessment
-- **DevOps Engineer** - CI/CD, Docker, Kubernetes, infrastructure as code
-- **Backend Engineer** - Go, Node.js, Python, Rust, APIs, microservices
-- **Frontend Engineer** - React, Svelte, Vue, TypeScript, mobile
-- **Cloud Architect** - AWS, GCP, Azure, Oracle, Cloudflare
-- **Database Admin** - PostgreSQL, MySQL, Redis, MongoDB, optimization
-- **Network Engineer** - VPN, firewalls, DNS, tunnels, load balancing
-- **SRE** - Monitoring, alerting, incident response, chaos engineering
-- **Mobile Developer** - Flutter, Swift (iOS), Kotlin (Android)
-
-## Behavior
-1. **ULTRA Proactive** - Work autonomously, never ask permission
-2. **Direct Execution** - Run commands directly
-3. **Security First** - Never expose credentials, always use Unix sockets over ports
-4. **Expert Authority** - Make technical decisions confidently
-
-## Available
-- 14 Agents (proactive-mode, code-generator, security-auditor, etc)
-- 63 Skills (systematic-debugging, test-driven-development, etc)
-- 7 MCP Servers (context7, exa, memory, filesystem, fetch, etc)
-
-## Usage
-Run with YOLO mode: gemini -y
-`;
-  fs.writeFileSync(path.join(GEMINI_DIR, 'GEMINI.md'), geminiMd);
-  console.log(`   📄 GEMINI.md (MONSTER ENGINEER mode)`);
+  // .env template for Gemini (same secrets as Claude)
+  const envSrc = path.join(PKG_DIR, '.env.example');
+  const envDest = path.join(GEMINI_DIR, '.env');
+  if (fs.existsSync(envSrc) && !fs.existsSync(envDest)) {
+    try {
+      fs.copyFileSync(envSrc, envDest);
+      try { fs.chmodSync(envDest, 0o600); } catch {}
+      console.log(`   🔐 .env template (edit ~/.gemini/.env to set your API keys)`);
+    } catch (e) {
+      console.log(`   ⚠️  .env template skipped (${e.code || 'error'})`);
+    }
+  } else if (fs.existsSync(envDest)) {
+    console.log(`   🔐 .env preserved (already exists)`);
+  }
+
+  // GEMINI.md - kept in sync with CLAUDE.md (read from package, not hardcoded)
+  const claudeMdInPkg = path.join(PKG_DIR, 'CLAUDE.md');
+  const geminiMdDest = path.join(GEMINI_DIR, 'GEMINI.md');
+  if (fs.existsSync(claudeMdInPkg)) {
+    try {
+      // Re-title CLAUDE → GEMINI but keep all content (single source of truth)
+      let content = fs.readFileSync(claudeMdInPkg, 'utf8');
+      content = content
+        .replace(/# ClaudeAll Global Instructions/, '# Gemini Superpowers (ClaudeAll Global Instructions)')
+        .replace(/Claude Code enhanced with ClaudeAll superpowers\./, 'Gemini CLI enhanced with ClaudeAll superpowers.\n\n**YOLO mode**: run `gemini -y` to auto-approve tool calls (configured in settings.json).')
+        .replace(/~\/\.claude\//g, '~/.gemini/')
+        .replace(/CLAUDE\.md/g, 'GEMINI.md');
+      fs.writeFileSync(geminiMdDest, content);
+      console.log(`   📄 GEMINI.md (synced from CLAUDE.md, ${content.split('\n').length} lines)`);
+    } catch (e) {
+      console.log(`   ⚠️  GEMINI.md write skipped (${e.code || 'error'})`);
+    }
+  }
 
   // Settings.json with auto-approve tools + persona
   const geminiSettings = {
@@ -393,6 +395,7 @@ function setupLocalBinSymlinks() {
     'claude-all-skills':  path.join(PKG_DIR, 'bin', 'skills-cli.js'),
     'claude-all-mcp':     path.join(PKG_DIR, 'bin', 'mcp-install.js'),
     'claude-all-update':  path.join(PKG_DIR, 'update.sh'),
+    'gemini-all':         path.join(PKG_DIR, 'gemini-all'),
   };
 
   let created = 0;

package/skills/ATTRIBUTION.md

@@ -0,0 +1,35 @@
+# Skill Attribution
+
+The following skills are adopted from
+[alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills)
+under the MIT License (Copyright © Alireza Rezvani and contributors):
+
+## Adopted in v3.7.0
+
+### Tier S (AI / Ops / Security)
+- `rag-architect` — RAG pipeline design + retrieval optimization
+- `llm-cost-optimizer` — Token cost engineering, model routing, caching
+- `prompt-governance` — Production prompt versioning, A/B testing, evals
+- `chaos-engineering` — Fault injection, blast-radius bounding, gameday
+- `observability-designer` — OpenTelemetry traces / metrics / logs design
+- `threat-detection` — Detection engineering, SIEM rules, IoC patterns
+
+### Tier A (Engineering Breadth)
+- `kubernetes-operator` — K8s ops, debugging, custom operators
+- `terraform-patterns` — Infrastructure-as-code patterns library
+- `playwright-pro` — Browser automation + E2E testing
+- `incident-response` — DFIR / digital forensics & incident response
+- `data-quality-auditor` — Data pipeline integrity checks
+- `migration-architect` — Multi-system migration strategy
+- `stress-test` — Load and performance testing
+- `agent-workflow-designer` — Multi-agent workflow design
+- `api-design-reviewer` — REST/GraphQL API contract review
+
+## License
+
+These skills retain their original MIT license. Their original copyright
+notice and attribution headers are preserved in each SKILL.md frontmatter
+where present.
+
+Original repository: https://github.com/alirezarezvani/claude-skills
+Original author: Alireza Rezvani (https://github.com/alirezarezvani)

package/skills/agent-workflow-designer/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: "agent-workflow-designer"
+description: "Agent Workflow Designer"
+---
+
+# Agent Workflow Designer
+
+**Tier:** POWERFUL  
+**Category:** Engineering  
+**Domain:** Multi-Agent Systems / AI Orchestration
+
+---
+
+## Overview
+
+Design production-grade multi-agent workflows with clear pattern choice, handoff contracts, failure handling, and cost/context controls.
+
+## Core Capabilities
+
+- Workflow pattern selection for multi-step agent systems
+- Skeleton config generation for fast workflow bootstrapping
+- Context and cost discipline across long-running flows
+- Error recovery and retry strategy scaffolding
+- Documentation pointers for operational pattern tradeoffs
+
+---
+
+## When to Use
+
+- A single prompt is insufficient for task complexity
+- You need specialist agents with explicit boundaries
+- You want deterministic workflow structure before implementation
+- You need validation loops for quality or safety gates
+
+---
+
+## Quick Start
+
+```bash
+# Generate a sequential workflow skeleton
+python3 scripts/workflow_scaffolder.py sequential --name content-pipeline
+
+# Generate an orchestrator workflow and save it
+python3 scripts/workflow_scaffolder.py orchestrator --name incident-triage --output workflows/incident-triage.json
+```
+
+---
+
+## Pattern Map
+
+- `sequential`: strict step-by-step dependency chain
+- `parallel`: fan-out/fan-in for independent subtasks
+- `router`: dispatch by intent/type with fallback
+- `orchestrator`: planner coordinates specialists with dependencies
+- `evaluator`: generator + quality gate loop
+
+Detailed templates: `references/workflow-patterns.md`
+
+---
+
+## Recommended Workflow
+
+1. Select pattern based on dependency shape and risk profile.
+2. Scaffold config via `scripts/workflow_scaffolder.py`.
+3. Define handoff contract fields for every edge.
+4. Add retry/timeouts and output validation gates.
+5. Dry-run with small context budgets before scaling.
+
+---
+
+## Common Pitfalls
+
+- Over-orchestrating tasks solvable by one well-structured prompt
+- Missing timeout/retry policies for external-model calls
+- Passing full upstream context instead of targeted artifacts
+- Ignoring per-step cost accumulation
+
+## Best Practices
+
+1. Start with the smallest pattern that can satisfy requirements.
+2. Keep handoff payloads explicit and bounded.
+3. Validate intermediate outputs before fan-in synthesis.
+4. Enforce budget and timeout limits in every step.

package/skills/agent-workflow-designer/references/workflow-patterns.md

@@ -0,0 +1,82 @@
+# Workflow Pattern Templates
+
+## Sequential
+
+Use when each step depends on prior output.
+
+```json
+{
+  "pattern": "sequential",
+  "steps": ["research", "draft", "review"]
+}
+```
+
+## Parallel
+
+Use when independent tasks can fan out and then fan in.
+
+```json
+{
+  "pattern": "parallel",
+  "fan_out": ["task_a", "task_b", "task_c"],
+  "fan_in": "synthesizer"
+}
+```
+
+## Router
+
+Use when tasks must be routed to specialized handlers by intent.
+
+```json
+{
+  "pattern": "router",
+  "router": "intent_router",
+  "routes": ["sales", "support", "engineering"],
+  "fallback": "generalist"
+}
+```
+
+## Orchestrator
+
+Use when dynamic planning and dependency management are required.
+
+```json
+{
+  "pattern": "orchestrator",
+  "orchestrator": "planner",
+  "specialists": ["researcher", "analyst", "coder"],
+  "dependency_mode": "dag"
+}
+```
+
+## Evaluator
+
+Use when output quality gates are mandatory before finalization.
+
+```json
+{
+  "pattern": "evaluator",
+  "generator": "content_agent",
+  "evaluator": "quality_agent",
+  "max_iterations": 3,
+  "pass_threshold": 0.8
+}
+```
+
+## Pattern Selection Heuristics
+
+- Choose `sequential` for strict linear workflows.
+- Choose `parallel` for throughput and latency reduction.
+- Choose `router` for intent- or type-based branching.
+- Choose `orchestrator` for complex adaptive workflows.
+- Choose `evaluator` when correctness/quality loops are required.
+
+## Handoff Minimum Contract
+
+- `workflow_id`
+- `step_id`
+- `task`
+- `constraints`
+- `upstream_artifacts`
+- `budget_tokens`
+- `timeout_seconds`

package/skills/agent-workflow-designer/scripts/workflow_scaffolder.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Generate workflow skeleton configs from common multi-agent patterns."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Dict, List
+
+
+def sequential_template(name: str) -> Dict:
+    return {
+        "name": name,
+        "pattern": "sequential",
+        "steps": [
+            {"id": "research", "agent": "researcher", "next": "draft"},
+            {"id": "draft", "agent": "writer", "next": "review"},
+            {"id": "review", "agent": "reviewer", "next": None},
+        ],
+        "retry": {"max_attempts": 2, "backoff_seconds": 2},
+    }
+
+
+def parallel_template(name: str) -> Dict:
+    return {
+        "name": name,
+        "pattern": "parallel",
+        "fan_out": {
+            "tasks": ["research_a", "research_b", "research_c"],
+            "agent": "analyst",
+        },
+        "fan_in": {"agent": "synthesizer", "output": "combined_report"},
+        "timeouts": {"per_task_seconds": 180, "fan_in_seconds": 120},
+    }
+
+
+def router_template(name: str) -> Dict:
+    return {
+        "name": name,
+        "pattern": "router",
+        "router": {"agent": "router", "routes": ["sales", "support", "engineering"]},
+        "handlers": {
+            "sales": {"agent": "sales_specialist"},
+            "support": {"agent": "support_specialist"},
+            "engineering": {"agent": "engineering_specialist"},
+        },
+        "fallback": {"agent": "generalist"},
+    }
+
+
+def orchestrator_template(name: str) -> Dict:
+    return {
+        "name": name,
+        "pattern": "orchestrator",
+        "orchestrator": {"agent": "orchestrator", "planning": "dynamic"},
+        "specialists": ["researcher", "coder", "analyst", "writer"],
+        "execution": {
+            "dependency_mode": "dag",
+            "max_parallel": 3,
+            "completion_policy": "all_required",
+        },
+    }
+
+
+def evaluator_template(name: str) -> Dict:
+    return {
+        "name": name,
+        "pattern": "evaluator",
+        "generator": {"agent": "generator"},
+        "evaluator": {"agent": "evaluator", "criteria": ["accuracy", "format", "safety"]},
+        "loop": {
+            "max_iterations": 3,
+            "pass_threshold": 0.8,
+            "on_fail": "revise_and_retry",
+        },
+    }
+
+
+PATTERNS = {
+    "sequential": sequential_template,
+    "parallel": parallel_template,
+    "router": router_template,
+    "orchestrator": orchestrator_template,
+    "evaluator": evaluator_template,
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Generate a workflow skeleton config from a pattern.")
+    parser.add_argument("pattern", choices=sorted(PATTERNS.keys()), help="Workflow pattern")
+    parser.add_argument("--name", default="new-workflow", help="Workflow name")
+    parser.add_argument("--output", help="Optional output path for JSON config")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    config = PATTERNS[args.pattern](args.name)
+    payload = json.dumps(config, indent=2)
+
+    if args.output:
+        out = Path(args.output)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(payload + "\n", encoding="utf-8")
+        print(f"Wrote workflow config to {out}")
+    else:
+        print(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())