spurline-test 0.3.0

data/lib/spurline/base.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Spurline
+  # Framework internals. Developers never interact with this class directly.
+  # Includes all DSL modules and provides registry access.
+  #
+  # Default adapters are registered here so `use_model :claude_sonnet` works
+  # out of the box without manual registration.
+  class Base
+    include Spurline::DSL::Model
+    include Spurline::DSL::Persona
+    include Spurline::DSL::Tools
+    include Spurline::DSL::Memory
+    include Spurline::DSL::Guardrails
+    include Spurline::DSL::Hooks
+    include Spurline::DSL::SuspendUntil
+
+    # Default model-to-adapter mapping.
+    DEFAULT_ADAPTERS = {
+      claude_sonnet: { adapter: Spurline::Adapters::Claude, model: "claude-sonnet-4-20250514" },
+      claude_opus: { adapter: Spurline::Adapters::Claude, model: "claude-opus-4-20250514" },
+      claude_haiku: { adapter: Spurline::Adapters::Claude, model: "claude-haiku-4-5-20251001" },
+      openai_gpt4o: { adapter: Spurline::Adapters::OpenAI, model: "gpt-4o" },
+      openai_gpt4o_mini: { adapter: Spurline::Adapters::OpenAI, model: "gpt-4o-mini" },
+      openai_o3_mini: { adapter: Spurline::Adapters::OpenAI, model: "o3-mini" },
+      stub: { adapter: Spurline::Adapters::StubAdapter },
+    }.freeze
+
+    class << self
+      def deterministic_sequence(*tool_names)
+        if tool_names.empty?
+          raise Spurline::ConfigurationError,
+            "deterministic_sequence requires at least one tool name."
+        end
+
+        @deterministic_sequence_config = tool_names.map do |item|
+          item.is_a?(Hash) ? item : item.to_sym
+        end
+      end
+
+      def deterministic_sequence_config
+        own = instance_variable_defined?(:@deterministic_sequence_config) ? @deterministic_sequence_config : nil
+        if own
+          own
+        elsif superclass.respond_to?(:deterministic_sequence_config)
+          superclass.deterministic_sequence_config
+        else
+          nil
+        end
+      end
+
+      def tool_registry
+        @tool_registry ||= Spurline::Tools::Registry.new
+        Spurline::Spur.flush_pending_registrations!(@tool_registry)
+        @tool_registry
+      end
+
+      def toolkit_registry
+        @toolkit_registry ||= Spurline::Tools::ToolkitRegistry.new(tool_registry: tool_registry)
+      end
+
+      def adapter_registry
+        @adapter_registry ||= begin
+          registry = Spurline::Adapters::Registry.new
+          register_default_adapters!(registry)
+          registry
+        end
+        Spurline::Spur.flush_pending_adapter_registrations!(@adapter_registry)
+        @adapter_registry
+      end
+
+      def session_store
+        @session_store ||= resolve_session_store(Spurline.config.session_store)
+      end
+
+      def session_store=(store)
+        @session_store = resolve_session_store(store)
+      end
+
+      def inherited(subclass)
+        super
+        # Share registries with subclasses
+        subclass.instance_variable_set(:@tool_registry, tool_registry)
+        subclass.instance_variable_set(:@toolkit_registry, toolkit_registry)
+        subclass.instance_variable_set(:@adapter_registry, adapter_registry)
+        subclass.instance_variable_set(:@session_store, @session_store)
+        if instance_variable_defined?(:@deterministic_sequence_config)
+          subclass.instance_variable_set(
+            :@deterministic_sequence_config,
+            @deterministic_sequence_config&.dup
+          )
+        end
+      end
+
+      private
+
+      def resolve_session_store(store)
+        case store
+        when nil, :memory
+          Spurline::Session::Store::Memory.new
+        when :sqlite
+          Spurline::Session::Store::SQLite.new(path: Spurline.config.session_store_path)
+        when :postgres
+          url = Spurline.config.session_store_postgres_url
+          unless url && !url.strip.empty?
+            raise Spurline::ConfigurationError,
+              "session_store_postgres_url must be set when using :postgres session store. " \
+              "Set it via Spurline.configure { |c| c.session_store_postgres_url = \"postgresql://...\" }."
+          end
+          Spurline::Session::Store::Postgres.new(url: url)
+        else
+          return store if store.respond_to?(:save) &&
+            store.respond_to?(:load) &&
+            store.respond_to?(:delete) &&
+            store.respond_to?(:exists?)
+
+          raise Spurline::ConfigurationError,
+            "Invalid session_store: #{store.inspect}. " \
+            "Use :memory, :sqlite, :postgres, or an object implementing save/load/delete/exists?."
+        end
+      end
+
+      def register_default_adapters!(registry)
+        DEFAULT_ADAPTERS.each do |name, config|
+          registry.register(name, config[:adapter])
+        end
+      end
+    end
+  end
+end

