openclacky 0.9.26 → 0.9.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65dad1ba4790fcffb30157bcc74a05a9f9cbd3e341ead0e007e6c768b0c11fd1
-  data.tar.gz: f507ade251d206b073eb1b88c236d8905e9c986718d93c62cf3f2b575fa908bb
+  metadata.gz: fc55d904ebe65b0a5d464481ef0075dcb3271e8ccd56143b3ea2b04600100a41
+  data.tar.gz: e3aab9ed25ac14fc964eff4b2032322679802bb8f627286e60ab7bdc14d80289
 SHA512:
-  metadata.gz: f70df4500b95cd35c2a3fb245e384f94bbf4051da6528d6b9bd76a9a38e81838844cc68276ab0b7fc3833982252b9d61c1c5c3b414e22422049e2a91f2c24a4b
-  data.tar.gz: 6cd678e1288d06f6997c01c056b898c900ba9b7fcde2bacdd3a35b113d0ab4d33d3e5e2c2fde9a31d1c9c351b615b93f28bcfa305eb7489b4deda1c1c801ce45
+  metadata.gz: 361f37d7bcb4546d0ff92783bdc3018068cb47d411b80595fdcd003c8d62f007e9483ccce46292f7b1fe5a9828ef4e9779f7553ad747e21c388bf39de0b12487
+  data.tar.gz: 04db6b2d4d939d58e49265dc3c000b82455b857e1634987c4c5218ae716e7ed9d4e7f7950964d56aa484c29ee11290b32721e3000c1bc51022edee14eb417d2b

data/.clacky/skills/gem-release/SKILL.md

@@ -132,10 +132,13 @@ To use this skill, simply say:
 
 6. **Sync scripts/ to OSS**
 
-   After updating latest.txt, sync all files in `scripts/` to OSS so users always get the latest install scripts:
+   After updating latest.txt, first rebuild all shell scripts from templates, then sync to OSS:
 
    ```bash
-   # Upload each script file to OSS
+   # Step 1: Rebuild .sh files from .sh.cc templates
+   bash scripts/build/build.sh
+
+   # Step 2: Upload each script file to OSS
    for script in scripts/*; do
      coscli cp "$script" cos://clackyai-1258723534/clacky-ai/openclacky/main/scripts/$(basename "$script")
    done
@@ -144,7 +147,7 @@ To use this skill, simply say:
    curl -fsSL https://oss.1024code.com/clacky-ai/openclacky/main/scripts/install.sh | head -5
    ```
 
-   This ensures `scripts/install.sh`, `scripts/install_simple.sh`, `scripts/install.ps1`, `scripts/uninstall.sh` and any future scripts are all mirrored on OSS.
+   This ensures `scripts/install.sh`, `scripts/install_simple.sh`, `scripts/install.ps1`, `scripts/uninstall.sh` and any future scripts are compiled from latest templates and mirrored on OSS.
 
    > **Prerequisite**: Same `coscli` setup as above
 
@@ -338,7 +341,8 @@ echo "X.Y.Z" > /tmp/latest.txt
 coscli cp /tmp/latest.txt cos://clackyai-1258723534/openclacky/latest.txt
 curl -fsSL https://oss.1024code.com/openclacky/latest.txt  # verify
 
