ai-consultants 2.10.1

package/scripts/query_claude.sh

@@ -0,0 +1,99 @@
+#!/bin/bash
+# query_claude.sh - Query Claude CLI or API
+#
+# Usage: ./query_claude.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   CLAUDE_MODEL - Model to use (default: opus-4.6)
+#   CLAUDE_TIMEOUT - Timeout in seconds (default: 240)
+#   CLAUDE_USE_API - Use API mode instead of CLI (default: false)
+#   ANTHROPIC_API_KEY - API key for API mode
+#   ENABLE_PERSONA - Enable "The Synthesizer" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+source "$SCRIPT_DIR/lib/personas.sh"
+
+# --- Parameters ---
+QUERY="${1:-}"
+CONTEXT_FILE="${2:-}"
+OUTPUT_FILE="${3:-/tmp/claude_response.json}"
+
+# --- Configuration ---
+ENABLE_PERSONA="${ENABLE_PERSONA:-true}"
+CONSULTANT_NAME="Claude"
+CLAUDE_CMD="${CLAUDE_CMD:-claude}"
+MODEL_USED="${CLAUDE_MODEL:-opus-4.6}"
+
+# --- Build query ---
+FULL_QUERY=$(build_full_query "$QUERY" "$CONTEXT_FILE")
+validate_query "$FULL_QUERY" "Claude" || exit 1
+
+# --- Add persona if enabled ---
+if [[ "$ENABLE_PERSONA" == "true" ]]; then
+    FULL_QUERY=$(build_query_with_persona "$CONSULTANT_NAME" "$FULL_QUERY")
+fi
+
+# --- Timestamp for metadata ---
+START_TIME=$(get_timestamp_ms)
+
+# --- Execution (CLI or API mode) ---
+TEMP_OUTPUT=$(mktemp)
+
+if is_api_mode "claude"; then
+    # --- API Mode ---
+    log_api_mode_status "claude"
+    validate_api_mode "claude" || exit 1
+
+    source "$SCRIPT_DIR/lib/api_query.sh"
+
+    run_api_mode_query \
+        "$CONSULTANT_NAME" \
+        "$MODEL_USED" \
+        "$FULL_QUERY" \
+        "$TEMP_OUTPUT" \
+        "$CLAUDE_TIMEOUT_SECONDS"
+
+    exit_code=$?
+else
+    # --- CLI Mode ---
+    log_api_mode_status "claude"
+    check_command "$CLAUDE_CMD" "Claude CLI" "Visit https://docs.anthropic.com/en/docs/claude-code" || exit 1
+
+    # Claude CLI uses --print for non-interactive mode
+    echo "$FULL_QUERY" | run_query \
+        "Claude" \
+        "$TEMP_OUTPUT" \
+        "$CLAUDE_TIMEOUT_SECONDS" \
+        "$CLAUDE_CMD" --print --model "$MODEL_USED"
+
+    exit_code=$?
+fi
+
+# --- Calculate latency ---
+END_TIME=$(get_timestamp_ms)
+LATENCY_MS=$((END_TIME - START_TIME))
+
+# --- Configuration for response building ---
+PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
+
+# --- Post-processing: wrap in full schema using shared helpers ---
+if [[ $exit_code -eq 0 && -f "$TEMP_OUTPUT" && -s "$TEMP_OUTPUT" ]]; then
+    RAW_RESPONSE=$(cat "$TEMP_OUTPUT")
+    rm -f "$TEMP_OUTPUT"
+
+    # Try to parse as structured JSON
+    if echo "$RAW_RESPONSE" | jq -e '.response.summary' > /dev/null 2>&1; then
+        build_structured_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" "$RAW_RESPONSE" "$LATENCY_MS" > "$OUTPUT_FILE"
+    else
+        build_fallback_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" "$RAW_RESPONSE" "$LATENCY_MS" > "$OUTPUT_FILE"
+    fi
+else
+    rm -f "$TEMP_OUTPUT"
+    build_error_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" "Query failed with exit code $exit_code" "$LATENCY_MS" > "$OUTPUT_FILE"
+fi
+
+cat "$OUTPUT_FILE"
+exit $exit_code

