aidp 0.5.0 → 0.7.0

data/lib/aidp/analyze/agent_tool_executor.rb

@@ -30,17 +30,11 @@ module Aidp
 
       log_execution_start(execution_id, tool_name, options)
 
-      begin
-        result = execute_tool_with_timeout(tool_name, options)
-        execution_time = Time.now - start_time
-
-        log_execution_success(execution_id, tool_name, execution_time, result)
-        result
-      rescue => e
-        execution_time = Time.now - start_time
-        log_execution_error(execution_id, tool_name, execution_time, e)
-        raise
-      end
+      result = execute_tool_with_timeout(tool_name, options)
+      execution_time = Time.now - start_time
+
+      log_execution_success(execution_id, tool_name, execution_time, result)
+      result
     end
 
     # Execute multiple tools in parallel

data/lib/aidp/analyze/data_retention_manager.rb

@@ -51,11 +51,6 @@ module Aidp
           when "immediate"
             results[:cleaned_data][data_type] = clean_immediately(data_type, dry_run)
           end
-        rescue => e
-          results[:errors] << {
-            data_type: data_type,
-            error: e.message
-          }
         end
 
         results

data/lib/aidp/analyze/error_handler.rb

@@ -116,9 +116,6 @@ module Aidp
 
       def continue_with_partial_data(operation, partial_data_handler)
         operation.call
-      rescue => e
-        logger.warn("Operation failed, continuing with partial data: #{e.message}")
-        partial_data_handler.call(e)
       end
 
       # Error reporting and statistics

data/lib/aidp/analyze/export_manager.rb

@@ -158,13 +158,6 @@ module Aidp
         size: File.size(output_path),
         generated_at: Time.now
       }
-    rescue => e
-      {
-        success: false,
-        error: e.message,
-        format: format,
-        generated_at: Time.now
-      }
     end
 
     def format_export_data(data, options)

data/lib/aidp/analyze/incremental_analyzer.rb

@@ -171,12 +171,7 @@ module Aidp
         state_file = get_state_file_path(analysis_type)
         return create_initial_state(analysis_type) unless File.exist?(state_file)
 
-        begin
-          YAML.load_file(state_file) || create_initial_state(analysis_type)
-        rescue => e
-          puts "Warning: Could not load analysis state: #{e.message}"
-          create_initial_state(analysis_type)
-        end
+        YAML.load_file(state_file) || create_initial_state(analysis_type)
       end
 
       def save_analysis_state(analysis_type, state)
@@ -367,11 +362,6 @@ module Aidp
         plan[:components].each do |component|
           component_result = analyze_component(component, plan[:analysis_type], options)
           results[:results][component] = component_result
-        rescue => e
-          results[:errors] << {
-            component: component,
-            error: e.message
-          }
         end
 
         results[:end_time] = Time.now

data/lib/aidp/analyze/large_analysis_progress.rb

@@ -292,11 +292,6 @@ module Aidp
         success: true,
         imported_progress: @current_progress
       }
-    rescue => e
-      {
-        success: false,
-        error: e.message
-      }
     end
 
     private

data/lib/aidp/analyze/memory_manager.rb

@@ -54,38 +54,24 @@ module Aidp
         errors: []
       }
 
-      begin
-        dataset.each_with_index do |item, index|
-          # Check memory usage
-          current_memory = get_memory_usage
-          results[:memory_usage] << current_memory
+      dataset.each_with_index do |item, index|
+        # Check memory usage
+        current_memory = get_memory_usage
+        results[:memory_usage] << current_memory
 
-          # Trigger garbage collection if needed
-          if should_trigger_gc?(current_memory)
-            trigger_garbage_collection
-            results[:gc_count] += 1
-          end
+        # Trigger garbage collection if needed
+        if should_trigger_gc?(current_memory)
+          trigger_garbage_collection
+          results[:gc_count] += 1
+        end
 
-          # Process item
-          begin
-            result = processor_method.call(item, options)
-            results[:results] << result
-            results[:processed_items] += 1
-          rescue => e
-            results[:errors] << {
-              item_index: index,
-              error: e.message
-            }
-          end
+        # Process item
+        result = processor_method.call(item, options)
+        results[:results] << result
+        results[:processed_items] += 1
 
