juno-code 1.0.13 → 1.0.14

package/dist/bin/juno-code.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+# juno-code.sh
+#
+# Purpose: Shell wrapper for juno-code CLI
+#
+# This script integrates bootstrap.sh with the main CLI entry point.
+# When users run 'juno-code', this wrapper:
+# 1. Checks if project is initialized (.juno_task exists)
+# 2. If initialized: Runs bootstrap.sh to ensure Python environment is ready
+# 3. Executes the actual TypeScript CLI with all arguments
+#
+# Architecture: juno-code = shell-shim + juno-code logic
+#
+# Created by: juno-code build system
+# Auto-generated during npm build
+
+set -euo pipefail
+
+# Get the directory where this script is located
+# IMPORTANT: Resolve symlinks first (npm creates symlinks in /usr/local/bin or /opt/homebrew/bin)
+# We need the real path to find cli.mjs in the same directory
+if [ -L "${BASH_SOURCE[0]}" ]; then
+    # Follow the symlink to get the real script location
+    REAL_SCRIPT="$(readlink "${BASH_SOURCE[0]}")"
+    # If it's a relative symlink, make it absolute relative to the symlink location
+    if [[ "$REAL_SCRIPT" != /* ]]; then
+        REAL_SCRIPT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && cd "$(dirname "$REAL_SCRIPT")" && pwd)/$(basename "$REAL_SCRIPT")"
+    fi
+    SCRIPT_DIR="$(cd "$(dirname "$REAL_SCRIPT")" && pwd)"
+else
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+fi
+
+# Path to the actual CLI entrypoint (Node.js)
+CLI_ENTRYPOINT="${SCRIPT_DIR}/cli.mjs"
+
+# Path to bootstrap.sh (should be in .juno_task/scripts after init)
+BOOTSTRAP_SCRIPT=".juno_task/scripts/bootstrap.sh"
+
+# Main execution flow
+main() {
+    # Check if we're in an initialized juno-code project
+    if [ -d ".juno_task" ] && [ -f "$BOOTSTRAP_SCRIPT" ]; then
+        # Project is initialized - use bootstrap.sh to setup environment and run CLI
+        # Bootstrap.sh will:
+        # 1. Check if we're in a venv
+        # 2. Check if .venv_juno exists, create if needed
+        # 3. Activate venv if needed
+        # 4. Execute the command we pass to it
+
+        # Make sure bootstrap script is executable
+        chmod +x "$BOOTSTRAP_SCRIPT" 2>/dev/null || true
+
+        # Delegate to bootstrap.sh with node CLI as the command to execute
+        # Bootstrap will setup environment then exec our CLI
+        exec "$BOOTSTRAP_SCRIPT" node "$CLI_ENTRYPOINT" "$@"
+    else
+        # Not initialized or bootstrap missing - run CLI directly
+        # This allows 'juno-code init' to work without bootstrap
+        exec node "$CLI_ENTRYPOINT" "$@"
+    fi
+}
+
+# Run main with all arguments
+main "$@"

package/dist/index.js

@@ -75,7 +75,7 @@ var __export = (target, all) => {
 exports.version = void 0;
 var init_version = __esm({
   "src/version.ts"() {
-    exports.version = "1.0.13";
+    exports.version = "1.0.14";
   }
 });
 function isHeadlessEnvironment() {

package/dist/index.mjs

@@ -44,7 +44,7 @@ var __export = (target, all) => {
 var version;
 var init_version = __esm({
   "src/version.ts"() {
-    version = "1.0.13";
+    version = "1.0.14";
   }
 });
 function isHeadlessEnvironment() {

package/dist/templates/scripts/bootstrap.sh

@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+
+# bootstrap.sh
+#
+# Purpose: Pre-flight Python environment setup for juno-code
+#
+# This script runs before the main juno-code entrypoint and ensures:
+# 1. Python virtual environment (.venv_juno) exists
+# 2. Required Python packages are installed
+# 3. Virtual environment is activated if needed
+# 4. Main application can run with proper Python dependencies
+#
+# Usage: ./bootstrap.sh [main-entrypoint-command] [args...]
+#
+# 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 bootstrap.sh is being executed
+# User feedback: "Add a one line printing from .sh file as well so we could debug it"
+echo "[DEBUG] bootstrap.sh is being executed from: $(pwd)" >&2
+
+# Color output for better readability
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+VENV_DIR=".venv_juno"
+SCRIPTS_DIR=".juno_task/scripts"
+INSTALL_SCRIPT="${SCRIPTS_DIR}/install_requirements.sh"
+
+# Logging functions
+log_info() {
+    echo -e "${BLUE}[BOOTSTRAP]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[BOOTSTRAP]${NC} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[BOOTSTRAP]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[BOOTSTRAP]${NC} $1"
+}
+
+# Function to check if we're inside .venv_juno specifically
+# CRITICAL FIX: Don't just check for ANY venv - check if we're in .venv_juno
+# User feedback: "bootstrap.sh has the issues that install_requirements.sh used to have.
+# the detection of virtual enviroment is not correct."
+# Previous approach was too permissive - accepted ANY venv (conda, other venvs)
+# NEW APPROACH: Only return success if we're in .venv_juno specifically
+is_in_venv_juno() {
+    # Check if VIRTUAL_ENV is set and points to .venv_juno
+    if [ -n "${VIRTUAL_ENV:-}" ]; then
+        # Check if VIRTUAL_ENV path contains .venv_juno
+        if [[ "${VIRTUAL_ENV:-}" == *"/.venv_juno" ]] || [[ "${VIRTUAL_ENV:-}" == *".venv_juno"* ]]; then
+            return 0  # Inside .venv_juno
+        fi
+
+        # Check if the basename is .venv_juno
+        if [ "$(basename "${VIRTUAL_ENV:-}")" = ".venv_juno" ]; then
+            return 0  # Inside .venv_juno
+        fi
+    fi
+
+    return 1  # Not inside .venv_juno (or not in any venv)
+}
+
+# Function to activate virtual environment
+activate_venv() {
+    local venv_path="$1"
+
+    if [ ! -d "$venv_path" ]; then
+        log_error "Virtual environment not found: $venv_path"
+        return 1
+    fi
+
+    # Activate the venv
+    # shellcheck disable=SC1091
+    if [ -f "$venv_path/bin/activate" ]; then
+        source "$venv_path/bin/activate"
+        log_success "Activated virtual environment: $venv_path"
+        return 0
+    else
+        log_error "Activation script not found: $venv_path/bin/activate"
+        return 1
+    fi
+}
+
+# Function to ensure Python environment is ready
+ensure_python_environment() {
+    log_info "Checking Python environment..."
+
+    # CRITICAL FIX: Check if we're specifically in .venv_juno, not just ANY venv
+    # User feedback: "the detection of virtual enviroment is not correct"
+    # Previous logic accepted ANY venv (conda, other venvs) which was wrong
+    # NEW LOGIC: Only accept .venv_juno specifically
+
+    # Step 1: Check if we're already in .venv_juno specifically
+    if is_in_venv_juno; then
+        log_success "Already inside .venv_juno virtual environment"
+        return 0
+    fi
+
+    # Step 2: Not in .venv_juno - check if .venv_juno exists in project root
+    if [ -d "$VENV_DIR" ]; then
+        log_info "Found existing virtual environment: $VENV_DIR"
+
+        # Activate the venv
+        if activate_venv "$VENV_DIR"; then
+            return 0
+        else
+            log_error "Failed to activate virtual environment"
+            return 1
+        fi
+    fi
+
+    # Step 3: .venv_juno doesn't exist - need to create it
+    log_warning "Virtual environment not found: $VENV_DIR"
+    log_info "Running install_requirements.sh to create virtual environment..."
+
+    # Check if install_requirements.sh exists
+    if [ ! -f "$INSTALL_SCRIPT" ]; then
+        log_error "Install script not found: $INSTALL_SCRIPT"
+        log_error "Please run 'juno-code init' to initialize the project"
+        return 1
+    fi
+
+    # Make sure the script is executable
+    chmod +x "$INSTALL_SCRIPT"
+
+    # Run the install script
+    if bash "$INSTALL_SCRIPT"; then
+        log_success "Python environment setup completed successfully"
+
+        # After install, activate the venv if it was created
+        if [ -d "$VENV_DIR" ]; then
+            if activate_venv "$VENV_DIR"; then
+                return 0
+            fi
+        fi
+
+        return 0
+    else
+        log_error "Failed to run install_requirements.sh"
+        log_error "Please check the error messages above"
+        return 1
+    fi
+}
+
+# Main bootstrap logic
+main() {
+    log_info "=== juno-code Bootstrap ==="
+    echo ""
+
+    # Ensure Python environment is ready
+    if ! ensure_python_environment; then
+        log_error "Failed to setup Python environment"
+        exit 1
+    fi
+
+    echo ""
+    log_success "Python environment ready!"
+
+    # If there are additional arguments, execute them as the main entrypoint
+    if [ $# -gt 0 ]; then
+        log_info "Executing main entrypoint: $*"
+        echo ""
+
+        # Execute the main entrypoint with all arguments
+        exec "$@"
+    else
+        log_info "No main entrypoint specified - environment is ready for use"
+        log_info "To activate the virtual environment manually, run:"
+        echo ""
+        echo "    source $VENV_DIR/bin/activate"
+        echo ""
+    fi
+}
+
+# Run main function with all arguments
+main "$@"

package/dist/templates/scripts/install_requirements.sh

@@ -23,6 +23,11 @@
 
 set -euo pipefail  # Exit on error, undefined variable, or pipe failure
 
+# DEBUG OUTPUT: Show that install_requirements.sh is being executed
+# User feedback: "Add a one line printing from .sh file as well so we could debug it"
+echo "[DEBUG] install_requirements.sh is being executed from: $(pwd)" >&2
+echo "[DEBUG] .venv_juno will be created in: $(pwd)/.venv_juno" >&2
+
 # Color output for better readability
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -102,6 +107,54 @@ is_in_virtualenv() {
     return 1  # Not inside venv
 }
 
+# Function to find the best Python version (3.10-3.13, preferably 3.13)
+find_best_python() {
+    # Try to find Python in order of preference: 3.13, 3.12, 3.11, 3.10
+    local python_versions=("python3.13" "python3.12" "python3.11" "python3.10")
+
+    for py_cmd in "${python_versions[@]}"; do
+        if command -v "$py_cmd" &> /dev/null; then
+            # Verify it's actually the right version
+            local version
+            version=$($py_cmd --version 2>&1 | grep -oE '[0-9]+\.[0-9]+' | head -1)
+            local major
+            major=$(echo "$version" | cut -d'.' -f1)
+            local minor
+            minor=$(echo "$version" | cut -d'.' -f2)
+
+            # Check if version is 3.10 or higher
+            if [ "$major" -eq 3 ] && [ "$minor" -ge 10 ]; then
+                echo "$py_cmd"
+                return 0
+            fi
+        fi
+    done
+
+    # Fall back to python3 if available and check its version
+    if command -v python3 &> /dev/null; then
+        local version
+        version=$(python3 --version 2>&1 | grep -oE '[0-9]+\.[0-9]+' | head -1)
+        local major
+        major=$(echo "$version" | cut -d'.' -f1)
+        local minor
+        minor=$(echo "$version" | cut -d'.' -f2)
+
+        # Check if version is 3.10 or higher
+        if [ "$major" -eq 3 ] && [ "$minor" -ge 10 ]; then
+            echo "python3"
+            return 0
+        else
+            # Python3 exists but is too old
+            log_error "Found Python $version, but Python 3.10+ is required"
+            return 1
+        fi
+    fi
+
+    # No suitable Python found
+    log_error "No Python 3.10+ found. Please install Python 3.10, 3.11, 3.12, or 3.13 (preferably 3.13)"
+    return 1
+}
+
 # Function to check if Python is externally managed (PEP 668)
 # This is common on Ubuntu 23.04+, Debian, and other modern Linux distros
 is_externally_managed_python() {
@@ -156,30 +209,66 @@ install_with_uv() {
 
     local uv_flags="--quiet"
 
-    if is_in_virtualenv; then
-        log_info "Detected virtual environment - installing into venv"
-    elif is_externally_managed_python; then
-        log_warning "Detected externally managed Python (PEP 668) - Ubuntu/Debian system"
-        log_info "Creating temporary virtual environment for installation..."
+    # CRITICAL FIX: Properly detect if uv will work in the current environment
+    # User feedback: "Maybe the way you are verifying being inside venv by uv is not correct !!!"
+    # Previous approach failed because uv pip list doesn't reliably indicate venv compatibility
+    # NEW APPROACH: Always create .venv_juno unless we're already inside it
+
+    local venv_path=".venv_juno"
+    local need_venv=true
+
+    # Check if we're already inside .venv_juno
+    if [ -n "${VIRTUAL_ENV:-}" ] && ( [[ "${VIRTUAL_ENV:-}" == *"/.venv_juno" ]] || [[ "${VIRTUAL_ENV:-}" == *".venv_juno"* ]] ); then
+        log_info "Already inside .venv_juno virtual environment"
+        need_venv=false
+    # Check if we're in .venv_juno by checking the activate script path
+    elif [ -n "${VIRTUAL_ENV:-}" ] && [ "$(basename "${VIRTUAL_ENV:-}")" = ".venv_juno" ]; then
+        log_info "Already inside .venv_juno virtual environment"
+        need_venv=false
+    fi
+
+    # If we need a venv, create and activate .venv_juno
+    if [ "$need_venv" = true ]; then
+        log_info "Creating/using .venv_juno virtual environment for reliable uv installation..."
+
+        # Find best Python version (3.10-3.13, preferably 3.13)
+        local python_cmd
+        if ! python_cmd=$(find_best_python); then
+            log_error "Cannot create venv: No suitable Python version found"
+            log_info "Please install Python 3.10+ (preferably Python 3.13)"
+            log_info "  Mac: brew install python@3.13"
+            log_info "  Ubuntu/Debian: sudo apt install python3.13 python3.13-venv"
+            return 1
+        fi
+
+        local version
+        version=$($python_cmd --version 2>&1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+')
+        log_info "Using Python $version for virtual environment"
 
         # Create a project-local venv if it doesn't exist
-        local venv_path=".juno_venv"
         if [ ! -d "$venv_path" ]; then
-            if ! python3 -m venv "$venv_path" 2>/dev/null; then
+            log_info "Creating virtual environment with $python_cmd..."
+            if ! $python_cmd -m venv "$venv_path" 2>/dev/null; then
                 log_error "Failed to create virtual environment"
-                log_info "Please install python3-venv: sudo apt install python3-venv python3-full"
+                log_info "Please ensure python venv module is installed:"
+                log_info "  Mac: brew install python@3.13"
+                log_info "  Ubuntu/Debian: sudo apt install python3.13-venv python3-full"
                 return 1
             fi
-            log_success "Created virtual environment at $venv_path"
+            log_success "Created virtual environment at $venv_path with Python $version"
+        else
+            log_info "Using existing virtual environment at $venv_path"
         fi
 
         # Activate the venv for this script
         # shellcheck disable=SC1091
-        source "$venv_path/bin/activate"
-        log_success "Activated virtual environment"
-    else
-        log_info "Not in a virtual environment - using --system flag for system-wide installation"
-        uv_flags="--quiet --system"
+        if [ -f "$venv_path/bin/activate" ]; then
+            source "$venv_path/bin/activate"
+            log_success "Activated virtual environment - uv will now install into .venv_juno"
+        else
+            log_error "Virtual environment activation script not found"
+            return 1
+        fi
     fi
 
     local failed_packages=()
@@ -217,20 +306,32 @@ install_with_pip() {
         fi
     fi
 
-    # Handle externally managed Python
+    # Handle externally managed Python or missing venv
     if ! is_in_virtualenv && is_externally_managed_python; then
         log_warning "Detected externally managed Python (PEP 668) - Ubuntu/Debian system"
-        log_info "Creating temporary virtual environment for installation..."
+        log_info "Creating virtual environment for installation..."
+
+        # Find best Python version (3.10-3.13, preferably 3.13)
+        if ! python_cmd=$(find_best_python); then
+            log_error "Cannot create venv: No suitable Python version found"
+            log_info "Please install Python 3.10+ (preferably Python 3.13)"
+            log_info "  Ubuntu/Debian: sudo apt install python3.13 python3.13-venv"
+            return 1
+        fi
+
+        local version
+        version=$($python_cmd --version 2>&1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+')
+        log_info "Using Python $version for virtual environment"
 
         # Create a project-local venv if it doesn't exist
-        local venv_path=".juno_venv"
+        local venv_path=".venv_juno"
         if [ ! -d "$venv_path" ]; then
             if ! $python_cmd -m venv "$venv_path" 2>/dev/null; then
                 log_error "Failed to create virtual environment"
-                log_info "Please install python3-venv: sudo apt install python3-venv python3-full"
+                log_info "Please install python3-venv (Linux: sudo apt install python3.13-venv python3-full)"
                 return 1
             fi
-            log_success "Created virtual environment at $venv_path"
+            log_success "Created virtual environment at $venv_path with Python $version"
         fi
 
         # Activate the venv for this script
@@ -353,9 +454,9 @@ main() {
         if install_with_uv; then
             echo ""
             log_success "All packages installed successfully using 'uv'!"
-            if [ -d ".juno_venv" ]; then
-                log_info "Packages installed in virtual environment: .juno_venv"
-                log_info "To use them, activate the venv: source .juno_venv/bin/activate"
+            if [ -d ".venv_juno" ]; then
+                log_info "Packages installed in virtual environment: .venv_juno"
+                log_info "To use them, activate the venv: source .venv_juno/bin/activate"
             fi
             echo ""
             exit 0
@@ -367,9 +468,9 @@ main() {
         if install_with_pip; then
             echo ""
             log_success "All packages installed successfully using 'pip'!"
-            if [ -d ".juno_venv" ]; then
-                log_info "Packages installed in virtual environment: .juno_venv"
-                log_info "To use them, activate the venv: source .juno_venv/bin/activate"
+            if [ -d ".venv_juno" ]; then
+                log_info "Packages installed in virtual environment: .venv_juno"
+                log_info "To use them, activate the venv: source .venv_juno/bin/activate"
             fi
             echo ""
             exit 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juno-code",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "AI Subagent Orchestration CLI - Professional TypeScript CLI for AI-powered code intelligence, MCP server orchestration, and subagent collaboration",
   "keywords": [
     "ai",
@@ -35,6 +35,9 @@
     "README.md",
     "CHANGELOG.md"
   ],
+  "scripts": {
+    "build:copy-wrapper": "node -e \"const fs = require('fs-extra'); fs.copySync('src/bin/juno-code.sh', 'dist/bin/juno-code.sh'); fs.chmodSync('dist/bin/juno-code.sh', 0o755);\""
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.20.0",
     "chalk": "^5.3.0",