package/scripts/query_codex.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+# query_codex.sh - Query OpenAI Codex CLI or API (v2.6 with API mode support)
+#
+# Usage: ./query_codex.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   CODEX_MODEL - Model to use (default: gpt-5.3-codex)
+#   CODEX_TIMEOUT - Timeout in seconds (default: 180)
+#   CODEX_USE_API - Use API mode instead of CLI (default: false)
+#   OPENAI_API_KEY - API key for API mode
+#   ENABLE_PERSONA - Enable "The Pragmatist" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+source "$SCRIPT_DIR/lib/personas.sh"
+
+# --- Parameters ---
+QUERY="${1:-}"
+CONTEXT_FILE="${2:-}"
+OUTPUT_FILE="${3:-/tmp/codex_response.json}"
+
+# --- Configuration ---
+ENABLE_PERSONA="${ENABLE_PERSONA:-true}"
+CONSULTANT_NAME="Codex"
+
+# --- Build query ---
+FULL_QUERY=$(build_full_query "$QUERY" "$CONTEXT_FILE")
+validate_query "$FULL_QUERY" "Codex" || exit 1
+
+# --- Add persona if enabled ---
+if [[ "$ENABLE_PERSONA" == "true" ]]; then
+    FULL_QUERY=$(build_query_with_persona "$CONSULTANT_NAME" "$FULL_QUERY")
+fi
+
+# --- Timestamp for metadata ---
+START_TIME=$(get_timestamp_ms)
+
+# --- Execution (CLI or API mode) ---
+TEMP_OUTPUT=$(mktemp)
+
+if is_api_mode "codex"; then
+    # --- API Mode ---
+    log_api_mode_status "codex"
+    validate_api_mode "codex" || exit 1
+
+    source "$SCRIPT_DIR/lib/api_query.sh"
+
+    run_api_mode_query \
+        "$CONSULTANT_NAME" \
+        "$CODEX_MODEL" \
+        "$FULL_QUERY" \
+        "$TEMP_OUTPUT" \
+        "$CODEX_TIMEOUT_SECONDS"
+
+    exit_code=$?
+else
+    # --- CLI Mode ---
+    log_api_mode_status "codex"
+    check_command "$CODEX_CMD" "Codex CLI" "npm install -g @openai/codex" || exit 1
+
+    # Build command
+    CMD_ARGS=("$CODEX_CMD" "exec" "--skip-git-repo-check")
+    if [[ -n "$CODEX_MODEL" ]]; then
+        CMD_ARGS+=("-m" "$CODEX_MODEL")
+    fi
+
+    # Codex uses query as the last argument, not from stdin
+    run_query \
+        "Codex" \
+        "$TEMP_OUTPUT" \
+        "$CODEX_TIMEOUT_SECONDS" \
+        "${CMD_ARGS[@]}" "$FULL_QUERY" < /dev/null
+
+    exit_code=$?
+fi
+
+# --- Calculate latency ---
+END_TIME=$(get_timestamp_ms)
+LATENCY_MS=$((END_TIME - START_TIME))
+
+# --- Configuration for response building ---
+MODEL_USED="${CODEX_MODEL:-gpt-5.3-codex}"
+PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
+
+# --- Post-processing: use shared helper ---
+process_consultant_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
+    "$TEMP_OUTPUT" "$OUTPUT_FILE" "$exit_code" "$LATENCY_MS"
+
+cat "$OUTPUT_FILE"
+exit $exit_code

