juno-code 1.0.41 → 1.0.43

package/dist/templates/scripts/install_requirements.sh

@@ -52,10 +52,9 @@ BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
 # Required packages
-REQUIRED_PACKAGES=("juno-kanban" "roundtable-ai")
-
-# Slack integration dependencies (optional, only installed when Slack scripts are used)
-SLACK_PACKAGES=("slack_sdk" "python-dotenv")
+# Note: requests and python-dotenv are required by github.py
+# slack_sdk is required by Slack integration scripts (slack_fetch.py, slack_respond.py)
+REQUIRED_PACKAGES=("juno-kanban" "roundtable-ai" "requests" "python-dotenv" "slack_sdk")
 
 # Version check cache configuration
 # This ensures we don't check PyPI on every run (performance optimization per Task RTafs5)

package/dist/templates/scripts/kanban.sh

@@ -9,6 +9,12 @@
 #
 # Usage: ./.juno_task/scripts/kanban.sh [juno-kanban arguments]
 # Example: ./.juno_task/scripts/kanban.sh list --limit 5
+# Example: ./.juno_task/scripts/kanban.sh list -f json --raw  # (flag order normalized)
+# Example: ./.juno_task/scripts/kanban.sh -f json --raw list  # (also works)
+#
+# Note: Global flags (-f/--format, -p/--pretty, --raw, -v/--verbose, -c/--config)
+#       can be placed anywhere in the command line. This wrapper normalizes them
+#       to appear before the command for juno-kanban compatibility.
 #
 # Environment Variables:
 #   JUNO_DEBUG=true    - Show [DEBUG] diagnostic messages
@@ -170,6 +176,67 @@ PROJECT_ROOT="$( cd "$SCRIPT_DIR/../.." && pwd )"
 # Change to project root
 cd "$PROJECT_ROOT"
 
