aidp 0.13.0 → 0.14.0

data/lib/aidp/harness/config_schema.rb

@@ -404,6 +404,55 @@ module Aidp
                   items: {
                     type: :string
                   }
+                },
+                guards: {
+                  type: :hash,
+                  required: false,
+                  default: {
+                    enabled: false
+                  },
+                  properties: {
+                    enabled: {
+                      type: :boolean,
+                      required: false,
+                      default: false
+                    },
+                    include_files: {
+                      type: :array,
+                      required: false,
+                      default: [],
+                      items: {
+                        type: :string
+                      }
+                    },
+                    exclude_files: {
+                      type: :array,
+                      required: false,
+                      default: [],
+                      items: {
+                        type: :string
+                      }
+                    },
+                    confirm_files: {
+                      type: :array,
+                      required: false,
+                      default: [],
+                      items: {
+                        type: :string
+                      }
+                    },
+                    max_lines_per_commit: {
+                      type: :integer,
+                      required: false,
+                      min: 1,
+                      max: 10000
+                    },
+                    bypass: {
+                      type: :boolean,
+                      required: false,
+                      default: false
+                    }
+                  }
                 }
               }
             }
@@ -576,6 +625,45 @@ module Aidp
               }
             }
           }
+        },
+        logging: {
+          type: :hash,
+          required: false,
+          default: {},
+          properties: {
+            level: {
+              type: :string,
+              required: false,
+              default: "info",
+              enum: ["debug", "info", "warn", "error"]
+            },
+            json: {
+              type: :boolean,
+              required: false,
+              default: false
+            },
+            max_size_mb: {
+              type: :integer,
+              required: false,
+              default: 10,
+              min: 1,
+              max: 100
+            },
+            max_backups: {
+              type: :integer,
+              required: false,
+              default: 5,
+              min: 1,
+              max: 20
+            },
+            max_age_days: {
+              type: :integer,
+              required: false,
+              default: 14,
+              min: 1,
+              max: 365
+            }
+          }
         }
       }.freeze
 

data/lib/aidp/harness/configuration.rb

@@ -170,6 +170,41 @@ module Aidp
         work_loop_config[:lint_commands] || []
       end
 
+      # Get guards configuration
+      def guards_config
+        work_loop_config[:guards] || default_guards_config
+      end
+
+      # Check if guards are enabled
+      def guards_enabled?
+        guards_config[:enabled] == true
+      end
+
+      # Get include file patterns for guards
+      def guards_include_files
+        guards_config[:include_files] || []
+      end
+
+      # Get exclude file patterns for guards
+      def guards_exclude_files
+        guards_config[:exclude_files] || []
+      end
+
+      # Get files requiring confirmation for guards
+      def guards_confirm_files
+        guards_config[:confirm_files] || []
+      end
+
+      # Get max lines per commit for guards
+      def guards_max_lines_per_commit
+        guards_config[:max_lines_per_commit]
+      end
+
+      # Check if guards are bypassed
+      def guards_bypass?
+        guards_config[:bypass] == true
+      end
+
       # Get provider priority
       def provider_priority(provider_name)
         provider_config(provider_name)[:priority] || 0
@@ -447,7 +482,19 @@ module Aidp
           enabled: true,
           max_iterations: 50,
           test_commands: [],
-          lint_commands: []
+          lint_commands: [],
+          guards: default_guards_config
+        }
+      end
+
+      def default_guards_config
+        {
+          enabled: false,
+          include_files: [],
+          exclude_files: [],
+          confirm_files: [],
+          max_lines_per_commit: nil,
+          bypass: false
         }
       end
 

data/lib/aidp/harness/ui/enhanced_workflow_selector.rb

@@ -258,7 +258,9 @@ module Aidp
           @user_input = result[:user_input]
 
           # Return in the expected format
+          # IMPORTANT: Include the mode from guided agent result (usually :execute)
           {
+            mode: result[:mode],
             workflow_type: result[:workflow_type],
             steps: result[:steps],
             user_input: @user_input,

data/lib/aidp/init/doc_generator.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Aidp
+  module Init
+    # Creates project documentation artefacts based on the analyzer output. All
+    # documents are deterministic and tailored with repository insights.
+    class DocGenerator
+      OUTPUT_DIR = "docs"
+      STYLE_GUIDE_PATH = File.join(OUTPUT_DIR, "LLM_STYLE_GUIDE.md")
+      ANALYSIS_PATH = File.join(OUTPUT_DIR, "PROJECT_ANALYSIS.md")
+      QUALITY_PLAN_PATH = File.join(OUTPUT_DIR, "CODE_QUALITY_PLAN.md")
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+      end
+
+      def generate(analysis:, preferences: {})
+        ensure_output_directory
+        write_style_guide(analysis, preferences)
+        write_project_analysis(analysis)
+        write_quality_plan(analysis, preferences)
+      end
+
+      private
+
+      def ensure_output_directory
+        FileUtils.mkdir_p(File.join(@project_dir, OUTPUT_DIR))
+      end
+
+      def write_style_guide(analysis, preferences)
+        languages = format_list(analysis[:languages].keys)
+        frameworks = format_list(analysis[:frameworks])
+        test_frameworks = format_list(analysis[:test_frameworks])
+        key_dirs = format_list(analysis[:key_directories])
+        tooling = analysis[:tooling].keys.map { |tool| format_tool(tool) }.sort
+
+        adoption_note = if truthy?(preferences[:adopt_new_conventions])
+          "This project has opted to adopt new conventions recommended by aidp init. When in doubt, prefer the rules below over legacy patterns."
+        else
+          "Retain existing conventions when they do not conflict with the guidance below."
+        end
+
+        content = <<~GUIDE
+          # Project LLM Style Guide
+
+          > Generated automatically by `aidp init` on #{Time.now.utc.iso8601}.
+          >
+          > Detected languages: #{languages}
+          > Framework hints: #{frameworks.empty? ? "None detected" : frameworks}
+          > Primary test frameworks: #{test_frameworks.empty? ? "Unknown" : test_frameworks}
+          > Key directories: #{key_dirs.empty? ? "Standard structure" : key_dirs}
+
+          #{adoption_note}
+
+          ## 1. Core Engineering Rules
+          - Prioritise readability and maintainability; extract objects or modules once business logic exceeds a few branches.
+          - Co-locate domain objects with their tests under the matching directory (e.g., `lib/` ↔ `spec/`).
+          - Remove dead code and feature flags that are no longer exercised; keep git history as the source of truth.
+          - Use small, composable services rather than bloated classes.
+
+          ## 2. Naming & Structure
+          - Follow idiomatic naming for the detected languages (#{languages}); align files under #{key_dirs.empty? ? "the project root" : key_dirs}.
+          - Ensure top-level namespaces mirror the directory structure (e.g., `Aidp::Init` lives in `lib/aidp/init/`).
+          - Keep public APIs explicit with keyword arguments and descriptive method names.
+
+          ## 3. Parameters & Data
+          - Limit positional arguments to three; prefer keyword arguments or value objects beyond that.
+          - Reuse shared data structures to capture configuration (YAML/JSON) instead of scattered constants.
+          - Validate incoming data at boundaries; rely on plain objects internally.
+
+          ## 4. Error Handling
+          - Raise domain-specific errors; avoid using plain `StandardError` without context.
+          - Wrap external calls with rescuable adapters and surface actionable error messages.
+          - Log failures with relevant identifiers only—never entire payloads.
+
+          ## 5. Testing Contracts
+          - Mirror production directory structure inside `#{preferred_test_dirs(analysis)}`.
+          - Keep tests independent; mock external services only at the boundary layers.
+          - Use the project's native assertions (#{test_frameworks.empty? ? "choose an appropriate framework" : test_frameworks}) and ensure every bug fix comes with a regression test.
+
+          ## 6. Framework-Specific Guidelines
+          - Adopt the idioms of detected frameworks#{frameworks.empty? ? " once adopted." : " (#{frameworks})."}
+          - Keep controllers/handlers thin; delegate logic to service objects or interactors.
+          - Store shared UI or component primitives in a central folder to make reuse easier.
+
+          ## 7. Dependencies & External Services
+          - Document every external integration inside `docs/` and keep credentials outside the repo.
+          - Use dependency injection for clients; avoid global state or singletons.
+          - When adding new gems or packages, document the rationale in `PROJECT_ANALYSIS.md`.
+
+          ## 8. Build & Development
+          - Run linters before committing: #{tooling.empty? ? "add rubocop/eslint/flake8 as appropriate." : tooling.join(", ")}.
+          - Keep build scripts in `bin/` or `scripts/` and ensure they are idempotent.
+          - Prefer `mise` or language-specific version managers to keep toolchains aligned.
+
+          ## 9. Performance
+          - Measure before optimising; add benchmarks for hotspots.
+          - Cache expensive computations when they are pure and repeatable.
+          - Review dependency load time; lazy-load optional components where possible.
+
+          ## 10. Project-Specific Anti-Patterns
+          - Avoid sprawling God objects that mix persistence, business logic, and presentation.
+          - Resist ad-hoc shelling out; prefer library APIs with proper error handling.
+          - Do not bypass the agreed testing workflow—even for small fixes.
+
+          ---
+          Generated from template `planning/generate_llm_style_guide.md` with repository-aware adjustments.
+        GUIDE
+
+        File.write(File.join(@project_dir, STYLE_GUIDE_PATH), content)
+      end
+
+      def write_project_analysis(analysis)
+        languages = format_language_breakdown(analysis[:languages])
+        frameworks = bullet_list(analysis[:frameworks], default: "_None detected_")
+        config_files = bullet_list(analysis[:config_files], default: "_No dedicated configuration files discovered_")
+        tooling = format_tooling_section(analysis[:tooling])
+
+        stats = analysis[:repo_stats]
+        stats_lines = [
+          "- Total files scanned: #{stats[:total_files]}",
+          "- Unique directories: #{stats[:total_directories]}",
+          "- Documentation folder present: #{stats[:docs_present] ? "Yes" : "No"}",
+          "- CI configuration present: #{stats[:has_ci_config] ? "Yes" : "No"}",
+          "- Containerisation assets: #{stats[:has_containerization] ? "Yes" : "No"}"
+        ]
+
+        content = <<~ANALYSIS
+          # Project Analysis
+
+          Generated automatically by `aidp init` on #{Time.now.utc.iso8601}. This document summarises the repository structure to guide future autonomous work loops.
+
+          ## Language & Framework Footprint
+          #{languages}
+
+          ### Framework Signals
+          #{frameworks}
+
+          ## Key Directories
+          #{bullet_list(analysis[:key_directories], default: "_No conventional application directories detected_")}
+
+          ## Configuration & Tooling Files
+          #{config_files}
+
+          ## Test & Quality Signals
+          #{bullet_list(analysis[:test_frameworks], prefix: "- Detected test suite: ", default: "_Unable to infer test suite_")}
+
+          ## Local Quality Toolchain
+          #{tooling}
+
+          ## Repository Stats
+          #{stats_lines.join("\n")}
+
+          ---
+          Template inspiration: `analysis/analyze_repository.md`, `analysis/analyze_tests.md`.
+        ANALYSIS
+
+        File.write(File.join(@project_dir, ANALYSIS_PATH), content)
+      end
+
+      def write_quality_plan(analysis, preferences)
+        tooling = analysis[:tooling]
+        proactive = if truthy?(preferences[:stricter_linters])
+          "- Enable stricter linting rules and fail CI on offences.\n- Enforce formatting checks (`mise exec --` for consistent environments).\n"
+        else
+          "- Maintain current linting thresholds while documenting exceptions.\n"
+        end
+
+        migration = if truthy?(preferences[:migrate_styles])
+          "- Plan refactors to align legacy files with the new style guide.\n- Schedule incremental clean-up tasks to avoid large-batch rewrites.\n"
+        else
+          "- Keep legacy style deviations documented until dedicated refactors are scheduled.\n"
+        end
+
+        content = <<~PLAN
+          # Code Quality Plan
+
+          This plan captures the current tooling landscape and proposes next steps for keeping the codebase healthy. Generated by `aidp init` on #{Time.now.utc.iso8601}.
+
+          ## Local Quality Toolchain
+          #{tooling.empty? ? "_No linting/formatting tools detected. Consider adding RuboCop, ESLint, or Prettier based on the primary language._" : format_tooling_table(tooling)}
+
+          ## Immediate Actions
+          #{proactive}#{migration}- Document onboarding steps in `docs/` to ensure future contributors follow the agreed workflow.
+
+          ## Long-Term Improvements
+          - Keep the style guide in sync with real-world code changes; regenerate with `aidp init` after major rewrites.
+          - Automate test and lint runs via CI (detected: #{analysis.dig(:repo_stats, :has_ci_config) ? "yes" : "no"}).
+          - Track flaky tests or unstable tooling in `PROJECT_ANALYSIS.md` under a “Health Log” section.
+
+          ---
+          Based on templates: `analysis/analyze_static_code.md`, `analysis/analyze_tests.md`.
+        PLAN
+
+        File.write(File.join(@project_dir, QUALITY_PLAN_PATH), content)
+      end
+
+      def preferred_test_dirs(analysis)
+        detected = Array(analysis[:key_directories]).select { |dir| dir =~ /\b(spec|test|tests)\b/ }
+        detected.empty? ? "the chosen test directory" : detected.join(", ")
+      end
+
+      def format_list(values)
+        Array(values).join(", ")
+      end
+
+      def bullet_list(values, prefix: "- ", default: "_None_")
+        items = Array(values)
+        return default if items.empty?
+
+        items.map { |value| "#{prefix}#{value}" }.join("\n")
+      end
+
+      def format_language_breakdown(languages)
+        return "_No source files detected._" if languages.nil? || languages.empty?
+
+        total = languages.values.sum
+        languages.map do |language, weight|
+          percentage = total.zero? ? 0 : ((weight.to_f / total) * 100).round(2)
+          "- #{language}: #{percentage}% of codebase"
+        end.join("\n")
+      end
+
+      def format_tooling_table(tooling)
+        rows = tooling.map do |tool, evidence|
+          "| #{format_tool(tool)} | #{evidence.uniq.join(", ")} |"
+        end
+        header = "| Tool | Evidence |\n|------|----------|"
+        ([header] + rows).join("\n")
+      end
+
+      def format_tooling_section(tooling)
+        return "_No tooling detected._" if tooling.nil? || tooling.empty?
+
+        header = "| Tool | Evidence |\n|------|----------|"
+        rows = tooling.map do |tool, evidence|
+          "| #{format_tool(tool)} | #{Array(evidence).uniq.join(", ")} |"
+        end
+        ([header] + rows).join("\n")
+      end
+
+      def format_tool(tool)
+        tool.to_s.split("_").map(&:capitalize).join(" ")
+      end
+
+      def truthy?(value)
+        value == true || value.to_s.strip.casecmp("yes").zero?
+      rescue
+        false
+      end
+    end
+  end
+end