package/scripts/query_cursor.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+# query_cursor.sh - Query Cursor CLI
+#
+# Usage: ./query_cursor.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   CURSOR_MODEL   - Model to use (default: uses Cursor's default)
+#   CURSOR_TIMEOUT - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA - Enable "The Integrator" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+source "$SCRIPT_DIR/lib/personas.sh"
+
+# --- Parameters ---
+QUERY="${1:-}"
+CONTEXT_FILE="${2:-}"
+OUTPUT_FILE="${3:-/tmp/cursor_response.json}"
+
+# --- Configuration ---
+ENABLE_PERSONA="${ENABLE_PERSONA:-true}"
+CONSULTANT_NAME="Cursor"
+MODEL_USED="${CURSOR_MODEL:-cursor}"
+
+# --- Check prerequisites ---
+check_command "$CURSOR_CMD" "Cursor CLI" "curl https://cursor.com/install -fsS | bash" || exit 1
+
+# --- Build query ---
+FULL_QUERY=$(build_full_query "$QUERY" "$CONTEXT_FILE")
+validate_query "$FULL_QUERY" "Cursor" || exit 1
+
+# --- Add persona if enabled ---
+if [[ "$ENABLE_PERSONA" == "true" ]]; then
+    FULL_QUERY=$(build_query_with_persona "$CONSULTANT_NAME" "$FULL_QUERY")
+fi
+
+# --- Timestamp for metadata ---
+START_TIME=$(get_timestamp_ms)
+
+# --- Execution ---
+TEMP_OUTPUT=$(mktemp)
+trap 'rm -f "$TEMP_OUTPUT"' EXIT
+
+# Build command args with optional model
+# -p = print mode, -f = force-allow / trust workspace (prevents interactive prompt)
+CMD_ARGS=("$CURSOR_CMD" "-p" "-f" "--output-format" "text")
+if [[ -n "${CURSOR_MODEL:-}" ]]; then
+    CMD_ARGS+=("--model" "$CURSOR_MODEL")
+fi
+
+run_query \
+    "Cursor" \
+    "$TEMP_OUTPUT" \
+    "$CURSOR_TIMEOUT_SECONDS" \
+    "${CMD_ARGS[@]}" "$FULL_QUERY" < /dev/null
+
+exit_code=$?
+
+# --- Calculate latency ---
+END_TIME=$(get_timestamp_ms)
+LATENCY_MS=$((END_TIME - START_TIME))
+
+# --- Post-processing: use shared helper ---
+PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
+
+process_consultant_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
+    "$TEMP_OUTPUT" "$OUTPUT_FILE" "$exit_code" "$LATENCY_MS"
+
+cat "$OUTPUT_FILE"
+exit $exit_code

package/scripts/query_deepseek.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# query_deepseek.sh - Query DeepSeek via HTTP API
+#
+# Usage: ./query_deepseek.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   DEEPSEEK_API_KEY   - API key for DeepSeek (required)
+#   DEEPSEEK_MODEL     - Model to use (default: deepseek-reasoner)
+#   DEEPSEEK_TIMEOUT   - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA     - Enable "The Code Specialist" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/api_query.sh"
+
+run_api_consultant "DeepSeek" "$@"