-          # Update memory tracking
-          update_memory_tracking(current_memory)
-        end
-      rescue => e
-        results[:errors] << {
-          type: "streaming_error",
-          message: e.message
-        }
+        # Update memory tracking
+        update_memory_tracking(current_memory)
       end
 
       results
@@ -103,32 +89,25 @@ module Aidp
         errors: []
       }
 
-      begin
-        dataset.each_slice(chunk_size) do |chunk|
-          # Check memory before processing chunk
-          pre_chunk_memory = get_memory_usage
-          results[:memory_usage] << pre_chunk_memory
-
-          # Process chunk
-          chunk_results = process_chunk(chunk, processor_method, options)
-          results[:results].concat(chunk_results[:results])
-          results[:errors].concat(chunk_results[:errors])
-          results[:processed_items] += chunk_results[:processed_items]
-
-          # Trigger garbage collection after chunk
-          if should_trigger_gc?(pre_chunk_memory)
-            trigger_garbage_collection
-            results[:gc_count] += 1
-          end
-
-          results[:processed_chunks] += 1
-          update_memory_tracking(pre_chunk_memory)
+      dataset.each_slice(chunk_size) do |chunk|
+        # Check memory before processing chunk
+        pre_chunk_memory = get_memory_usage
+        results[:memory_usage] << pre_chunk_memory
+
+        # Process chunk
+        chunk_results = process_chunk(chunk, processor_method, options)
+        results[:results].concat(chunk_results[:results])
+        results[:errors].concat(chunk_results[:errors])
+        results[:processed_items] += chunk_results[:processed_items]
+
+        # Trigger garbage collection after chunk
+        if should_trigger_gc?(pre_chunk_memory)
+          trigger_garbage_collection
+          results[:gc_count] += 1
         end
-      rescue => e
-        results[:errors] << {
-          type: "chunking_error",
-          message: e.message
-        }
+
+        results[:processed_chunks] += 1
+        update_memory_tracking(pre_chunk_memory)
       end
 
       results
@@ -303,11 +282,6 @@ module Aidp
         result = processor_method.call(item, options)
         results[:results] << result
         results[:processed_items] += 1
-      rescue => e
-        results[:errors] << {
-          item_index: index,
-          error: e.message
-        }
       end
 
       results
@@ -335,7 +309,7 @@ module Aidp
     def generate_cache_key(item)
       # Generate a cache key for the item
       Digest::MD5.hexdigest(item.to_json)
-    rescue
+    rescue JSON::GeneratorError
       # Fallback to object_id if JSON serialization fails
       "item_#{item.object_id}"
     end

data/lib/aidp/analyze/parallel_processor.rb

@@ -236,12 +236,6 @@ module Aidp
             index: future_info[:index]
           }
           @progress.increment
-        rescue => e
-          @errors << {
-            chunk_id: future_info[:chunk][:id],
-            error: e.message,
-            index: future_info[:index]
-          }
         end
 
         completed_futures

data/lib/aidp/analyze/performance_optimizer.rb

@@ -663,9 +663,6 @@ module Aidp
       futures = items.map do |item|
         Concurrent::Future.execute do
           processor ? processor.call(item) : item
-        rescue => e
-          @statistics[:errors] += 1
-          {error: e.message, item: item}
         end
       end
 

data/lib/aidp/analyze/repository_chunker.rb

@@ -264,29 +264,22 @@ module Aidp
           status: "running"
         }
 
-        begin
-          # Perform analysis based on chunk type
-          case chunk[:strategy]
-          when "time_based"
-            results[:data] = analyze_time_chunk(chunk, analysis_type, options)
-          when "commit_count"
-            results[:data] = analyze_commit_chunk(chunk, analysis_type, options)
-          when "size_based"
-            results[:data] = analyze_size_chunk(chunk, analysis_type, options)
-          when "feature_based"
-            results[:data] = analyze_feature_chunk(chunk, analysis_type, options)
-          end
-
-          results[:status] = "completed"
-          results[:end_time] = Time.now
-          results[:duration] = results[:end_time] - results[:start_time]
-        rescue => e
-          results[:status] = "failed"
-          results[:error] = e.message
-          results[:end_time] = Time.now
-          results[:duration] = results[:end_time] - results[:start_time]
+        # Perform analysis based on chunk type
+        case chunk[:strategy]
+        when "time_based"
+          results[:data] = analyze_time_chunk(chunk, analysis_type, options)
+        when "commit_count"
+          results[:data] = analyze_commit_chunk(chunk, analysis_type, options)
+        when "size_based"
+          results[:data] = analyze_size_chunk(chunk, analysis_type, options)
+        when "feature_based"
+          results[:data] = analyze_feature_chunk(chunk, analysis_type, options)
         end
 