data/lib/spurline/cartographer/analyzer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Spurline
+  module Cartographer
+    class Analyzer
+      attr_reader :repo_path, :findings
+
+      def initialize(repo_path:)
+        @repo_path = File.expand_path(repo_path)
+        @findings = {}
+      end
+
+      # Subclasses implement this. Returns a hash merged into RepoProfile.
+      def analyze
+        raise NotImplementedError, "#{self.class}#analyze must return a findings hash"
+      end
+
+      # Per-layer confidence score (0.0-1.0).
+      def confidence
+        1.0
+      end
+
+      private
+
+      def file_exists?(relative_path)
+        return false if excluded_relative_path?(relative_path)
+
+        File.exist?(File.join(repo_path, relative_path))
+      end
+
+      def read_file(relative_path)
+        return nil if excluded_relative_path?(relative_path)
+
+        path = File.join(repo_path, relative_path)
+        return nil unless File.file?(path)
+
+        File.read(path)
+      end
+
+      def glob(pattern)
+        Dir.glob(File.join(repo_path, pattern)).reject do |path|
+          excluded_relative_path?(relative_path(path))
+        end
+      end
+
+      def relative_path(path)
+        path.to_s.sub(%r{\A#{Regexp.escape(repo_path)}/?}, "")
+      end
+
+      def excluded_relative_path?(relative_path)
+        normalized = relative_path.to_s.sub(%r{\A\./}, "").sub(%r{\A/}, "")
+        return false if normalized.empty?
+
+        excluded_patterns.any? do |pattern|
+          token = pattern.to_s.sub(%r{\A\./}, "").sub(%r{\A/}, "").sub(%r{/$}, "")
+          if token.include?("/")
+            normalized == token || normalized.start_with?("#{token}/")
+          else
+            normalized.split("/").include?(token)
+          end
+        end
+      end
+
+      def excluded_patterns
+        Array(Spurline.config.cartographer_exclude_patterns)
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/spurline/cartographer/analyzers/ci_config.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Spurline
+  module Cartographer
+    module Analyzers
+      class CIConfig < Analyzer
+        def analyze
+          providers = []
+          commands = []
+
+          github_workflows = glob(".github/workflows/*.{yml,yaml}")
+          unless github_workflows.empty?
+            providers << :github_actions
+            github_workflows.each do |workflow_path|
+              commands.concat(extract_github_commands(workflow_path))
+            end
+          end
+
+          circle_config_path = File.join(repo_path, ".circleci", "config.yml")
+          if File.file?(circle_config_path)
+            providers << :circleci
+            commands.concat(extract_circleci_commands(circle_config_path))
+          end
+
+          gitlab_path = File.join(repo_path, ".gitlab-ci.yml")
+          if File.file?(gitlab_path)
+            providers << :gitlab_ci
+            commands.concat(extract_gitlab_commands(gitlab_path))
+          end
+
+          jenkinsfile_path = File.join(repo_path, "Jenkinsfile")
+          if File.file?(jenkinsfile_path)
+            providers << :jenkins
+            commands.concat(extract_jenkins_commands(jenkinsfile_path))
+          end
+
+          ci_hash = {}
+          ci_hash[:provider] = providers.first if providers.any?
+          ci_hash[:providers] = providers if providers.any?
+          ci_hash[:test_command] = pick_command(commands) { |cmd| test_command?(cmd) }
+          ci_hash[:lint_command] = pick_command(commands) { |cmd| lint_command?(cmd) }
+          ci_hash[:deploy_command] = pick_command(commands) { |cmd| deploy_command?(cmd) }
+          ci_hash.compact!
+
+          @findings = {
+            ci: ci_hash,
+            metadata: {
+              ci_config: {
+                command_count: commands.length,
+              },
+            },
+          }
+        end
+
+        def confidence
+          providers = findings.dig(:ci, :providers)
+          providers && !providers.empty? ? 1.0 : 0.5
+        end
+
+        private
+
+        def extract_github_commands(path)
+          payload = safe_yaml_load(path)
+          return [] unless payload.is_a?(Hash)
+
+          jobs = payload["jobs"]
+          return [] unless jobs.is_a?(Hash)
+
+          jobs.values.flat_map do |job|
+            next [] unless job.is_a?(Hash)
+
+            steps = job["steps"]
+            next [] unless steps.is_a?(Array)
+
+            steps.filter_map do |step|
+              next unless step.is_a?(Hash)
+
+              normalize_command(step["run"])
+            end
+          end
+        end
+
+        def extract_circleci_commands(path)
+          payload = safe_yaml_load(path)
+          return [] unless payload.is_a?(Hash)
+
+          jobs = payload["jobs"]
+          return [] unless jobs.is_a?(Hash)
+
+          jobs.values.flat_map do |job|
+            next [] unless job.is_a?(Hash)
+
+            steps = job["steps"]
+            next [] unless steps.is_a?(Array)
+
+            steps.filter_map do |step|
+              case step
+              when String
+                nil
+              when Hash
+                run = step["run"] || step[:run]
+                if run.is_a?(Hash)
+                  normalize_command(run["command"] || run[:command])
+                else
+                  normalize_command(run)
+                end
+              end
+            end
+          end
+        end
+
+        def extract_gitlab_commands(path)
+          payload = safe_yaml_load(path)
+          return [] unless payload.is_a?(Hash)
+
+          payload.values.flat_map do |job|
+            next [] unless job.is_a?(Hash)
+
+            scripts = job["script"] || job[:script]
+            case scripts
+            when Array
+              scripts.filter_map { |script| normalize_command(script) }
+            when String
+              [normalize_command(scripts)].compact
+            else
+              []
+            end
+          end
+        end
+
+        def extract_jenkins_commands(path)
+          content = File.read(path)
+          commands = content.scan(/\bsh\s+["']([^"']+)["']/).flatten
+          commands.filter_map { |command| normalize_command(command) }
+        rescue Errno::ENOENT
+          []
+        end
+
+        def safe_yaml_load(path)
+          YAML.safe_load(File.read(path), aliases: true)
+        rescue Psych::SyntaxError, Errno::ENOENT
+          nil
+        end
+
+        def pick_command(commands)
+          commands.find { |command| yield(command) }
+        end
+
+        def normalize_command(value)
+          return nil unless value
+
+          value.to_s.strip.gsub(/\s+/, " ")
+        end
+
+        def test_command?(command)
+          command.match?(/\b(rspec|minitest|pytest|go test|cargo test|npm test|yarn test|pnpm test|rake test|bundle exec rspec|bundle exec rake spec)\b/i)
+        end
+
+        def lint_command?(command)
+          command.match?(/\b(rubocop|eslint|prettier|standardrb|lint)\b/i)
+        end
+
+        def deploy_command?(command)
+          command.match?(/\b(deploy|kubectl|helm|terraform apply|cap\s)\b/i)
+        end
+      end
+    end
+  end
+end

data/lib/spurline/cartographer/analyzers/dotfiles.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Spurline
+  module Cartographer
+    module Analyzers
+      class Dotfiles < Analyzer
+        RUBOCOP_FILES = [".rubocop.yml"].freeze
+        ESLINT_FILES = %w[
+          .eslintrc
+          .eslintrc.json
+          .eslintrc.yml
+          .eslintrc.yaml
+          .eslintrc.js
+        ].freeze
+        PRETTIER_FILES = %w[
+          .prettierrc
+          .prettierrc.json
+          .prettierrc.yml
+          .prettierrc.yaml
+        ].freeze
+
+        def analyze
+          style_configs = {}
+          env_vars = parse_env_example
+
+          rubocop_file = RUBOCOP_FILES.find { |path| file_exists?(path) }
+          style_configs[:rubocop] = parse_yaml_keys(rubocop_file) if rubocop_file
+
+          eslint_file = ESLINT_FILES.find { |path| file_exists?(path) }
+          style_configs[:eslint] = parse_config_keys(eslint_file) if eslint_file
+
+          prettier_file = PRETTIER_FILES.find { |path| file_exists?(path) }
+          style_configs[:prettier] = parse_config_keys(prettier_file) if prettier_file
+
+          style_configs[:editorconfig] = parse_editorconfig_keys if file_exists?(".editorconfig")
+
+          runtime_versions = {}
+          nvmrc = read_file(".nvmrc")&.strip
+          runtime_versions[:node] = nvmrc if nvmrc && !nvmrc.empty?
+          runtime_versions.merge!(parse_tool_versions)
+
+          @findings = {
+            environment_vars_required: env_vars,
+            metadata: {
+              dotfiles: {
+                style_configs: style_configs,
+                runtime_versions: runtime_versions,
+              },
+            },
+          }
+        end
+
+        def confidence
+          has_dotfiles = findings.dig(:metadata, :dotfiles, :style_configs)&.any?
+          has_dotfiles ? 0.9 : 0.6
+        end
+
+        private
+
+        def parse_env_example
+          content = read_file(".env.example")
+          return [] unless content
+
+          content.each_line.filter_map do |line|
+            match = line.match(/^\s*([A-Z][A-Z0-9_]*)\s*=/)
+            match&.captures&.first
+          end.uniq.sort
+        end
+
+        def parse_editorconfig_keys
+          content = read_file(".editorconfig")
+          return [] unless content
+
+          content.each_line.filter_map do |line|
+            stripped = line.strip
+            next if stripped.empty? || stripped.start_with?("#", ";", "[")
+
+            stripped.split("=").first&.strip
+          end.uniq.sort
+        end
+
+        def parse_tool_versions
+          content = read_file(".tool-versions")
+          return {} unless content
+
+          content.each_line.each_with_object({}) do |line, hash|
+            stripped = line.strip
+            next if stripped.empty? || stripped.start_with?("#")
+
+            tool, version = stripped.split(/\s+/, 2)
+            next unless tool && version
+
+            hash[tool.to_sym] = version.strip
+          end
+        end
+
+        def parse_config_keys(relative_path)
+          return [] unless relative_path
+
+          if relative_path.end_with?(".json") || relative_path == ".eslintrc" || relative_path == ".prettierrc"
+            parse_json_keys(relative_path)
+          elsif relative_path.end_with?(".yml") || relative_path.end_with?(".yaml")
+            parse_yaml_keys(relative_path)
+          else
+            ["config_present"]
+          end
+        end
+
+        def parse_yaml_keys(relative_path)
+          return [] unless relative_path
+
+          payload = YAML.safe_load(read_file(relative_path), aliases: true)
+          return [] unless payload.is_a?(Hash)
+
+          payload.keys.map(&:to_s).sort
+        rescue Psych::SyntaxError, NoMethodError
+          []
+        end
+
+        def parse_json_keys(relative_path)
+          payload = JSON.parse(read_file(relative_path))
+          return [] unless payload.is_a?(Hash)
+
+          payload.keys.map(&:to_s).sort
+        rescue JSON::ParserError, NoMethodError
+          []
+        end
+      end
+    end
+  end
+end

data/lib/spurline/cartographer/analyzers/entry_points.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+
+module Spurline
+  module Cartographer
+    module Analyzers
+      class EntryPoints < Analyzer
+        def analyze
+          grouped = {
+            web: Set.new,
+            background: Set.new,
+            console: Set.new,
+            test: Set.new,
+            lint: Set.new,
+            deploy: Set.new,
+          }
+
+          collect_executables(grouped)
+          collect_procfile(grouped)
+          collect_makefile(grouped)
+          collect_package_scripts(grouped)
+          collect_rakefile(grouped)
+
+          @findings = {
+            entry_points: grouped.transform_values { |commands| commands.to_a.sort },
+          }
+        end
+
+        def confidence
+          commands = findings[:entry_points].values.flatten
+          commands.empty? ? 0.5 : 0.9
+        end
+
+        private
+
+        def collect_executables(grouped)
+          (glob("bin/*") + glob("exe/*")).uniq.each do |path|
+            next unless File.file?(path)
+
+            command = "./#{relative_path(path)}"
+            classify_command(grouped, File.basename(path), command)
+          end
+        end
+
+        def collect_procfile(grouped)
+          content = read_file("Procfile")
+          return unless content
+
+          content.each_line do |line|
+            stripped = line.strip
+            next if stripped.empty? || stripped.start_with?("#")
+
+            type, command = stripped.split(":", 2)
+            next unless type && command
+
+            normalized = command.strip
+            case type.strip
+            when "web"
+              grouped[:web] << normalized
+            when "worker", "jobs", "queue"
+              grouped[:background] << normalized
+            when "console"
+              grouped[:console] << normalized
+            when "test"
+              grouped[:test] << normalized
+            end
+          end
+        end
+
+        def collect_makefile(grouped)
+          content = read_file("Makefile")
+          return unless content
+
+          content.each_line do |line|
+            match = line.match(/^([A-Za-z0-9_.-]+):(?:\s|$)/)
+            next unless match
+
+            target = match[1]
+            next if target.start_with?(".") || target.include?("%")
+
+            command = "make #{target}"
+            classify_command(grouped, target, command)
+          end
+        end
+
+        def collect_package_scripts(grouped)
+          content = read_file("package.json")
+          return unless content
+
+          package = JSON.parse(content)
+          scripts = package["scripts"]
+          return unless scripts.is_a?(Hash)
+
+          scripts.each do |name, script|
+            command = script.to_s.strip
+            next if command.empty?
+
+            classify_command(grouped, name, command)
+          end
+        rescue JSON::ParserError
+          nil
+        end
+
+        def collect_rakefile(grouped)
+          content = read_file("Rakefile")
+          return unless content
+
+          grouped[:test] << "bundle exec rake spec" if content.match?(/RSpec::Core::RakeTask|task\s+:spec/)
+          grouped[:console] << "bundle exec rake -T"
+        end
+
+        def classify_command(grouped, name, command)
+          token = name.to_s.downcase
+          lower_command = command.downcase
+
+          if token.match?(/web|server|start|puma|rails/) || lower_command.match?(/\b(puma|rails server|rackup|npm start|node\s+)/)
+            grouped[:web] << command
+          end
+
+          if token.match?(/worker|job|queue|sidekiq|resque/) || lower_command.match?(/\b(sidekiq|resque|worker)\b/)
+            grouped[:background] << command
+          end
+
+          if token.match?(/console|repl|irb|pry/) || lower_command.match?(/\b(rails console|irb|pry)\b/)
+            grouped[:console] << command
+          end
+
+          if token.match?(/test|spec|rspec|jest|pytest/) || lower_command.match?(/\b(rspec|jest|pytest|minitest|go test|cargo test|npm test|bundle exec rspec)\b/)
+            grouped[:test] << command
+          end
+
+          if token.match?(/lint|rubocop|eslint|prettier/) || lower_command.match?(/\b(rubocop|eslint|prettier|lint)\b/)
+            grouped[:lint] << command
+          end
+
+          if token.match?(/deploy|release/) || lower_command.match?(/\b(deploy|kubectl|helm|cap\s)\b/)
+            grouped[:deploy] << command
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spurline/cartographer/analyzers/file_signatures.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Spurline
+  module Cartographer
+    module Analyzers
+      class FileSignatures < Analyzer
+        LANGUAGE_SENTINELS = {
+          ruby: %w[Gemfile Gemfile.lock .ruby-version Rakefile],
+          javascript: %w[package.json .node-version .nvmrc],
+          python: %w[pyproject.toml .python-version requirements.txt],
+          go: %w[go.mod],
+          rust: %w[Cargo.toml],
+          java: %w[pom.xml],
+        }.freeze
+
+        TOOLCHAIN_SENTINELS = %w[Makefile docker-compose.yml Dockerfile].freeze
+        PRIORITY = %i[ruby javascript python go rust java].freeze
+
+        def analyze
+          language_scores = {}
+          detected = {}
+
+          LANGUAGE_SENTINELS.each do |language, files|
+            present = files.select { |file| file_exists?(file) }
+            next if present.empty?
+
+            language_scores[language] = present.length
+            detected[language] = present
+          end
+
+          ordered_languages = language_scores.keys.sort_by do |language|
+            [-language_scores[language], PRIORITY.index(language) || PRIORITY.length]
+          end
+
+          @findings = {
+            languages: {
+              primary: ordered_languages.first,
+              secondary: ordered_languages.drop(1),
+            },
+            metadata: {
+              file_signatures: {
+                detected: detected,
+                toolchain: TOOLCHAIN_SENTINELS.select { |file| file_exists?(file) },
+              },
+            },
+          }
+        end
+
+        def confidence
+          findings.dig(:languages, :primary).nil? ? 0.85 : 1.0
+        end
+      end
+    end
+  end
+end