-# Sync scripts/ to OSS
+# Sync scripts/ to OSS (build from templates first)
+bash scripts/build/build.sh
 for script in scripts/*; do
   coscli cp "$script" cos://clackyai-1258723534/clacky-ai/openclacky/main/scripts/$(basename "$script")
 done

data/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.27] - 2026-04-07
+
+### Added
+- **Image understanding in file_reader**: the agent can now read and analyse images (PNG, JPG, GIF, WebP) by sending them to the vision API — just attach or reference an image file
+- **Image auto-resize before upload**: large images are automatically resized to fit within model limits (max 5 MB base64), so vision requests no longer fail on high-resolution files
+- **Rails project installer script**: new `install_rails_deps.sh` script sets up a complete Ruby on Rails development environment (Ruby, Bundler, Node, Yarn, PostgreSQL) in one command
+- **Uninstall script**: new `scripts/uninstall.sh` to cleanly remove the openclacky gem and its associated files
+- **Shell script build system**: `scripts/build/` now contains a template compiler (`.sh.cc` → `.sh`) with dependency checking — install scripts are generated from composable library modules
+- **stdout streaming in Web UI**: agent tool output and shell results are now streamed live to the browser as they arrive, rather than waiting for a full response
+- **Ctrl+O shortcut in CLI**: pressing Ctrl+O in the terminal UI opens a file/output viewer for the current session
+
+### Improved
+- **Smart error recovery on 400 responses**: the agent now rolls back its message history when an API request is rejected as malformed (BadRequestError), preventing the same bad message from being replayed on every subsequent turn
+- **Brand skill reliability**: brand skills now auto-retry on transient failures and fall back gracefully if the remote skill is temporarily unavailable
+- **Shell tool RC file loading**: shell commands now correctly source `.bashrc` / `.zshrc` so user-defined aliases and environment variables are available inside tool executions
+- **Shell UTF-8 encoding**: fixed a warning about character encoding when shell output contains non-ASCII characters
+
+### Fixed
+- **Shell UTF-8 warning suppression**: eliminated noisy encoding warnings that appeared in shell tool output on some macOS setups
+
+### More
+- Lite mode configuration groundwork for clackyai platform
+- Rails new-project skill updated with improved environment checker
+- `new` skill improvements: http_server integration and tool category support
+
 ## [0.9.26] - 2026-04-03
 
 ### Added

data/lib/clacky/agent/skill_manager.rb

@@ -379,9 +379,6 @@ module Clacky
       # @param arguments [String] Arguments for the skill
       # @return [String] Summary of subagent execution
       def execute_skill_with_subagent(skill, arguments)
-        # Log subagent fork
-        @ui&.show_info("Subagent start: #{skill.identifier}")
-
         # For encrypted brand skills with supporting scripts: decrypt to a tmpdir.
         # Subagent path has a clear boundary (subagent.run returns), so we shred inline
         # rather than registering on the parent agent.
@@ -406,6 +403,10 @@ module Clacky
           system_prompt_suffix: skill_instructions
         )
 
+        # Log which model the subagent is actually using (may differ from requested
+        # when "lite" falls back to default due to no lite model configured)
+        @ui&.show_info("Subagent start: #{skill.identifier} [#{subagent.current_model_info[:model]}]")
+
         # Run subagent with the actual task as the sole user turn.
         # If the user typed the skill command with no arguments (e.g. "/jade-appraisal"),
         # use a generic trigger phrase so the user message is never empty.
@@ -446,8 +447,14 @@ module Clacky
           m[:skill_name] = skill.identifier
         end
 
+        # Merge subagent cost into parent agent's total so the sessionbar reflects
+        # the real cumulative spend across all subagents
+        subagent_cost = result[:total_cost_usd] || 0.0
+        @total_cost += subagent_cost
+        @ui&.update_sessionbar(cost: @total_cost)
+
         # Log completion
-        @ui&.show_info("Subagent completed: #{result[:iterations]} iterations, $#{result[:total_cost_usd].round(4)}")
+        @ui&.show_info("Subagent completed: #{result[:iterations]} iterations, $#{subagent_cost.round(4)} (total: $#{@total_cost.round(4)})")
 
         # Return summary as the skill execution result
         summary

data/lib/clacky/agent.rb

@@ -432,6 +432,11 @@ module Clacky
         }
         Clacky::Logger.error("agent_run_error", error: e)
 
+        # 400 errors mean our request was malformed — roll back history so the bad
+        # message is not replayed on the next user turn.
+        # Other errors (auth, network, etc.) leave history intact for retry.
+        @pending_error_rollback = true if e.is_a?(Clacky::BadRequestError)
+
         # Build error result for session data, but let CLI handle error display
         result = build_result(:error, error: e.message)  # rubocop:disable Lint/UselessAssignment
         raise
@@ -647,35 +652,24 @@ module Clacky
           # Automatic progress display after 2 seconds for any tool execution
           progress_shown = false
           progress_timer = nil
-          output_buffer = nil
 
           if @ui
             progress_message = build_tool_progress_message(call[:name], args)
 
-            # For shell commands, create shared output buffer
-            if call[:name] == "shell" || call[:name] == "safe_shell"
-              output_buffer = { content: "", timestamp: Time.now }
-              args[:output_buffer] = output_buffer
+            # For shell/safe_shell: inject on_output callback for real-time stdout streaming.
+            # The callback fires immediately on each read_nonblock chunk — no polling delay.
+            if (call[:name] == "shell" || call[:name] == "safe_shell") &&
+               @ui.respond_to?(:show_tool_stdout)
+              args[:on_output] = ->(stream, data) {
+                @ui.show_tool_stdout([data]) if stream == :stdout
+              }
             end
 
             progress_timer = Thread.new do
               sleep 2
-              @ui.show_progress(progress_message, prefix_newline: false, output_buffer: output_buffer)
+              @ui.show_progress(progress_message, prefix_newline: false)
               progress_shown = true
-
-              # For shell commands: stream new stdout lines to WebUI as they arrive
-              if output_buffer && @ui.respond_to?(:show_tool_stdout)
-                last_sent_count = 0
-                loop do
-                  sleep 1
-                  stdout_lines = output_buffer[:stdout_lines]&.to_a || []
-                  new_lines = stdout_lines[last_sent_count..]
-                  if new_lines && !new_lines.empty?
-                    @ui.show_tool_stdout(new_lines)
-                    last_sent_count = stdout_lines.size
-                  end
-                end
-              end
+              # Streaming is handled by on_output callback — no polling loop needed here
             end
           end
 

data/lib/clacky/agent_config.rb

@@ -222,9 +222,45 @@ module Clacky
         end
       end
 
+      # Auto-inject lite model from provider preset when:
+      # 1. A default model exists
+      # 2. No lite model is configured yet (neither in file nor env)
+      # 3. The default model's provider has a known lite_model
+      # The injected lite model is runtime-only (not persisted to config.yml)
+      inject_provider_lite_model(models)
+
       new(models: models)
     end
 
+    # Auto-inject a lite model entry if the default model's provider supports one
+    # and no lite model is already present. The injected entry reuses the same
+    # api_key and base_url as the default model — only the model name differs.
+    # @param models [Array<Hash>] mutable models array (modified in-place)
+    private_class_method def self.inject_provider_lite_model(models)
+      return if models.any? { |m| m["type"] == "lite" }
+
+      default_model = models.find { |m| m["type"] == "default" } || models.first
+      return unless default_model
+
+      provider_id = Clacky::Providers.find_by_base_url(default_model["base_url"])
+      return unless provider_id
+
+      lite_model_name = Clacky::Providers.lite_model(provider_id)
+      return unless lite_model_name
+
+      # Don't inject if the default model IS the lite model
+      return if default_model["model"] == lite_model_name
+
+      models << {
+        "api_key"          => default_model["api_key"],
+        "base_url"         => default_model["base_url"],
+        "model"            => lite_model_name,
+        "anthropic_format" => default_model["anthropic_format"] || false,
+        "type"             => "lite",
+        "auto_injected"    => true  # Mark as auto-injected (not saved to file)
+      }
+    end
+
     # Save configuration to file
     # Deep copy — models array contains mutable Hashes, so a shallow dup would
     # let the copy share the same Hash objects with the original, causing
@@ -244,8 +280,11 @@ module Clacky
     end
 
     # Convert to YAML format (top-level array)
+    # Auto-injected lite models (auto_injected: true) are excluded from persistence —
+    # they are regenerated at load time from the provider preset.
     def to_yaml
-      YAML.dump(@models)
+      persistable = @models.reject { |m| m["auto_injected"] }
+      YAML.dump(persistable)
     end
 
     # Check if any model is configured

data/lib/clacky/brand_config.rb

@@ -33,11 +33,6 @@ module Clacky
     CONFIG_DIR  = File.join(Dir.home, ".clacky")
     BRAND_FILE  = File.join(CONFIG_DIR, "brand.yml")
 
-    # OpenClacky Cloud API base URL.
-    # Override with CLACKY_LICENSE_SERVER env var for local development:
-    #   CLACKY_LICENSE_SERVER=http://localhost:3000 bundle exec ruby bin/clacky server
-    API_BASE_URL = ENV.fetch("CLACKY_LICENSE_SERVER", "https://www.openclacky.com")
-
     # How often to send a heartbeat (seconds) — once per day
     HEARTBEAT_INTERVAL = 86_400
 
@@ -285,9 +280,6 @@ module Clacky
       return { success: false, error: "License not activated" } unless activated?
       return { success: false, error: "User license required to upload skills" } unless user_licensed?
 
-      require "net/http"
-      require "uri"
-
       # The client skills API uses @license_user_id (the platform owner user id),
       # NOT the user_id embedded in the license key structure.
       user_id   = @license_user_id.to_s
@@ -299,23 +291,17 @@ module Clacky
 
       # POST /api/v1/client/skills         → create (first upload)
       # PATCH /api/v1/client/skills/:name → update (force overwrite)
-      if force
-        uri = URI.parse("#{API_BASE_URL}/api/v1/client/skills/#{URI.encode_www_form_component(skill_name)}")
-      else
-        uri = URI.parse("#{API_BASE_URL}/api/v1/client/skills")
-      end
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl       = uri.scheme == "https"
-      http.open_timeout  = 15
-      http.read_timeout  = 60
+      path = if force
+               "/api/v1/client/skills/#{URI.encode_www_form_component(skill_name)}"
+             else
+               "/api/v1/client/skills"
+             end
 
       boundary = "----ClackySkillUpload#{SecureRandom.hex(8)}"
       crlf     = "\r\n"
 
-      # Build multipart body as a binary string using Array#pack so that null bytes
-      # in the ZIP data are preserved. Net::HTTP's body= raises on null bytes in
-      # the body string — avoid by writing all parts as binary and using body_stream.
+      # Build multipart body as a binary string so that null bytes in the ZIP
+      # data are preserved. All parts are joined as binary before sending.
       parts = []
       fields = {
         "key_hash"  => key_hash,
@@ -339,34 +325,34 @@ module Clacky
       parts << "--#{boundary}#{crlf}"
       parts << "Content-Disposition: form-data; name=\"skill_zip\"; filename=\"#{skill_name}.zip\"#{crlf}"
       parts << "Content-Type: application/zip#{crlf}#{crlf}"
-      # zip_data is binary — keep as-is
       parts << zip_data.b
       parts << "#{crlf}--#{boundary}--#{crlf}"
 
-      # Concatenate all parts as a single binary string
-      body_bytes = parts.map { |p| p.b }.join
+      body_bytes = parts.map(&:b).join
 
-      request = force ? Net::HTTP::Patch.new(uri.path) : Net::HTTP::Post.new(uri.path)
-      request["Content-Type"]   = "multipart/form-data; boundary=#{boundary}"
-      request["Content-Length"] = body_bytes.bytesize.to_s
-      request.body_stream = StringIO.new(body_bytes)
+      # Delegate sending (with retry + failover) to PlatformHttpClient.
+      # Uploads can be slow so we allow a generous 60-second read timeout.
+      result = if force
+                 platform_client.multipart_patch(path, body_bytes, boundary, read_timeout: 60)
+               else
+                 platform_client.multipart_post(path, body_bytes, boundary, read_timeout: 60)
+               end
 
-      response = http.request(request)
-      parsed   = JSON.parse(response.body) rescue {}
-
-      code_i = response.code.to_i
-      if code_i == 200 || code_i == 201
+      if result[:success]
+        parsed = result[:data]
         { success: true, skill: parsed["skill"] }
       else
-        # Server returns { status: "error", code: "...", errors: [...] }
-        code   = parsed["code"] || parsed["error"]
-        errors = parsed["errors"]&.join(", ")
-        msg    = [code, errors].compact.join(": ")
-        msg    = "Upload failed (HTTP #{response.code})" if msg.empty?
-
-        # Detect "already exists" conflicts (HTTP 409 or name_taken error code)
-        # so the caller can offer the user an overwrite option.
-        already_exists = code_i == 409 || code.to_s.include?("name_taken") || code.to_s.include?("already")
+        # Propagate structured error from PlatformHttpClient
+        body   = result[:data] || {}
+        code   = body["code"] || body["error"]
+        errors = body["errors"]&.join(", ")
+        msg    = result[:error] || [code, errors].compact.join(": ")
+        msg    = "Upload failed" if msg.to_s.strip.empty?
+
+        # Detect "already exists" conflicts so the caller can offer an overwrite option.
+        already_exists = body["code"].to_s.include?("name_taken") ||
+                         body["code"].to_s.include?("already") ||
+                         result[:error].to_s.include?("HTTP 409")
         { success: false, error: msg, already_exists: already_exists }
       end
     rescue StandardError => e
@@ -1158,49 +1144,17 @@ module Clacky
       nil
     end
 
-    # POST JSON to the API and return { success:, data:, error: }.
+    # POST JSON to the platform API with automatic retry and domain failover.
+    # Returns { success:, data:, error: }.
     private def api_post(path, payload)
-      require "net/http"
-      require "uri"
-
-      uri = URI.parse("#{API_BASE_URL}#{path}")
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == "https"
-      http.open_timeout = 10
-      http.read_timeout = 15
-
-      request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
-      request.body = JSON.generate(payload)
-
-      response = http.request(request)
-      body     = JSON.parse(response.body) rescue {}
-
-      if response.code.to_i == 200
-        { success: true, data: body["data"] || body }
-      else
-        error_msg = map_api_error(body["code"])
-        { success: false, error: error_msg, data: body }
-      end
-    rescue StandardError => e
-      { success: false, error: "Network error: #{e.message}", data: {} }
+      platform_client.post(path, payload)
     end
 
-    # Map API error codes to human-readable messages.
-    API_ERROR_MESSAGES = {
-      "invalid_proof"        => "Invalid license key — please check and try again.",
-      "invalid_signature"    => "Invalid request signature.",
-      "nonce_replayed"       => "Duplicate request detected. Please try again.",
-      "timestamp_expired"    => "System clock is out of sync. Please adjust your time settings.",
-      "license_revoked"      => "This license has been revoked. Please contact support.",
-      "license_expired"      => "This license has expired. Please renew to continue.",
-      "device_limit_reached" => "Device limit reached for this license.",
-      "device_revoked"       => "This device has been revoked from the license.",
-      "invalid_license"      => "License key not found. Please verify the key.",
-      "device_not_found"     => "Device not registered. Please re-activate."
-    }.freeze
-
-    private def map_api_error(code)
-      API_ERROR_MESSAGES[code] || "Activation failed (#{code || 'unknown error'}). Please contact support."
+    # Lazy-initialised PlatformHttpClient, respecting CLACKY_LICENSE_SERVER override.
+    private def platform_client
+      @platform_client ||= Clacky::PlatformHttpClient.new(
+        base_url: ENV["CLACKY_LICENSE_SERVER"]
+      )
     end
   end
 end

data/lib/clacky/client.rb

@@ -291,9 +291,19 @@ module Clacky
 
       case response.status
       when 400
-        hint = error_message.downcase.match?(/unavailable|quota/) ? " (possibly out of credits)" : ""
-        raise AgentError, "API request failed (400): #{error_message}#{hint}"
+        # Well-behaved APIs (Anthropic, OpenAI) never put quota/availability issues in 400.
+        # However, some proxy/relay providers do — so we inspect the message first.
+        # Also, Bedrock returns ThrottlingException as 400 instead of 429.
+        if error_message.match?(/ThrottlingException|unavailable|quota/i)
+          hint = error_message.match?(/quota/i) ? " (possibly out of credits)" : ""
+          raise RetryableError, "Rate limit or service issue (400): #{error_message}#{hint}"
+        end
+
+        # True bad request — our message was malformed. Roll back history so the
+        # broken message is not replayed on the next user turn.
+        raise BadRequestError, "API request failed (400): #{error_message}"
       when 401 then raise AgentError, "Invalid API key"
+      when 402 then raise AgentError, "Billing or payment issue (possibly out of credits): #{error_message}"
       when 403 then raise AgentError, "Access denied: #{error_message}"
       when 404 then raise AgentError, "API endpoint not found: #{error_message}"
       when 429 then raise RetryableError, "Rate limit exceeded, please wait a moment"

data/lib/clacky/default_skills/code-explorer/SKILL.md

@@ -3,6 +3,7 @@ name: code-explorer
 description: Use this skill when exploring, analyzing, or understanding project/code structure. Required for tasks like "analyze project", "explore codebase", "understand how X works".
 agent: coding
 fork_agent: true
+model: lite
 forbidden_tools:
   - write
   - edit

data/lib/clacky/default_skills/new/SKILL.md

@@ -16,6 +16,26 @@ When user wants to create a new Rails project:
 
 ## Process Steps
 
+### 0. Ask Project Type and Requirement
+Before doing anything, use `request_user_feedback` to ask the user two things:
+
+```
+project_type: "demo" or "production"
+requirement: one-sentence description of what they want to build
+```
+
+Card content:
+- Title: "🚀 New Project"
+- Two options for project type:
+  - **⚡ Demo** — no database, AI builds freely, quick prototype
+  - **🏗️ Production** — real app, ready to deploy, full Rails setup
+- One text input: "Describe your project in one sentence"
+- Confirm button: "Let's go!"
+
+**Based on user's choice:**
+- If **Demo**: do NOT follow the Rails setup steps below. Instead, freely build a simple HTML/CSS/JS (or React) prototype directly in the working directory based on their requirement. Use your creativity.
+- If **Production**: continue with steps 1–3 below (full Rails flow).
+
 ### 1. Check Directory Before Starting
 Before running the setup script, check if current directory is empty:
 - Use glob tool to check if directory has files: `glob("*", base_path: ".")`
@@ -38,7 +58,7 @@ The script will automatically:
 
 **Step 2: Check Environment**
 - Run rails_env_checker.sh to verify dependencies:
-  - Ruby >= 3.0.0 (must be pre-installed)
+  - Ruby >= 3.3.0 (auto-installed via mise if missing or too old — supports CN mirrors)
   - Node.js >= 22.0.0 (will install automatically if missing on macOS/Ubuntu)
   - PostgreSQL (will install automatically if missing on macOS/Ubuntu)
 - Script automatically installs missing dependencies without prompting
@@ -76,7 +96,7 @@ What would you like to develop next?
 ## Error Handling
 - Directory not empty → Ask user confirmation, abort if declined
 - Git clone fails → Check network connection, verify repository URL
-- Ruby not installed → Error message, user must install Ruby 3.x manually
+- Ruby < 3.3 or missing → **Automatically installs Ruby 3.3 via mise** (with CN mirror support); exits with instructions if mise install fails
 - Node.js < 22 → Script installs automatically (macOS/Ubuntu)
 - PostgreSQL missing → Script installs automatically (macOS/Ubuntu)
 - bin/setup fails → Show error, suggest running `./bin/setup` manually

data/lib/clacky/default_skills/new/scripts/create_rails_project.sh

@@ -33,16 +33,13 @@ print_step() {
     echo -e "\n${BLUE}==>${NC} $1"
 }
 
-# Get script directory
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
 # Check if current directory is empty
 check_current_directory() {
     print_step "Checking current directory..."
-    
+
     local current_dir=$(pwd)
     print_info "Working in: $current_dir"
-    
+
     # Check if directory is empty (silently continue if not)
     if [ "$(ls -A .)" ]; then
         print_warning "Current directory is not empty - continuing anyway"
@@ -54,11 +51,11 @@ check_current_directory() {
 # Clone template to current directory
 clone_template() {
     print_step "Cloning Rails template..."
-    
+
     # Create temporary directory
     local temp_dir=$(mktemp -d)
     print_info "Using temporary directory: $temp_dir"
-    
+
     # Clone template to temp directory
     print_info "Downloading template from GitHub..."
     if git clone https://github.com/clacky-ai/rails-template-7x-starter.git "$temp_dir" >/dev/null 2>&1; then
@@ -68,18 +65,18 @@ clone_template() {
         rm -rf "$temp_dir"
         exit 1
     fi
-    
+
     # Move all files to current directory
     print_info "Moving files to current directory..."
     mv "$temp_dir"/* "$temp_dir"/.* . 2>/dev/null || true
-    
+
     # Delete .git directory
     rm -rf .git
-    
+
     # Clean up temp directory
     rm -rf "$temp_dir"
     print_success "Template files copied to current directory"
-    
+
     # Initialize new git repository
     print_info "Initializing git repository..."
     git init > /dev/null 2>&1
@@ -88,37 +85,37 @@ clone_template() {
     print_success "Git repository initialized"
 }
 
-# Check environment dependencies
+# Check and install environment dependencies
 check_environment() {
     print_step "Checking environment dependencies..."
-    
-    # Run rails_env_checker.sh
-    if [ -f "$SCRIPT_DIR/rails_env_checker.sh" ]; then
-        if bash "$SCRIPT_DIR/rails_env_checker.sh"; then
-            print_success "Environment check passed"
-            return 0
-        else
-            print_error "Environment check failed"
-            return 1
-        fi
-    else
-        print_warning "rails_env_checker.sh not found, skipping environment check"
-        print_info "Please ensure you have Ruby 3.x, Node.js 22+, and PostgreSQL installed"
+
+    local installer="$HOME/.clacky/scripts/install_rails_deps.sh"
+    if [ ! -f "$installer" ]; then
+        print_warning "install_rails_deps.sh not found at $installer"
+        print_info "Please ensure Ruby 3.3+, Node.js 22+, and PostgreSQL are installed"
+        return 1
+    fi
+
+    if bash "$installer"; then
+        print_success "Environment ready"
         return 0
+    else
+        print_error "Environment setup failed"
+        return 1
     fi
 }
 
 # Run project setup
 run_project_setup() {
     print_step "Running project setup..."
-    
+
     if [ ! -f "./bin/setup" ]; then
         print_error "bin/setup not found"
         return 1
     fi
-    
+
     chmod +x ./bin/setup
-    
+
     if ./bin/setup; then
         print_success "Project setup completed"
         return 0
@@ -139,27 +136,27 @@ main() {
     echo "║                                                           ║"
     echo "╚═══════════════════════════════════════════════════════════╝"
     echo ""
-    
+
     # Check current directory
     check_current_directory
-    
+
     # Clone template
     if ! clone_template; then
         exit 1
     fi
-    
+
     # Check environment
     if ! check_environment; then
         print_error "Please fix environment issues and run ./bin/setup manually"
         exit 1
     fi
-    
+
     # Run project setup
     if ! run_project_setup; then
         print_error "Setup failed. You can try running './bin/setup' manually"
         exit 1
     fi
-    
+
     # Project is ready
     echo ""
     echo "╔═══════════════════════════════════════════════════════════╗"