+        results[:status] = "completed"
+        results[:end_time] = Time.now
+        results[:duration] = results[:end_time] - results[:start_time]
+
         results
       end
 

data/lib/aidp/analyze/steps.rb

@@ -40,6 +40,12 @@ module Aidp
           "outs" => ["docs/analysis/static_analysis.md"],
           "gate" => false
         },
+        "06A_TREE_SITTER_SCAN" => {
+          "templates" => ["06a_tree_sitter_scan.md"],
+          "description" => "Tree-sitter powered static analysis to build knowledge base",
+          "outs" => [".aidp/kb/symbols.json", ".aidp/kb/seams.json", ".aidp/kb/hotspots.json"],
+          "gate" => false
+        },
         "07_REFACTORING_RECOMMENDATIONS" => {
           "templates" => ["07_refactoring_recommendations.md"],
           "description" => "Provide actionable refactoring guidance",

data/lib/aidp/analyze/storage.rb

@@ -64,13 +64,6 @@ module Aidp
         stored_at: timestamp,
         success: true
       }
-    rescue => e
-      {
-        success: false,
-        error: e.message,
-        execution_id: execution_id,
-        step_name: step_name
-      }
     end
 
     # Store metrics with indefinite retention

data/lib/aidp/analyze/tool_configuration.rb

@@ -251,32 +251,27 @@ module Aidp
     def import_config(file_path, scope = :project)
       return false unless File.exist?(file_path)
 
-      begin
-        config_data = case File.extname(file_path)
-        when ".yml", ".yaml"
-          YAML.load_file(file_path)
-        when ".json"
-          JSON.parse(File.read(file_path))
-        else
-          raise ArgumentError, "Unsupported file format: #{File.extname(file_path)}"
-        end
-
-        case scope
-        when :project
-          @project_config = config_data
-          save_project_config
-        when :user
-          @user_config = config_data
-          save_user_config
-        else
-          raise ArgumentError, "Invalid scope: #{scope}"
-        end
+      config_data = case File.extname(file_path)
+      when ".yml", ".yaml"
+        YAML.load_file(file_path)
+      when ".json"
+        JSON.parse(File.read(file_path))
+      else
+        raise ArgumentError, "Unsupported file format: #{File.extname(file_path)}"
+      end
 
-        true
-      rescue => e
-        warn "Failed to import configuration: #{e.message}"
-        false
+      case scope
+      when :project
+        @project_config = config_data
+        save_project_config
+      when :user
+        @user_config = config_data
+        save_user_config
+      else
+        raise ArgumentError, "Invalid scope: #{scope}"
       end
+
+      true
     end
 
     # Validate configuration
@@ -297,24 +292,14 @@ module Aidp
     def load_user_config
       return {} unless File.exist?(USER_CONFIG_FILE)
 
-      begin
-        YAML.load_file(USER_CONFIG_FILE) || {}
-      rescue => e
-        warn "Failed to load user config: #{e.message}"
-        {}
-      end
+      YAML.load_file(USER_CONFIG_FILE) || {}
     end
 
     def load_project_config
       config_path = project_config_path
       return {} unless File.exist?(config_path)
 
-      begin
-        YAML.load_file(config_path) || {}
-      rescue => e
-        warn "Failed to load project config: #{e.message}"
-        {}
-      end
+      YAML.load_file(config_path) || {}
     end
 
     def project_config_path

data/lib/aidp/cli/jobs_command.rb

@@ -87,9 +87,6 @@ module Aidp
       rescue Timeout::Error
         @io.puts "Database connection timed out"
         raise
-      rescue => e
-        @io.puts "Error connecting to database: #{e.message}"
-        raise
       end
 
       def render_job_list
@@ -396,8 +393,6 @@ module Aidp
         else
           "pending"
         end
-      rescue => e
-        "error (#{e.message})"
       end
 
       def truncate_error(error)