package/scripts/query_gemini.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# query_gemini.sh - Query Google Gemini CLI or API (v2.6 with API mode support)
+#
+# Usage: ./query_gemini.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   GEMINI_MODEL - Model to use (default: gemini-3.1-pro-preview)
+#   GEMINI_TIMEOUT - Timeout in seconds (default: 180)
+#   GEMINI_USE_API - Use API mode instead of CLI (default: false)
+#   GEMINI_API_KEY - API key for API mode
+#   ENABLE_PERSONA - Enable "The Architect" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+source "$SCRIPT_DIR/lib/personas.sh"
+
+# --- Parameters ---
+QUERY="${1:-}"
+CONTEXT_FILE="${2:-}"
+OUTPUT_FILE="${3:-/tmp/gemini_response.json}"
+
+# --- Configuration ---
+ENABLE_PERSONA="${ENABLE_PERSONA:-true}"
+CONSULTANT_NAME="Gemini"
+
+# --- Build query ---
+FULL_QUERY=$(build_full_query "$QUERY" "$CONTEXT_FILE")
+validate_query "$FULL_QUERY" "Gemini" || exit 1
+
+# --- Add persona if enabled ---
+if [[ "$ENABLE_PERSONA" == "true" ]]; then
+    FULL_QUERY=$(build_query_with_persona "$CONSULTANT_NAME" "$FULL_QUERY")
+fi
+
+# --- Timestamp for metadata ---
+START_TIME=$(get_timestamp_ms)
+
+# --- Execution (CLI or API mode) ---
+TEMP_OUTPUT=$(mktemp)
+
+if is_api_mode "gemini"; then
+    # --- API Mode ---
+    log_api_mode_status "gemini"
+    validate_api_mode "gemini" || exit 1
+
+    source "$SCRIPT_DIR/lib/api_query.sh"
+
+    run_api_mode_query \
+        "$CONSULTANT_NAME" \
+        "$GEMINI_MODEL" \
+        "$FULL_QUERY" \
+        "$TEMP_OUTPUT" \
+        "$GEMINI_TIMEOUT_SECONDS"
+
+    exit_code=$?
+else
+    # --- CLI Mode ---
+    log_api_mode_status "gemini"
+    check_command "$GEMINI_CMD" "Gemini CLI" "npm install -g @google/gemini-cli" || exit 1
+
+    echo "$FULL_QUERY" | run_query \
+        "Gemini" \
+        "$TEMP_OUTPUT" \
+        "$GEMINI_TIMEOUT_SECONDS" \
+        "$GEMINI_CMD" -p - -m "$GEMINI_MODEL" --output-format json
+
+    exit_code=$?
+fi
+
+# --- Calculate latency ---
+END_TIME=$(get_timestamp_ms)
+LATENCY_MS=$((END_TIME - START_TIME))
+
+# --- Configuration for response building ---
+MODEL_USED="$GEMINI_MODEL"
+PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
+
+# --- Post-processing: use shared helper ---
+process_consultant_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
+    "$TEMP_OUTPUT" "$OUTPUT_FILE" "$exit_code" "$LATENCY_MS" "response"
+
+cat "$OUTPUT_FILE"
+exit $exit_code

package/scripts/query_glm.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# query_glm.sh - Query GLM (Zhipu AI) via HTTP API (v2.0 with Persona and Confidence)
+#
+# Usage: ./query_glm.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   GLM_API_KEY     - API key for Zhipu AI (required)
+#   GLM_MODEL       - Model to use (default: glm-4)
+#   GLM_TIMEOUT     - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA  - Enable "The Methodologist" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/api_query.sh"
+
+run_api_consultant "GLM" "$@"

package/scripts/query_grok.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# query_grok.sh - Query Grok (xAI) via HTTP API (v2.0 with Persona and Confidence)
+#
+# Usage: ./query_grok.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   GROK_API_KEY    - API key for xAI (required)
+#   GROK_MODEL      - Model to use (default: grok-4-1-fast-reasoning)
+#   GROK_TIMEOUT    - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA  - Enable "The Provocateur" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/api_query.sh"
+
+run_api_consultant "Grok" "$@"