+# Arrays to store normalized arguments (declared at script level for proper handling)
+declare -a NORMALIZED_GLOBAL_FLAGS=()
+declare -a NORMALIZED_COMMAND_ARGS=()
+
+# Normalize argument order for juno-kanban
+# juno-kanban requires global flags BEFORE the command, but users often
+# write them after (e.g., "list -f json --raw" instead of "-f json --raw list")
+# This function reorders arguments so global flags come first.
+# Results are stored in NORMALIZED_GLOBAL_FLAGS and NORMALIZED_COMMAND_ARGS arrays.
+normalize_arguments() {
+    # Reset arrays
+    NORMALIZED_GLOBAL_FLAGS=()
+    NORMALIZED_COMMAND_ARGS=()
+    local found_command=false
+
+    # Known subcommands
+    local commands="create search get show update archive mark list merge"
+
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            # Global flags that take a value
+            -f|--format|-c|--config)
+                if [[ -n "${2:-}" ]]; then
+                    NORMALIZED_GLOBAL_FLAGS+=("$1" "$2")
+                    shift 2
+                else
+                    NORMALIZED_GLOBAL_FLAGS+=("$1")
+                    shift
+                fi
+                ;;
+            # Global flags that don't take a value
+            -p|--pretty|--raw|-v|--verbose|-h|--help|--version)
+                NORMALIZED_GLOBAL_FLAGS+=("$1")
+                shift
+                ;;
+            # Check if this is a known command
+            *)
+                # Check if this argument is a known command
+                local is_command=false
+                for cmd in $commands; do
+                    if [[ "$1" == "$cmd" ]]; then
+                        is_command=true
+                        found_command=true
+                        break
+                    fi
+                done
+
+                # If we found a command, everything from here goes to command_args
+                if $is_command || $found_command; then
+                    NORMALIZED_COMMAND_ARGS+=("$1")
+                    found_command=true
+                else
+                    # Before finding a command, treat as command arg
+                    NORMALIZED_COMMAND_ARGS+=("$1")
+                fi
+                shift
+                ;;
+        esac
+    done
+}
+
 # Main kanban logic
 main() {
     log_info "=== juno-kanban Wrapper ==="
@@ -182,11 +249,26 @@ main() {
 
     log_success "Python environment ready!"
 
-    # Execute juno-kanban with all passed arguments from project root
+    # Normalize argument order (global flags before command)
+    # This allows users to write "list -f json --raw" which gets reordered to "-f json --raw list"
+    normalize_arguments "$@"
+
+    if [ "${JUNO_DEBUG:-false}" = "true" ]; then
+        echo "[DEBUG] Original args: $*" >&2
+        echo "[DEBUG] Normalized global flags: ${NORMALIZED_GLOBAL_FLAGS[*]:-<none>}" >&2
+        echo "[DEBUG] Normalized command args: ${NORMALIZED_COMMAND_ARGS[*]:-<none>}" >&2
+    fi
+
+    # Execute juno-kanban with normalized arguments from project root
     # Close stdin (redirect from /dev/null) to prevent hanging when called from tools
     # that don't provide stdin (similar to Issue #42 hook fix)
-    log_info "Executing juno-kanban: $*"
-    juno-kanban "$@" < /dev/null
+    # Build the command properly preserving argument quoting
+    log_info "Executing juno-kanban with normalized arguments"
+
+    # Execute with proper array expansion to preserve quoting
+    # Use ${arr[@]+"${arr[@]}"} pattern to handle empty arrays with set -u
+    juno-kanban ${NORMALIZED_GLOBAL_FLAGS[@]+"${NORMALIZED_GLOBAL_FLAGS[@]}"} \
+                ${NORMALIZED_COMMAND_ARGS[@]+"${NORMALIZED_COMMAND_ARGS[@]}"} < /dev/null
 }
 
 # Run main function with all arguments

package/dist/templates/scripts/run_until_completion.sh

@@ -4,11 +4,10 @@
 #
 # 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.
+# This script uses a while loop pattern: it ALWAYS runs pre-run hooks/commands,
+# then checks the kanban board for tasks BEFORE running juno-code. If no tasks
+# exist, juno-code is NOT executed. This allows pre-run hooks (e.g., Slack sync,
+# GitHub sync) to create tasks that will then be processed by juno-code.
 #
 # Usage: ./.juno_task/scripts/run_until_completion.sh [options] [juno-code arguments]
 # Example: ./.juno_task/scripts/run_until_completion.sh -s claude -i 5 -v
@@ -33,6 +32,9 @@
 #                               - Using the flag multiple times: --pre-run-hook A --pre-run-hook B
 #                               - Comma-separated: --pre-run-hook "A,B,C"
 #                               - Pipe-separated: --pre-run-hook "A|B|C"
+#   --stale-threshold <n>   - Number of stale iterations before exiting (default: 3)
+#                             Set to 0 to disable stale detection
+#   --no-stale-check        - Alias for --stale-threshold 0
 #
 # All other arguments are forwarded to juno-code.
 # The script shows all stdout/stderr from juno-code in real-time.
@@ -42,8 +44,16 @@
 #   JUNO_VERBOSE=true   - Show [RUN_UNTIL] informational messages
 #   JUNO_PRE_RUN        - Alternative way to specify pre-run command (env var)
 #   JUNO_PRE_RUN_HOOK   - Alternative way to specify pre-run hook name (env var)
+#   JUNO_STALE_THRESHOLD - Number of stale iterations before exiting (default: 3)
+#                          Set to 0 to disable stale detection
 #   (JUNO_DEBUG and JUNO_VERBOSE default to false for silent operation)
 #
+# Stale Iteration Detection:
+#   The script tracks kanban state (task IDs and statuses) between iterations.
+#   If no changes are detected for JUNO_STALE_THRESHOLD consecutive iterations,
+#   the script will exit to prevent infinite loops where the agent doesn't
+#   process any tasks.
+#
 # Created by: juno-code init command
 # Date: Auto-generated during project initialization
 
@@ -66,6 +76,12 @@ NC='\033[0m' # No Color
 SCRIPTS_DIR=".juno_task/scripts"
 KANBAN_SCRIPT="${SCRIPTS_DIR}/kanban.sh"
 
+# Stale iteration detection configuration
+# Number of consecutive iterations without kanban changes before exiting
+STALE_THRESHOLD="${JUNO_STALE_THRESHOLD:-3}"
+STALE_COUNTER=0
+PREVIOUS_KANBAN_STATE=""
+
 # Arrays to store pre-run commands, hooks, and juno-code arguments
 declare -a PRE_RUN_CMDS=()
 declare -a PRE_RUN_HOOKS=()
@@ -86,6 +102,22 @@ parse_arguments() {
                 PRE_RUN_CMDS+=("$2")
                 shift 2
                 ;;
+            --stale-threshold)
+                if [[ -z "${2:-}" ]]; then
+                    echo "[ERROR] --stale-threshold requires a number argument" >&2
+                    exit 1
+                fi
+                if ! [[ "$2" =~ ^[0-9]+$ ]]; then
+                    echo "[ERROR] --stale-threshold must be a non-negative integer, got: $2" >&2
+                    exit 1
+                fi
+                STALE_THRESHOLD="$2"
+                shift 2
+                ;;
+            --no-stale-check)
+                STALE_THRESHOLD=0
+                shift
+                ;;
             --pre-run-hook|--pre-run-hooks|--run-pre-hook|--run-pre-hooks)
                 if [[ -z "${2:-}" ]]; then
                     echo "[ERROR] $1 requires a hook name argument" >&2