@@ -426,8 +421,12 @@ module Aidp
             data = JSON.parse(result["data"])
             output << "Result: #{data["output"]}" if data["output"]
           end
-        rescue
-          # Ignore errors - table might not exist
+        rescue Sequel::DatabaseError, PG::Error => e
+          # Database error - table might not exist
+          @io.puts "Warning: Could not fetch job result: #{e.message}" if ENV["AIDP_DEBUG"]
+        rescue JSON::ParserError => e
+          # JSON parse error
+          @io.puts "Warning: Could not parse job result data: #{e.message}" if ENV["AIDP_DEBUG"]
         end
 
         # 2. Check for any recent log entries
@@ -440,8 +439,9 @@ module Aidp
           if logs && logs["last_error_message"]
             output << "Error: #{logs["last_error_message"]}"
           end
-        rescue
-          # Ignore errors
+        rescue Sequel::DatabaseError, PG::Error => e
+          # Database error fetching logs - continue with diagnostic
+          @io.puts "Warning: Could not fetch job logs: #{e.message}" if ENV["AIDP_DEBUG"]
         end
 
         # 3. Check if job appears to be hung

data/lib/aidp/cli.rb

@@ -196,6 +196,62 @@ module Aidp
       command.run
     end
 
+    desc "analyze code", "Run Tree-sitter static analysis to build knowledge base"
+    option :langs, type: :string, desc: "Comma-separated list of languages to analyze (default: ruby)"
+    option :threads, type: :numeric, desc: "Number of threads for parallel processing (default: CPU count)"
+    option :rebuild, type: :boolean, desc: "Rebuild knowledge base from scratch"
+    option :kb_dir, type: :string, desc: "Knowledge base directory (default: .aidp/kb)"
+    def analyze_code
+      require_relative "analysis/tree_sitter_scan"
+
+      langs = options[:langs] ? options[:langs].split(",").map(&:strip) : %w[ruby]
+      threads = options[:threads] || Etc.nprocessors
+      kb_dir = options[:kb_dir] || ".aidp/kb"
+
+      if options[:rebuild]
+        kb_path = File.expand_path(kb_dir, Dir.pwd)
+        FileUtils.rm_rf(kb_path) if File.exist?(kb_path)
+        puts "🗑️  Rebuilt knowledge base directory"
+      end
+
+      scanner = Aidp::Analysis::TreeSitterScan.new(
+        root: Dir.pwd,
+        kb_dir: kb_dir,
+        langs: langs,
+        threads: threads
+      )
+
+      scanner.run
+    end
+
+    desc "kb show [TYPE]", "Show knowledge base contents"
+    option :format, type: :string, desc: "Output format (json, table, summary)"
+    option :kb_dir, type: :string, desc: "Knowledge base directory (default: .aidp/kb)"
+    def kb_show(type = "summary")
+      require_relative "analysis/kb_inspector"
+
+      kb_dir = options[:kb_dir] || ".aidp/kb"
+      format = options[:format] || "summary"
+
+      inspector = Aidp::Analysis::KBInspector.new(kb_dir)
+      inspector.show(type, format: format)
+    end
+
+    desc "kb graph [TYPE]", "Generate graph visualization from knowledge base"
+    option :format, type: :string, desc: "Graph format (dot, json, mermaid)"
+    option :output, type: :string, desc: "Output file path"
+    option :kb_dir, type: :string, desc: "Knowledge base directory (default: .aidp/kb)"
+    def kb_graph(type = "imports")
+      require_relative "analysis/kb_inspector"
+
+      kb_dir = options[:kb_dir] || ".aidp/kb"
+      format = options[:format] || "dot"
+      output = options[:output]
+
+      inspector = Aidp::Analysis::KBInspector.new(kb_dir)
+      inspector.generate_graph(type, format: format, output: output)
+    end
+
     desc "version", "Show version information"
     def version
       puts "Aidp version #{Aidp::VERSION}"

data/lib/aidp/jobs/base_job.rb

@@ -30,8 +30,6 @@ module Aidp
       def handle_error(error)
         self.class.error_handlers.each do |handler|
           handler.call(error, self)
-        rescue => e
-          log_error "Error handler failed: #{e.message}"
         end
       end
 

data/lib/aidp/jobs/provider_execution_job.rb