package/scripts/query_kilo.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+# query_kilo.sh - Query Kilo Code CLI
+#
+# Usage: ./query_kilo.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   KILO_MODEL   - Model to use (default: uses Kilo's internal provider)
+#   KILO_TIMEOUT - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA - Enable "The Innovator" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+source "$SCRIPT_DIR/lib/personas.sh"
+
+# --- Parameters ---
+QUERY="${1:-}"
+CONTEXT_FILE="${2:-}"
+OUTPUT_FILE="${3:-/tmp/kilo_response.json}"
+
+# --- Configuration ---
+ENABLE_PERSONA="${ENABLE_PERSONA:-true}"
+CONSULTANT_NAME="Kilo"
+MODEL_USED="${KILO_MODEL:-kilo}"
+
+# --- Check prerequisites ---
+check_command "$KILO_CMD" "Kilo Code CLI" "npm install -g @kilocode/cli" || exit 1
+
+# --- Build query ---
+FULL_QUERY=$(build_full_query "$QUERY" "$CONTEXT_FILE")
+validate_query "$FULL_QUERY" "Kilo Code" || exit 1
+
+# --- Add persona if enabled ---
+if [[ "$ENABLE_PERSONA" == "true" ]]; then
+    FULL_QUERY=$(build_query_with_persona "$CONSULTANT_NAME" "$FULL_QUERY")
+fi
+
+# --- Timestamp for metadata ---
+START_TIME=$(get_timestamp_ms)
+
+# --- Execution ---
+TEMP_OUTPUT=$(mktemp)
+TEMP_RAW=$(mktemp)
+trap 'rm -f "$TEMP_OUTPUT" "$TEMP_RAW"' EXIT
+
+# Build command args: run subcommand + --auto + --dir /tmp (prevent SKILL.md loading)
+KILO_ARGS=("$KILO_CMD" "run" "--auto" "--dir" "/tmp")
+if [[ -n "${KILO_MODEL:-}" && "${KILO_MODEL}" != "auto" ]]; then
+    KILO_ARGS+=("--model" "$KILO_MODEL")
+fi
+KILO_ARGS+=("$FULL_QUERY")
+
+# Use run_with_timeout for cross-platform support (Linux/macOS/POSIX)
+log_info "Consulting Kilo Code (timeout: ${KILO_TIMEOUT_SECONDS}s)..."
+
+if run_with_timeout "$KILO_TIMEOUT_SECONDS" "${KILO_ARGS[@]}" > "$TEMP_RAW" 2>&1; then
+    exit_code=0
+else
+    exit_code=$?
+fi
+
+# --- Strip ANSI escape codes from Kilo's text output ---
+if [[ -f "$TEMP_RAW" && -s "$TEMP_RAW" ]]; then
+    # Kilo outputs plain text with ANSI codes; strip them for clean output
+    CONTENT=$(LC_ALL=C sed 's/\x1b\[[0-9;]*[a-zA-Z]//g' "$TEMP_RAW" | sed '/^$/d') || true
+
+    if [[ -n "${CONTENT:-}" ]]; then
+        exit_code=0
+        log_success "[Kilo Code] Response received (${#CONTENT} chars)"
+    else
+        log_error "[Kilo Code] Could not extract response"
+        exit_code=1
+    fi
+fi
+
+# --- Calculate latency ---
+END_TIME=$(get_timestamp_ms)
+LATENCY_MS=$((END_TIME - START_TIME))
+
+# --- Post-processing: extract structure from markdown output ---
+PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
+
+if [[ $exit_code -eq 0 && -n "${CONTENT:-}" ]]; then
+    # Check if Kilo returned valid JSON (unlikely but handle it)
+    if echo "$CONTENT" | jq -e '.response.summary' > /dev/null 2>&1; then
+        echo "$CONTENT" > "$TEMP_OUTPUT"
+        process_consultant_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
+            "$TEMP_OUTPUT" "$OUTPUT_FILE" "$exit_code" "$LATENCY_MS"
+    else
+        # Extract structured fields from markdown/text output
+        # Summary: first meaningful line(s), up to 200 chars
+        local_summary=$(echo "$CONTENT" | head -5 | tr '\n' ' ' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | head -c 200)
+
+        # Approach: look for headings or key phrases
+        local_approach=$(echo "$CONTENT" | grep -iE '^#+\s|^approach:|^recommendation:|^solution:' | head -1 | \
+            sed 's/^[#[:space:]]*//;s/^[Aa]pproach:[[:space:]]*//' | head -c 100)
+        [[ -z "$local_approach" ]] && local_approach=$(echo "$local_summary" | head -c 60)
+
+        # Confidence: estimate from language strength
+        local_confidence=6
+        if echo "$CONTENT" | grep -qiE 'highly recommend|strongly suggest|definitely|clearly the best'; then
+            local_confidence=8
+        elif echo "$CONTENT" | grep -qiE 'recommend|suggest|good approach|effective|solid'; then
+            local_confidence=7
+        elif echo "$CONTENT" | grep -qiE 'might|could|possibly|one option|uncertain|depends'; then
+            local_confidence=5
+        fi
+
+        jq -n \
+            --arg consultant "$CONSULTANT_NAME" \
+            --arg model "$MODEL_USED" \
+            --arg persona "$PERSONA_NAME" \
+            --arg summary "$local_summary" \
+            --arg detailed "$CONTENT" \
+            --arg approach "$local_approach" \
+            --argjson confidence "$local_confidence" \
+            --argjson metadata "$(build_response_metadata "$LATENCY_MS" "$MODEL_USED")" \
+            '{
+                consultant: $consultant, model: $model, persona: $persona,
+                response: {
+                    summary: $summary, detailed: $detailed, approach: $approach,
+                    pros: [], cons: [],
+                    caveats: ["Structured fields extracted from unformatted CLI output"]
+                },
+                confidence: {
+                    score: $confidence,
+                    reasoning: "Confidence estimated from response language patterns",
+                    uncertainty_factors: ["Non-JSON response format"]
+                },
+                metadata: $metadata
+            }' > "$OUTPUT_FILE"
+    fi
+else
+    build_error_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
+        "Query failed with exit code $exit_code" "$LATENCY_MS" > "$OUTPUT_FILE"
+fi
+
+cat "$OUTPUT_FILE"
+exit $exit_code

package/scripts/query_kimi.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# query_kimi.sh - Query Kimi CLI (v2.9)
+#
+# Usage: ./query_kimi.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   KIMI_MODEL     - Model identifier (default: kimi-code/kimi-for-coding)
+#   KIMI_TIMEOUT   - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA - Enable "The Eastern Sage" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+source "$SCRIPT_DIR/lib/personas.sh"
+
+# --- Parameters ---
+QUERY="${1:-}"
+CONTEXT_FILE="${2:-}"
+OUTPUT_FILE="${3:-/tmp/kimi_response.json}"
+
+# --- Configuration ---
+ENABLE_PERSONA="${ENABLE_PERSONA:-true}"
+CONSULTANT_NAME="Kimi"
+
+# --- Build query ---
+FULL_QUERY=$(build_full_query "$QUERY" "$CONTEXT_FILE")
+validate_query "$FULL_QUERY" "Kimi" || exit 1
+
+# --- Add persona if enabled ---
+if [[ "$ENABLE_PERSONA" == "true" ]]; then
+    FULL_QUERY=$(build_query_with_persona "$CONSULTANT_NAME" "$FULL_QUERY")
+fi
+
+# --- Timestamp for metadata ---
+START_TIME=$(get_timestamp_ms)
+
+# --- Execution ---
+TEMP_OUTPUT=$(mktemp)
+
+# Check CLI prerequisite
+check_command "$KIMI_CMD" "Kimi CLI" "curl -L code.kimi.com/install.sh | bash" || exit 1
+
+# Kimi CLI uses --quiet (equivalent to --print --output-format text --final-message-only)
+# and --input-format text for piped stdin
+echo "$FULL_QUERY" | run_query \
+    "Kimi" \
+    "$TEMP_OUTPUT" \
+    "$KIMI_TIMEOUT_SECONDS" \
+    "$KIMI_CMD" --quiet --input-format text
+
+exit_code=$?
+
+# --- Calculate latency ---
+END_TIME=$(get_timestamp_ms)
+LATENCY_MS=$((END_TIME - START_TIME))
+
+# --- Configuration for response building ---
+MODEL_USED="$KIMI_MODEL"
+PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
+
+# --- Post-processing: use shared helper ---
+process_consultant_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
+    "$TEMP_OUTPUT" "$OUTPUT_FILE" "$exit_code" "$LATENCY_MS"
+
+cat "$OUTPUT_FILE"
+exit $exit_code

package/scripts/query_minimax.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# query_minimax.sh - Query MiniMax via HTTP API
+#
+# Usage: ./query_minimax.sh "question" [context_file] [output_file]
+#
+# Environment variables:
+#   MINIMAX_API_KEY    - API key for MiniMax (required)
+#   MINIMAX_MODEL      - Model to use (default: MiniMax-M2.5)
+#   MINIMAX_TIMEOUT    - Timeout in seconds (default: 180)
+#   ENABLE_PERSONA     - Enable "The Pragmatic Optimizer" persona (default: true)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/api_query.sh"
+
+run_api_consultant "MiniMax" "$@"