@@ -327,6 +359,85 @@ PROJECT_ROOT="$( cd "$SCRIPT_DIR/../.." && pwd )"
 # Change to project root
 cd "$PROJECT_ROOT"
 
+# Function to get a snapshot of kanban state for comparison
+# Uses the summary statistics (total_tasks + status_counts) as a reliable indicator
+# of kanban state changes. This approach is more robust than parsing multi-line JSON
+# which can contain control characters that break jq parsing.
+get_kanban_state_snapshot() {
+    local snapshot=""
+
+    # Check if kanban script exists
+    if [ ! -f "$KANBAN_SCRIPT" ]; then
+        echo ""
+        return
+    fi
+
+    # Use --raw format for cleaner JSON output
+    # The --raw flag outputs: line 1 = tasks array, line 2 = summary object
+    local kanban_output
+    if kanban_output=$("$KANBAN_SCRIPT" -f json --raw list --status backlog todo in_progress 2>/dev/null); then
+        if command -v jq &> /dev/null; then
+            # Extract the summary line (last line of --raw output)
+            local summary_line
+            summary_line=$(echo "$kanban_output" | tail -1)
+
+            # Extract status counts from summary - this is a reliable state indicator
+            # Format: "backlog:N|done:N|in_progress:N|todo:N|archive:N|total:N"
+            local summary_snapshot=""
+            if [[ -n "$summary_line" ]] && echo "$summary_line" | grep -q '"summary"'; then
+                summary_snapshot=$(echo "$summary_line" | jq -r '
+                    .summary |
+                    "backlog:\(.status_counts.backlog // 0)|" +
+                    "todo:\(.status_counts.todo // 0)|" +
+                    "in_progress:\(.status_counts.in_progress // 0)|" +
+                    "done:\(.status_counts.done // 0)|" +
+                    "archive:\(.status_counts.archive // 0)|" +
+                    "total:\(.total_tasks // 0)"
+                ' 2>/dev/null)
+            fi
+
+            # Also try to extract task IDs using grep (more robust than jq for multi-line JSON)
+            # This catches cases where tasks are added/removed but counts stay the same
+            local task_ids=""
+            task_ids=$(echo "$kanban_output" | grep -o '"id": *"[^"]*"' | sed 's/"id": *"\([^"]*\)"/\1/' | sort | tr '\n' ',')
+
+            # Combine summary stats and task IDs for comprehensive state tracking
+            if [[ -n "$summary_snapshot" ]]; then
+                snapshot="${summary_snapshot}|ids:${task_ids}"
+            elif [[ -n "$task_ids" ]]; then
+                # Fallback to just task IDs if summary parsing failed
+                snapshot="ids:${task_ids}"
+            fi
+        else
+            # Fallback without jq: use grep to extract id and status fields
+            snapshot=$(echo "$kanban_output" | grep -E '"id"|"status"' | tr -d ' \n')
+        fi
+    fi
+
+    echo "$snapshot"
+}
+
+# Function to check if kanban state has changed
+# Returns 0 if state changed, 1 if stale (no change)
+check_kanban_state_changed() {
+    local current_state
+    current_state=$(get_kanban_state_snapshot)
+
+    if [ "${JUNO_DEBUG:-false}" = "true" ]; then
+        echo "[DEBUG] Previous kanban state: $PREVIOUS_KANBAN_STATE" >&2
+        echo "[DEBUG] Current kanban state: $current_state" >&2
+    fi
+
+    if [[ "$current_state" == "$PREVIOUS_KANBAN_STATE" ]]; then
+        # State is the same - no changes detected
+        return 1
+    else
+        # State changed
+        PREVIOUS_KANBAN_STATE="$current_state"
+        return 0
+    fi
+}
+
 # Function to check if there are tasks remaining
 has_remaining_tasks() {
     log_info "Checking kanban for remaining tasks..."
@@ -391,19 +502,37 @@ main() {
         log_status "Maximum iterations: unlimited"
     fi
 
+    if [ "$STALE_THRESHOLD" -gt 0 ]; then
+        log_status "Stale iteration threshold: $STALE_THRESHOLD"
+    else
+        log_status "Stale iteration detection: disabled"
+    fi
+
+    # Capture initial kanban state before first iteration
+    PREVIOUS_KANBAN_STATE=$(get_kanban_state_snapshot)
+
     # Check if we have any arguments for juno-code
     if [[ ${#JUNO_ARGS[@]} -eq 0 ]]; then
         log_warning "No arguments provided. Running juno-code with no arguments."
     fi
 
-    # Execute pre-run hooks and commands before entering the main loop
-    # Hooks run first, then explicit commands
+    # ALWAYS execute pre-run hooks and commands before checking for tasks
+    # This ensures hooks (e.g., Slack sync, GitHub sync) can create tasks
+    # that will then be processed by juno-code
     execute_pre_run_hooks
     execute_pre_run_commands
 
-    # 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
+    # Check for tasks BEFORE entering the main loop
+    # If no tasks exist after running pre-run hooks, exit gracefully
+    if ! has_remaining_tasks; then
+        log_success ""
+        log_success "=========================================="
+        log_success "No tasks found in kanban. Pre-run hooks executed, juno-code skipped."
+        log_success "=========================================="
+        exit 0
+    fi
+
+    # While loop pattern: Only run juno-code if there are tasks to process
     while true; do
         iteration=$((iteration + 1))
 
@@ -425,7 +554,6 @@ main() {
         log_status "------------------------------------------"
 
         # Run juno-code with parsed arguments (excluding --pre-run which was already processed)
-        # We run juno-code FIRST (do-while pattern), then check for remaining tasks
         if juno-code "${JUNO_ARGS[@]}"; then
             log_success "juno-code completed successfully"
         else
@@ -441,9 +569,57 @@ main() {
         # 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
+        # Check for stale iterations (no kanban state changes)
+        # This prevents infinite loops where agent doesn't process any tasks
+        if [ "$STALE_THRESHOLD" -gt 0 ]; then
+            if check_kanban_state_changed; then
+                # State changed - reset the stale counter
+                STALE_COUNTER=0
+                log_info "Kanban state changed. Stale counter reset."
+            else
+                # State unchanged - increment stale counter
+                STALE_COUNTER=$((STALE_COUNTER + 1))
+                log_warning "No kanban changes detected. Stale iteration count: $STALE_COUNTER/$STALE_THRESHOLD"
+
+                if [ "$STALE_COUNTER" -ge "$STALE_THRESHOLD" ]; then
+                    # Execute ON_STALE hook before exiting
+                    log_status ""
+                    log_status "Executing ON_STALE hook due to stale iteration detection"
+                    execute_hook_commands "ON_STALE"
+
+                    log_error ""
+                    log_error "=========================================="
+                    log_error "STALE ITERATION LIMIT REACHED"
+                    log_error "=========================================="
+                    log_error ""
+                    log_error "The script has run $STALE_COUNTER consecutive iterations"
+                    log_error "without any changes to the kanban board state."
+                    log_error ""
+                    log_error "This typically happens when:"
+                    log_error "  1. The agent doesn't recognize or prioritize remaining tasks"
+                    log_error "  2. Tasks are stuck in a state the agent cannot process"
+                    log_error "  3. There's a configuration or prompt issue"
+                    log_error ""
+                    log_error "Remaining tasks are still in the kanban system but"
+                    log_error "the agent is not making progress on them."
+                    log_error ""
+                    log_error "To adjust this threshold, set JUNO_STALE_THRESHOLD"
+                    log_error "environment variable (current: $STALE_THRESHOLD, default: 3)"
+                    log_error "Set to 0 to disable stale detection."
+                    log_error ""
+                    log_error "=========================================="
+                    # Also print to stdout so it's visible in all contexts
+                    echo ""
+                    echo "STALE ITERATION LIMIT REACHED: No kanban changes detected for $STALE_COUNTER iterations."
+                    echo "The agent is not processing remaining tasks. Exiting to prevent infinite loop."
+                    echo "Set JUNO_STALE_THRESHOLD=0 to disable this check, or increase the threshold value."
+                    echo ""
+                    exit 2
+                fi
+            fi
+        fi
+
+        # Check for remaining tasks AFTER running juno-code
         if ! has_remaining_tasks; then
             log_success ""
             log_success "=========================================="

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juno-code",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Ralph Wiggum meet Kanban! Ralph style execution for [Claude Code, Codex, Gemini, Cursor]. One task per iteration, automatic progress tracking, and git commits. Set it and let it run.",
   "keywords": [
     "Ralph",