@@ -18,32 +18,19 @@ module Aidp
         provider = Aidp::ProviderManager.get_provider(provider_type)
         raise "Provider #{provider_type} not available" unless provider
 
-        begin
-          # Execute provider
-          result = provider.send(prompt: prompt, session: session)
+        # Execute provider
+        result = provider.send(prompt: prompt, session: session)
 
-          # Store result
-          store_result(result, metadata)
+        # Store result
+        store_result(result, metadata)
 
-          # Record metrics
-          record_metrics(
-            provider_type: provider_type,
-            duration: Time.now - start_time,
-            success: true,
-            error: nil
-          )
-        rescue => error
-          # Record metrics
-          record_metrics(
-            provider_type: provider_type,
-            duration: Time.now - start_time,
-            success: false,
-            error: error.message
-          )
-
-          # Re-raise error to trigger Que's retry mechanism
-          raise
-        end
+        # Record metrics
+        record_metrics(
+          provider_type: provider_type,
+          duration: Time.now - start_time,
+          success: true,
+          error: nil
+        )
       end
 
       private

data/lib/aidp/providers/agent_supervisor.rb

@@ -215,8 +215,8 @@ module Aidp
           # Try one more time with KILL
           begin
             Process.kill("KILL", @process_pid) if process_running?(@process_pid)
-          rescue
-            # Give up
+          rescue Errno::ESRCH
+            # Process already terminated
           end
         end
       end

data/lib/aidp/providers/anthropic.rb

@@ -57,8 +57,6 @@ module Aidp
 
               # Stop checking if the process is done
               break if wait.value
-            rescue
-              break
             end
           end
 
@@ -88,8 +86,8 @@ module Aidp
             # Kill the process if it's taking too long
             begin
               Process.kill("TERM", wait.pid)
-            rescue
-              nil
+            rescue Errno::ESRCH
+              # Process already terminated
             end
 
             mark_failed("claude timed out after #{timeout_seconds} seconds")
@@ -101,8 +99,8 @@ module Aidp
             # Kill the process
             begin
               Process.kill("TERM", wait.pid)
-            rescue
-              nil
+            rescue Errno::ESRCH
+              # Process already terminated
             end
 
             mark_failed("claude execution was interrupted")
@@ -143,21 +141,17 @@ module Aidp
 
       def get_adaptive_timeout
         # Try to get timeout recommendations from metrics storage
-        begin
-          require_relative "../analyze/metrics_storage"
-          storage = Aidp::Analyze::MetricsStorage.new(Dir.pwd)
-          recommendations = storage.calculate_timeout_recommendations
-
-          # Get current step name from environment or context
-          step_name = ENV["AIDP_CURRENT_STEP"] || "unknown"
-
-          if recommendations[step_name]
-            recommended = recommendations[step_name][:recommended_timeout]
-            # Add 20% buffer for safety
-            return (recommended * 1.2).ceil
-          end
-        rescue => e
-          puts "⚠️  Could not get adaptive timeout: #{e.message}" if ENV["AIDP_DEBUG"]
+        require_relative "../analyze/metrics_storage"
+        storage = Aidp::Analyze::MetricsStorage.new(Dir.pwd)
+        recommendations = storage.calculate_timeout_recommendations
+
+        # Get current step name from environment or context
+        step_name = ENV["AIDP_CURRENT_STEP"] || "unknown"
+
+        if recommendations[step_name]
+          recommended = recommendations[step_name][:recommended_timeout]
+          # Add 20% buffer for safety
+          return (recommended * 1.2).ceil
         end
 
         # Fallback timeouts based on step type patterns

data/lib/aidp/providers/cursor.rb

@@ -121,8 +121,6 @@ module Aidp
 
               # Stop checking if the process is done
               break if wait.value
-            rescue
-              break
             end
           end
 
@@ -135,7 +133,7 @@ module Aidp
                 Process.kill("TERM", wait.pid)
                 sleep 2
                 Process.kill("KILL", wait.pid) if wait.value.nil?
-              rescue
+              rescue Errno::ESRCH
                 # Process already terminated
               end
             end
@@ -156,7 +154,7 @@ module Aidp
                 Process.kill("TERM", wait.pid)
                 sleep 1
                 Process.kill("KILL", wait.pid) if wait.value.nil?
-              rescue
+              rescue Errno::ESRCH
                 # Process already terminated
               end