juno-code 1.0.34 → 1.0.36

package/dist/templates/scripts/run_until_completion.sh

@@ -0,0 +1,202 @@
+#!/usr/bin/env bash
+
+# run_until_completion.sh
+#
+# Purpose: Continuously run juno-code until all kanban tasks are completed
+#
+# This script uses a do-while loop pattern: it runs juno-code at least once,
+# then checks the kanban board for tasks in backlog, todo, or in_progress status.
+# If tasks remain, it continues running juno-code. This ensures juno-code's
+# internal task management systems get a chance to operate even if kanban.sh
+# doesn't initially detect any tasks.
+#
+# Usage: ./.juno_task/scripts/run_until_completion.sh [juno-code arguments]
+# Example: ./.juno_task/scripts/run_until_completion.sh -s claude -i 5 -v
+# Example: ./.juno_task/scripts/run_until_completion.sh -b shell -s claude -m :opus
+#
+# All arguments passed to this script will be forwarded to juno-code.
+# The script shows all stdout/stderr from juno-code in real-time.
+#
+# Environment Variables:
+#   JUNO_DEBUG=true    - Show [DEBUG] diagnostic messages
+#   JUNO_VERBOSE=true  - Show [RUN_UNTIL] informational messages
+#   (Both default to false for silent operation)
+#
+# Created by: juno-code init command
+# Date: Auto-generated during project initialization
+
+set -euo pipefail  # Exit on error, undefined variable, or pipe failure
+
+# DEBUG OUTPUT: Show that run_until_completion.sh is being executed
+if [ "${JUNO_DEBUG:-false}" = "true" ]; then
+    echo "[DEBUG] run_until_completion.sh is being executed from: $(pwd)" >&2
+fi
+
+# Color output for better readability
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Configuration
+SCRIPTS_DIR=".juno_task/scripts"
+KANBAN_SCRIPT="${SCRIPTS_DIR}/kanban.sh"
+
+# Logging functions
+log_info() {
+    # Only print if JUNO_VERBOSE is set to true
+    if [ "${JUNO_VERBOSE:-false}" = "true" ]; then
+        echo -e "${BLUE}[RUN_UNTIL]${NC} $1" >&2
+    fi
+}
+
+log_success() {
+    # Only print if JUNO_VERBOSE is set to true
+    if [ "${JUNO_VERBOSE:-false}" = "true" ]; then
+        echo -e "${GREEN}[RUN_UNTIL]${NC} $1" >&2
+    fi
+}
+
+log_warning() {
+    # Only print if JUNO_VERBOSE is set to true
+    if [ "${JUNO_VERBOSE:-false}" = "true" ]; then
+        echo -e "${YELLOW}[RUN_UNTIL]${NC} $1" >&2
+    fi
+}
+
+log_error() {
+    # Always print errors regardless of JUNO_VERBOSE
+    echo -e "${RED}[RUN_UNTIL]${NC} $1" >&2
+}
+
+log_status() {
+    # Always print status updates so user knows what's happening
+    echo -e "${CYAN}[RUN_UNTIL]${NC} $1" >&2
+}
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Navigate to project root (parent of scripts directory)
+PROJECT_ROOT="$( cd "$SCRIPT_DIR/../.." && pwd )"
+
+# Change to project root
+cd "$PROJECT_ROOT"
+
+# Function to check if there are tasks remaining
+has_remaining_tasks() {
+    log_info "Checking kanban for remaining tasks..."
+
+    # Check if kanban script exists
+    if [ ! -f "$KANBAN_SCRIPT" ]; then
+        log_error "Kanban script not found: $KANBAN_SCRIPT"
+        log_error "Please run 'juno-code init' to initialize the project"
+        return 1
+    fi
+
+    # Make sure the script is executable
+    chmod +x "$KANBAN_SCRIPT"
+
+    # Run kanban list and check for "No results found"
+    # We capture both stdout and stderr to handle various output formats
+    local kanban_output
+    if kanban_output=$("$KANBAN_SCRIPT" list --status backlog todo in_progress 2>&1); then
+        if echo "$kanban_output" | grep -q "No results found"; then
+            log_info "No remaining tasks found"
+            return 1  # No remaining tasks
+        else
+            log_info "Found remaining tasks"
+            if [ "${JUNO_DEBUG:-false}" = "true" ]; then
+                echo "[DEBUG] Kanban output:" >&2
+                echo "$kanban_output" >&2
+            fi
+            return 0  # Has remaining tasks
+        fi
+    else
+        # kanban.sh returned non-zero, check if it's because no results
+        if echo "$kanban_output" | grep -q "No results found"; then
+            log_info "No remaining tasks found (from error output)"
+            return 1
+        fi
+        log_error "Failed to check kanban status"
+        log_error "Output: $kanban_output"
+        return 1  # Treat errors as "no tasks" to prevent infinite loops
+    fi
+}
+
+# Main run loop
+main() {
+    local iteration=0
+    local max_iterations="${JUNO_RUN_UNTIL_MAX_ITERATIONS:-0}"  # 0 = unlimited
+
+    log_status "=== Run Until Completion ==="
+    log_status "Arguments to juno-code: $*"
+
+    if [ "$max_iterations" -gt 0 ]; then
+        log_status "Maximum iterations: $max_iterations"
+    else
+        log_status "Maximum iterations: unlimited"
+    fi
+
+    # Check if we have any arguments
+    if [ $# -eq 0 ]; then
+        log_warning "No arguments provided. Running juno-code with no arguments."
+    fi
+
+    # Do-while loop pattern: Run juno-code at least once, then continue while tasks remain
+    # This ensures juno-code's internal task management systems get a chance to operate
+    # even if kanban.sh doesn't initially detect any tasks
+    while true; do
+        iteration=$((iteration + 1))
+
+        log_status ""
+        log_status "=========================================="
+        log_status "Iteration $iteration"
+        log_status "=========================================="
+
+        # Check max iterations limit BEFORE running (prevents exceeding limit)
+        if [ "$max_iterations" -gt 0 ] && [ "$iteration" -gt "$max_iterations" ]; then
+            log_warning ""
+            log_warning "=========================================="
+            log_warning "Maximum iterations ($max_iterations) reached. Exiting."
+            log_warning "=========================================="
+            exit 0
+        fi
+
+        log_status "Running juno-code with args: $*"
+        log_status "------------------------------------------"
+
+        # Run juno-code with all provided arguments
+        # We run juno-code FIRST (do-while pattern), then check for remaining tasks
+        if juno-code "$@"; then
+            log_success "juno-code completed successfully"
+        else
+            local exit_code=$?
+            log_warning "juno-code exited with code $exit_code"
+            # Continue the loop even if juno-code fails - it might succeed next iteration
+            # Some failures are expected (e.g., partial task completion)
+        fi
+
+        log_status "------------------------------------------"
+        log_status "Iteration $iteration complete. Checking for more tasks..."
+
+        # Small delay to prevent rapid-fire execution and allow user to Ctrl+C if needed
+        sleep 1
+
+        # Check for remaining tasks AFTER running juno-code (do-while pattern)
+        # This ensures juno-code runs at least once, allowing its internal task
+        # management systems to check kanban for updates
+        if ! has_remaining_tasks; then
+            log_success ""
+            log_success "=========================================="
+            log_success "All tasks completed! Exiting after $iteration iteration(s)."
+            log_success "=========================================="
+            exit 0
+        fi
+    done
+}
+
+# Run main function with all arguments
+main "$@"

package/dist/templates/services/README.md

@@ -180,6 +180,48 @@ You can override these by providing the `--tool` argument:
 ~/.juno_code/services/claude.py -p "Safe operation" --tool Read --tool Write
 ```
 
+### gemini.py
+
+Headless wrapper for Gemini CLI with shorthand model support and JSON/text output normalization.
+
+#### Features
+
+- Headless execution via `--prompt/-p` or `--prompt-file`
+- Shorthand model aliases (`:pro`, `:flash`, `:pro-3`, `:flash-3`, `:pro-2.5`, `:flash-2.5`)
+- Streaming JSON output normalization (default `--output-format stream-json`)
+- Auto-approval for headless mode (defaults to `--yolo` when no approval mode is provided)
+- Fails fast when `GEMINI_API_KEY` is missing to prevent confusing CLI errors
+- Optional directory inclusion (`--include-directories`) and debug passthrough
+
+#### Usage
+
+```bash
+# Basic headless run with shorthand model (stream-json output is default)
+~/.juno_code/services/gemini.py -p "Summarize the README" -m :pro-3
+
+# Include project context and enable debug logging
+~/.juno_code/services/gemini.py -p "Audit the project" --include-directories src,docs --debug
+
+# Auto-approve actions explicitly (default when no approval mode provided)
+~/.juno_code/services/gemini.py -p "Refactor the code" --yolo
+
+# Emit non-streaming JSON if needed
+~/.juno_code/services/gemini.py -p "Quick JSON response" --output-format json
+```
+
+#### Arguments
+
+- `-p, --prompt <text>`: Prompt text (required, mutually exclusive with --prompt-file)
+- `-pp, --prompt-file <path>`: Path to prompt file (required if no --prompt)
+- `--cd <path>`: Project path (default: current directory)
+- `-m, --model <name>`: Gemini model (supports shorthand aliases)
+- `--output-format <stream-json|json|text>`: Output format (default: stream-json)
+- `--include-directories <list>`: Comma-separated directories to include
+- `--approval-mode <mode>`: Approval mode (e.g., auto_edit). If omitted, `--yolo` is applied for headless automation.
+- `--yolo`: Auto-approve actions (non-interactive)
+- `--debug`: Enable Gemini CLI debug output
+- `--verbose`: Print the constructed command before execution
+
 ## Customization
 
 All service scripts installed in `~/.juno_code/services/` can be modified to suit your needs. This directory is designed for user customization.
@@ -238,6 +280,7 @@ Service scripts require Python 3.6+ to be installed on your system. Individual s
 
 - **codex.py**: Requires OpenAI Codex CLI to be installed
 - **claude.py**: Requires Anthropic Claude CLI to be installed (see https://docs.anthropic.com/en/docs/agents-and-tools/claude-code)
+- **gemini.py**: Requires Gemini CLI to be installed (see https://geminicli.com/docs/cli/headless/)
 
 ## Troubleshooting
 

package/dist/templates/services/claude.py

@@ -20,7 +20,7 @@ class ClaudeService:
     # Default configuration
     DEFAULT_MODEL = "claude-sonnet-4-5-20250929"
     DEFAULT_PERMISSION_MODE = "default"
-    DEFAULT_AUTO_INSTRUCTION = """You are Claude Code, an AI coding assistant. Follow the instructions provided and generate high-quality code."""
+    DEFAULT_AUTO_INSTRUCTION = """"""
 
     # Model shorthand mappings (colon-prefixed names expand to full model IDs)
     MODEL_SHORTHANDS = {

package/dist/templates/services/codex.py

@@ -17,12 +17,12 @@ class CodexService:
     """Service wrapper for OpenAI Codex CLI"""
 
     # Default configuration
-    DEFAULT_MODEL = "codex-5.1-max"
+    DEFAULT_MODEL = "codex-5.2-max"
     DEFAULT_AUTO_INSTRUCTION = """You are an AI coding assistant. Follow the instructions provided and generate high-quality code."""
 
     # Model shorthand mappings (colon-prefixed names expand to full model IDs)
     MODEL_SHORTHANDS = {
-        ":codex": "codex-5.1-codex-max",
+        ":codex": "codex-5.2-codex-max",
         ":gpt-5": "gpt-5",
         ":mini": "gpt-5-codex-mini",
     }
@@ -34,6 +34,7 @@ class CodexService:
         self.prompt = ""
         self.additional_args: List[str] = []
         self.verbose = False
+        self._item_counter = 0
 
     def expand_model_shorthand(self, model: str) -> str:
         """
@@ -69,10 +70,10 @@ Examples:
   %(prog)s -p "Write a hello world function"
   %(prog)s -pp prompt.txt --cd /path/to/project
   %(prog)s -p "Add tests" -m gpt-4 -c custom_arg=value
-  %(prog)s -p "Optimize code" -m :codex  # uses codex-5.1-codex-max
+  %(prog)s -p "Optimize code" -m :codex  # uses codex-5.2-codex-max
 
 Environment Variables:
-  CODEX_MODEL                Model name (supports shorthand, default: codex-5.1-max)
+  CODEX_MODEL                Model name (supports shorthand, default: codex-5.2-max)
   CODEX_HIDE_STREAM_TYPES    Comma-separated list of streaming msg types to hide
                              Default: turn_diff,token_count,exec_command_output_delta
   JUNO_CODE_HIDE_STREAM_TYPES Same as CODEX_HIDE_STREAM_TYPES (alias)
@@ -199,6 +200,37 @@ Environment Variables:
             content_text,
         )
 
+    def _parse_item_number(self, item_id: str) -> Optional[int]:
+        """Return numeric component from item_{n} ids or None if unparseable."""
+        if not isinstance(item_id, str):
+            return None
+        item_id = item_id.strip()
+        if not item_id.startswith("item_"):
+            return None
+        try:
+            return int(item_id.split("item_", 1)[1])
+        except Exception:
+            return None
+
+    def _normalize_item_id(self, payload: dict, outer_type: str) -> Optional[str]:
+        """
+        Prefer the existing id on item.* payloads; otherwise synthesize sequential item_{n}.
+        Maintains a per-run counter so missing ids still expose turn counts.
+        """
+        item_id = payload.get("id") if isinstance(payload, dict) else None
+        if isinstance(item_id, str) and item_id.strip():
+            parsed = self._parse_item_number(item_id)
+            if parsed is not None and parsed + 1 > self._item_counter:
+                self._item_counter = parsed + 1
+            return item_id.strip()
+
+        if isinstance(outer_type, str) and outer_type.startswith("item."):
+            generated = f"item_{self._item_counter}"
+            self._item_counter += 1
+            return generated
+
+        return None
+
     def read_prompt_file(self, file_path: str) -> str:
         """Read prompt from a file"""
         try:
@@ -266,6 +298,7 @@ Environment Variables:
         msg_type: str,
         payload: dict,
         outer_type: str = "",
+        item_id: Optional[str] = None,
     ) -> Optional[str]:
         """
         Pretty format for specific msg types to be human readable while
@@ -282,12 +315,21 @@ Environment Variables:
             now = datetime.now().strftime("%I:%M:%S %p")
             msg_type = (msg_type or "").strip()
             header_type = (outer_type or msg_type).strip()
-            header = {"type": header_type or msg_type or "message", "datetime": now}
+            base_type = header_type or msg_type or "message"
 
-            if outer_type and msg_type and outer_type != msg_type:
-                header["item_type"] = msg_type
+            def make_header(type_value: str):
+                hdr = {"type": type_value, "datetime": now}
+                if item_id:
+                    hdr["id"] = item_id
+                if outer_type and msg_type and outer_type != msg_type:
+                    hdr["item_type"] = msg_type
+                return hdr
+
+            header = make_header(base_type)
 
             if isinstance(payload, dict):
+                if item_id and "id" not in payload:
+                    payload["id"] = item_id
                 if payload.get("command"):
                     header["command"] = payload.get("command")
                 if payload.get("status"):
@@ -298,9 +340,7 @@ Environment Variables:
             # agent_reasoning → show 'text' human-readable
             if msg_type in {"agent_reasoning", "reasoning"}:
                 content = self._extract_reasoning_text(payload)
-                header = {"type": header_type or msg_type, "datetime": now}
-                if outer_type and msg_type and outer_type != msg_type:
-                    header["item_type"] = msg_type
+                header = make_header(header_type or msg_type)
                 if "\n" in content:
                     return json.dumps(header, ensure_ascii=False) + "\ntext:\n" + content
                 header["text"] = content
@@ -308,9 +348,7 @@ Environment Variables:
 
             if msg_type in {"agent_message", "message", "assistant_message", "assistant"}:
                 content = self._extract_message_text(payload)
-                header = {"type": header_type or msg_type, "datetime": now}
-                if outer_type and msg_type and outer_type != msg_type:
-                    header["item_type"] = msg_type
+                header = make_header(header_type or msg_type)
                 if "\n" in content:
                     return json.dumps(header, ensure_ascii=False) + "\nmessage:\n" + content
                 if content != "":
@@ -386,6 +424,9 @@ Environment Variables:
                 parts = [p.strip() for p in env_val.split(",") if p.strip()]
                 hide_types.update(parts)
 
+        # Reset per-run item counter for synthesized ids
+        self._item_counter = 0
+
         # We fully suppress all token_count events (do not emit even at end)
         last_token_count = None
 
@@ -444,6 +485,14 @@ Environment Variables:
             def handle_obj(obj_dict: dict):
                 nonlocal last_token_count
                 msg_type_inner, payload_inner, outer_type_inner = self._normalize_event(obj_dict)
+                item_id_inner = self._normalize_item_id(payload_inner, outer_type_inner)
+
+                if (
+                    item_id_inner
+                    and isinstance(obj_dict.get("item"), dict)
+                    and not obj_dict["item"].get("id")
+                ):
+                    obj_dict["item"]["id"] = item_id_inner
 
                 if msg_type_inner == "token_count":
                     last_token_count = obj_dict
@@ -452,7 +501,12 @@ Environment Variables:
                 if msg_type_inner and msg_type_inner in hide_types:
                     return  # suppress
 
-                pretty_line_inner = self._format_msg_pretty(msg_type_inner, payload_inner, outer_type_inner)
+                pretty_line_inner = self._format_msg_pretty(
+                    msg_type_inner,
+                    payload_inner,
+                    outer_type_inner,
+                    item_id=item_id_inner,
+                )
                 if pretty_line_inner is not None:
                     print(pretty_line_inner, flush=True)
                 else: