aidp 0.12.1 → 0.14.0

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

data/lib/aidp/init/project_analyzer.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "find"
+require "json"
+
+module Aidp
+  module Init
+    # Performs lightweight static analysis of the repository to detect languages,
+    # frameworks, config files, and quality tooling. Designed to run quickly and
+    # deterministically without external services.
+    class ProjectAnalyzer
+      IGNORED_DIRECTORIES = %w[
+        .git
+        .svn
+        .hg
+        node_modules
+        vendor
+        tmp
+        log
+        build
+        dist
+        coverage
+        .yardoc
+      ].freeze
+
+      LANGUAGE_EXTENSIONS = {
+        ".rb" => "Ruby",
+        ".rake" => "Ruby",
+        ".gemspec" => "Ruby",
+        ".js" => "JavaScript",
+        ".jsx" => "JavaScript",
+        ".ts" => "TypeScript",
+        ".tsx" => "TypeScript",
+        ".py" => "Python",
+        ".go" => "Go",
+        ".java" => "Java",
+        ".kt" => "Kotlin",
+        ".cs" => "C#",
+        ".php" => "PHP",
+        ".rs" => "Rust",
+        ".swift" => "Swift",
+        ".scala" => "Scala",
+        ".c" => "C",
+        ".cpp" => "C++",
+        ".hpp" => "C++",
+        ".m" => "Objective-C",
+        ".mm" => "Objective-C++",
+        ".hs" => "Haskell",
+        ".erl" => "Erlang",
+        ".ex" => "Elixir",
+        ".exs" => "Elixir",
+        ".clj" => "Clojure",
+        ".coffee" => "CoffeeScript"
+      }.freeze
+
+      CONFIG_FILES = %w[
+        .editorconfig
+        .rubocop.yml
+        .rubocop_todo.yml
+        .standardrb
+        .eslintrc
+        .eslintrc.js
+        .eslintrc.cjs
+        .eslintrc.json
+        .prettierrc
+        .prettierrc.js
+        .prettierrc.cjs
+        .prettierrc.json
+        .stylelintrc
+        .flake8
+        pyproject.toml
+        tox.ini
+        setup.cfg
+        package.json
+        Gemfile
+        Gemfile.lock
+        mix.exs
+        go.mod
+        go.sum
+        composer.json
+        Cargo.toml
+        Cargo.lock
+        pom.xml
+        build.gradle
+        build.gradle.kts
+      ].freeze
+
+      KEY_DIRECTORIES = %w[
+        app
+        src
+        lib
+        spec
+        test
+        tests
+        scripts
+        bin
+        config
+        docs
+        examples
+        packages
+        modules
+      ].freeze
+
+      TOOLING_HINTS = {
+        rubocop: [".rubocop.yml", ".rubocop_todo.yml"],
+        standardrb: [".standardrb"],
+        eslint: [".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json"],
+        prettier: [".prettierrc", ".prettierrc.js", ".prettierrc.cjs", ".prettierrc.json"],
+        stylelint: [".stylelintrc"],
+        flake8: [".flake8"],
+        black: ["pyproject.toml"],
+        pytest: ["pytest.ini", "pyproject.toml"],
+        jest: ["package.json"],
+        rspec: ["spec", ".rspec"],
+        minitest: ["test"],
+        gofmt: ["go.mod"],
+        cargo_fmt: ["Cargo.toml"]
+      }.freeze
+
+      FRAMEWORK_HINTS = {
+        "Rails" => {files: ["config/application.rb"], contents: [/rails/i]},
+        "Hanami" => {files: ["config/app.rb"], contents: [/hanami/i]},
+        "Sinatra" => {files: ["config.ru"], contents: [/sinatra/i]},
+        "React" => {files: ["package.json"], contents: [/react/]},
+        "Next.js" => {files: ["package.json"], contents: [/next/]},
+        "Express" => {files: ["package.json"], contents: [/express/]},
+        "Angular" => {files: ["angular.json"]},
+        "Vue" => {files: ["package.json"], contents: [/vue/]},
+        "Django" => {files: ["manage.py"], contents: [/django/]},
+        "Flask" => {files: ["requirements.txt"], contents: [/flask/]},
+        "FastAPI" => {files: ["pyproject.toml", "requirements.txt"], contents: [/fastapi/]},
+        "Phoenix" => {files: ["mix.exs"], contents: [/phoenix/]},
+        "Spring" => {files: ["pom.xml", "build.gradle", "build.gradle.kts"], contents: [/spring/]},
+        "Laravel" => {files: ["composer.json"], contents: [/laravel/]},
+        "Go Gin" => {files: ["go.mod"], contents: [/gin-gonic/]},
+        "Go Fiber" => {files: ["go.mod"], contents: [/github.com\/gofiber/]}
+      }.freeze
+
+      TEST_FRAMEWORK_HINTS = {
+        "RSpec" => {directories: ["spec"], dependencies: [/rspec/]},
+        "Minitest" => {directories: ["test"], dependencies: [/minitest/]},
+        "Cucumber" => {directories: ["features"]},
+        "Jest" => {dependencies: [/jest/]},
+        "Mocha" => {dependencies: [/mocha/]},
+        "Jasmine" => {dependencies: [/jasmine/]},
+        "Pytest" => {directories: ["tests", "test"], dependencies: [/pytest/]},
+        "NUnit" => {files: ["*.csproj"], contents: [/nunit/]},
+        "JUnit" => {dependencies: [/junit/]},
+        "Go test" => {files: ["*_test.go"]}
+      }.freeze
+
+      attr_reader :project_dir
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+      end
+
+      def analyze
+        {
+          languages: detect_languages,
+          frameworks: detect_frameworks,
+          key_directories: detect_key_directories,
+          config_files: detect_config_files,
+          test_frameworks: detect_test_frameworks,
+          tooling: detect_tooling,
+          repo_stats: collect_repo_stats
+        }
+      end
+
+      private
+
+      def detect_languages
+        counts = Hash.new(0)
+
+        traverse_files do |relative_path|
+          ext = File.extname(relative_path)
+          language = LANGUAGE_EXTENSIONS[ext]
+          next unless language
+
+          full_path = File.join(project_dir, relative_path)
+          counts[language] += File.size(full_path)
+        end
+
+        counts.sort_by { |_lang, weight| -weight }.to_h
+      end
+
+      def detect_frameworks
+        frameworks = Set.new
+
+        FRAMEWORK_HINTS.each do |framework, rules|
+          if rules[:files]&.any? { |file| project_glob?(file) }
+            if rules[:contents]
+              frameworks << framework if rules[:contents].any? { |pattern| search_files_for_pattern(rules[:files], pattern) }
+            else
+              frameworks << framework
+            end
+          elsif rules[:contents]&.any? { |pattern| search_project_for_pattern(pattern) }
+            frameworks << framework
+          end
+        end
+
+        frameworks.to_a.sort
+      end
+
+      def detect_key_directories
+        KEY_DIRECTORIES.select { |dir| Dir.exist?(File.join(project_dir, dir)) }
+      end
+
+      def detect_config_files
+        CONFIG_FILES.select { |file| project_glob?(file) }
+      end
+
+      def detect_test_frameworks
+        results = []
+
+        TEST_FRAMEWORK_HINTS.each do |framework, hints|
+          has_directory = hints[:directories]&.any? { |dir| Dir.exist?(File.join(project_dir, dir)) }
+          has_dependency = hints[:dependencies]&.any? { |pattern| search_project_for_pattern(pattern, limit_files: ["Gemfile", "Gemfile.lock", "package.json", "pyproject.toml", "requirements.txt", "go.mod", "mix.exs", "composer.json", "Cargo.toml"]) }
+          has_files = hints[:files]&.any? { |glob| project_glob?(glob) }
+
+          results << framework if has_directory || has_dependency || has_files
+        end
+
+        results.uniq.sort
+      end
+
+      def detect_tooling
+        tooling = Hash.new { |hash, key| hash[key] = [] }
+
+        TOOLING_HINTS.each do |tool, indicators|
+          hit = indicators.any? do |indicator|
+            if indicator.include?("*")
+            end
+            project_glob?(indicator)
+          end
+          tooling[tool] << "config" if hit
+        end
+
+        # Post-process for package.json to extract scripts referencing linters
+        package_json_path = File.join(project_dir, "package.json")
+        if File.exist?(package_json_path)
+          begin
+            json = JSON.parse(File.read(package_json_path))
+            scripts = json.fetch("scripts", {})
+            tooling[:eslint] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("eslint") }
+            tooling[:prettier] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("prettier") }
+            tooling[:jest] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("jest") }
+          rescue JSON::ParserError
+            # ignore malformed package.json
+          end
+        end
+
+        tooling.delete_if { |_tool, evidence| evidence.empty? }
+      end
+
+      def collect_repo_stats
+        {
+          total_files: counted_files.size,
+          total_directories: counted_directories.size,
+          docs_present: Dir.exist?(File.join(project_dir, "docs")),
+          has_ci_config: project_glob?(".github/workflows/*.yml") || project_glob?(".gitlab-ci.yml"),
+          has_containerization: project_glob?("Dockerfile") || project_glob?("docker-compose.yml")
+        }
+      end
+
+      def counted_files
+        @counted_files ||= begin
+          files = []
+          traverse_files { |path| files << path }
+          files
+        end
+      end
+
+      def counted_directories
+        @counted_directories ||= begin
+          dirs = Set.new
+          traverse_files do |path|
+            dirs << File.dirname(path)
+          end
+          dirs.to_a
+        end
+      end
+
+      def traverse_files
+        Find.find(project_dir) do |path|
+          next if path == project_dir
+
+          relative = path.sub("#{project_dir}/", "")
+          if File.directory?(path)
+            dirname = File.basename(path)
+            if IGNORED_DIRECTORIES.include?(dirname)
+              Find.prune
+            else
+              next
+            end
+          else
+            yield relative
+          end
+        end
+      end
+
+      def project_glob?(pattern)
+        Dir.glob(File.join(project_dir, pattern)).any?
+      end
+
+      def search_files_for_pattern(files, pattern)
+        files.any? do |file|
+          Dir.glob(File.join(project_dir, file)).any? do |path|
+            File.read(path).match?(pattern)
+          rescue Errno::ENOENT, Errno::EISDIR
+            false
+          end
+        end
+      end
+
+      def search_project_for_pattern(pattern, limit_files: nil)
+        if limit_files
+          limit_files.any? do |file|
+            path = File.join(project_dir, file)
+            next false unless File.exist?(path)
+
+            File.read(path).match?(pattern)
+          rescue Errno::ENOENT
+            false
+          end
+        else
+          traverse_files do |relative_path|
+            path = File.join(project_dir, relative_path)
+            begin
+              return true if File.read(path).match?(pattern)
+            rescue Errno::ENOENT
+              next
+            rescue ArgumentError, Encoding::InvalidByteSequenceError => e
+              warn "[AIDP] Skipping file with invalid encoding: #{path} (#{e.class})"
+              next
+            end
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/aidp/init/runner.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../message_display"
+require_relative "project_analyzer"
+require_relative "doc_generator"
+
+module Aidp
+  module Init
+    # High-level coordinator for `aidp init`. Handles analysis, optional user
+    # preferences, and documentation generation.
+    class Runner
+      include Aidp::MessageDisplay
+
+      def initialize(project_dir = Dir.pwd, prompt: TTY::Prompt.new, analyzer: nil, doc_generator: nil)
+        @project_dir = project_dir
+        @prompt = prompt
+        @analyzer = analyzer || ProjectAnalyzer.new(project_dir)
+        @doc_generator = doc_generator || DocGenerator.new(project_dir)
+      end
+
+      def run
+        display_message("🔍 Running aidp init project analysis...", type: :info)
+        analysis = @analyzer.analyze
+        display_summary(analysis)
+
+        preferences = gather_preferences
+
+        @doc_generator.generate(analysis: analysis, preferences: preferences)
+
+        display_message("\n📄 Generated documentation:", type: :info)
+        display_message("  - docs/LLM_STYLE_GUIDE.md", type: :success)
+        display_message("  - docs/PROJECT_ANALYSIS.md", type: :success)
+        display_message("  - docs/CODE_QUALITY_PLAN.md", type: :success)
+        display_message("\n✅ aidp init complete.", type: :success)
+
+        {
+          analysis: analysis,
+          preferences: preferences,
+          generated_files: [
+            "docs/LLM_STYLE_GUIDE.md",
+            "docs/PROJECT_ANALYSIS.md",
+            "docs/CODE_QUALITY_PLAN.md"
+          ]
+        }
+      end
+
+      private
+
+      def display_summary(analysis)
+        languages = analysis[:languages].keys
+        frameworks = analysis[:frameworks]
+        tests = analysis[:test_frameworks]
+        config_files = analysis[:config_files]
+
+        display_message("\n📊 Repository Snapshot", type: :highlight)
+        display_message("  Languages: #{languages.empty? ? "Unknown" : languages.join(", ")}", type: :info)
+        display_message("  Frameworks: #{frameworks.empty? ? "None detected" : frameworks.join(", ")}", type: :info)
+        display_message("  Test suites: #{tests.empty? ? "Not found" : tests.join(", ")}", type: :info)
+        display_message("  Config files: #{config_files.empty? ? "None detected" : config_files.join(", ")}", type: :info)
+      end
+
+      def gather_preferences
+        display_message("\n⚙️  Customise bootstrap plans (press Enter to accept defaults):", type: :info)
+
+        {
+          adopt_new_conventions: ask_yes_no("Adopt the newly generated conventions as canonical defaults?", default: true),
+          stricter_linters: ask_yes_no("Enforce stricter linting based on detected tools?", default: false),
+          migrate_styles: ask_yes_no("Plan migrations to align legacy files with the new style guide?", default: false)
+        }
+      end
+
+      def ask_yes_no(question, default:)
+        @prompt.yes?(question) do |q|
+          q.default default ? "yes" : "no"
+        end
+      rescue NoMethodError
+        # Compatibility with simplified prompts in tests (e.g. TestPrompt)
+        default
+      end
+    end
+  end
+end

data/lib/aidp/init.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "init/project_analyzer"
+require_relative "init/doc_generator"
+require_relative "init/runner"