ariadna 1.3.0 → 2.0.0

data/data/skills/rails-testing/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: rails-testing
+description: Ruby on Rails testing conventions — Minitest strategy, fixtures, system tests. Use when writing tests, setting up test data, or running test suites.
+---
+
+# Rails Testing Skill
+
+Testing strategy for Rails applications using **Minitest** and **fixtures**. Not RSpec, not FactoryBot.
+
+**Sub-files:**
+- [FIXTURES.md](FIXTURES.md) — Fixture patterns and test data management
+- [SYSTEM-TESTS.md](SYSTEM-TESTS.md) — System and integration test conventions
+
+---
+
+## Philosophy
+
+- **Test at the model level first** — Business logic lives in models; that's where tests provide the most value
+- **Fixtures over factories** — YAML fixtures are deterministic, fast, and require no setup code
+- **Always set `Current.session`** — Lambda defaults and multi-tenancy depend on it; forgetting it is the #1 test failure
+- **Test behavior, not implementation** — Assert on outcomes, not internal method calls
+- **Use `assert_difference` for state changes** — Catches false positives that boolean checks alone miss
+
+---
+
+## File Organization
+
+```
+test/
+  models/
+    card/
+      archivable_test.rb    # Concern tests get their own file
+    card_test.rb
+  controllers/
+    cards/
+      closures_controller_test.rb
+  jobs/
+    notify_recipients_job_test.rb
+  fixtures/
+    cards.yml
+    sessions.yml
+```
+
+---
+
+## Standard Test Structure
+
+```ruby
+require "test_helper"
+
+class Card::CloseableTest < ActiveSupport::TestCase
+  setup do
+    Current.session = sessions(:david)  # Always — sets user + account context
+  end
+
+  test "close creates closure record and marks card closed" do
+    card = cards(:logo)
+
+    assert_difference -> { Closure.count }, +1 do
+      card.close
+    end
+
+    assert card.closed?
+  end
+end
+```
+
+---
+
+## Model Testing
+
+### State Changes
+
+Nest `assert_difference` blocks when multiple record types change together:
+
+```ruby
+assert_difference -> { Closure.count }, +1 do
+  assert_difference -> { Event.count }, +1 do
+    card.close
+  end
+end
+
+assert card.closed?
+assert_equal "card_closed", Event.last.action
+```
+
+### Event Attributes
+
+Count alone is insufficient — always verify attributes:
+
+```ruby
+event = Event.last
+assert_equal "card_archived", event.action
+assert_equal card, event.eventable
+assert_equal Current.user, event.creator
+# For events with particulars:
+assert_equal old_board.name, event.particulars["old_board"]
+```
+
+### Scopes
+
+```ruby
+card.archive
+
+assert_includes Card.archived, card
+assert_not_includes Card.unarchived, card
+```
+
+---
+
+## Controller Testing
+
+Inherit from `ActionDispatch::IntegrationTest`. Assert on model state after the request:
+
+```ruby
+class Cards::ClosuresControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    Current.session = sessions(:david)
+    @card = cards(:logo)
+  end
+
+  test "create closes the card" do
+    post card_closure_path(@card.number)
+    assert @card.reload.closed?
+  end
+end
+```
+
+---
+
+## Job Testing
+
+Test synchronous logic and async enqueuing separately:
+
+```ruby
+# Business logic — fast, no job infrastructure
+test "process_data updates records" do
+  record.process_data
+  assert record.processed?
+end
+
+# Async wrapper — verify enqueuing
+test "process_data_later enqueues job" do
+  assert_enqueued_with(job: ProcessDataJob, args: [record]) do
+    record.process_data_later
+  end
+end
+```
+
+Multi-tenancy is automatic — `Current.account` is captured and restored by the job extension. Setting `Current.session` in `setup` is sufficient.
+
+---
+
+## Common Gotchas
+
+**1. Missing `Current.session`** — Lambda defaults (`default: -> { Current.user }`) raise `nil` errors. Put it in `setup`, not inline.
+
+**2. Only checking event count** — After `assert_difference`, verify `Event.last.action`, `eventable`, and `creator`.
+
+**3. Skipping `assert_difference`** — `assert card.archived?` can pass if the flag is set wrong. Wrap the action in `assert_difference -> { Card::Archive.count }, +1` to confirm the record was created.

data/data/skills/rails-testing/SYSTEM-TESTS.md

@@ -0,0 +1,73 @@
+# System Tests & Integration Tests
+
+Part of the [Rails Testing Skill](SKILL.md).
+
+---
+
+## When to Write System Tests
+
+System tests (browser-driven via Capybara) are reserved for **critical user flows**:
+
+- Authentication and session management
+- Multi-step form submissions
+- JavaScript-dependent interactions (Turbo streams, Stimulus)
+- Flows that span multiple controllers
+
+For business logic, prefer model tests — faster and more precise.
+
+---
+
+## Test Type Selection
+
+| Concern | Use |
+|---|---|
+| Business logic, state changes | Model test (`ActiveSupport::TestCase`) |
+| Controller routing, response codes | `ActionDispatch::IntegrationTest` |
+| Full browser flow, JS interactions | System test (`ApplicationSystemTestCase`) |
+| Job enqueuing | `assert_enqueued_with` in model/controller test |
+
+---
+
+## System Test Structure
+
+```ruby
+require "application_system_test_case"
+
+class CardLifecycleTest < ApplicationSystemTestCase
+  setup do
+    sign_in_as users(:david)
+  end
+
+  test "user can close and reopen a card" do
+    visit card_path(cards(:logo))
+    click_on "Close"
+    assert_text "Card closed"
+
+    click_on "Reopen"
+    assert_text "Card reopened"
+  end
+end
+```
+
+Define `sign_in_as` in `ApplicationSystemTestCase` — do not repeat the login flow in each test.
+
+---
+
+## Integration Tests (Controller-Level)
+
+For HTTP assertions without a browser, set `Current.session` directly:
+
+```ruby
+class Cards::ClosuresControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    Current.session = sessions(:david)
+  end
+
+  test "POST creates closure and redirects" do
+    post card_closure_path(cards(:logo).number)
+    assert_redirected_to card_path(cards(:logo).number)
+  end
+end
+```
+
+No browser sign-in flow needed — `Current.session` assignment is sufficient for controller tests.

data/lib/ariadna/installer.rb

@@ -21,7 +21,7 @@ module Ariadna
 
       copy_commands
       copy_agents
-      copy_guides
+      copy_skills
       copy_content
       write_version
       install_statusline
@@ -125,7 +125,7 @@ module Ariadna
 
     def source_manifest_keys
       keys = []
-      %w[commands/ariadna agents guides ariadna].each do |subdir|
+      %w[commands/ariadna agents skills ariadna].each do |subdir|
         src_base = subdir == "agents" ? source_dir : source_dir
         dir = File.join(src_base, subdir)
         next unless File.directory?(dir)
@@ -142,7 +142,7 @@ module Ariadna
     end
 
     def cleanup_empty_dirs
-      %w[commands/ariadna agents guides ariadna].each do |subdir|
+      %w[commands/ariadna agents skills ariadna].each do |subdir|
         dir = File.join(@target_dir, subdir)
         next unless File.directory?(dir)
 
@@ -201,23 +201,19 @@ module Ariadna
       puts "  \u2713 Installed #{count} agents"
     end
 
-    def copy_guides
-      src = File.join(source_dir, "guides")
-      dest = File.join(@target_dir, "guides")
-      FileUtils.mkdir_p(dest)
-
-      Dir[File.join(src, "*.md")].each do |file|
-        FileUtils.cp(file, File.join(dest, File.basename(file)))
-      end
-      count = Dir[File.join(dest, "*.md")].size
-      puts "  \u2713 Installed #{count} guides"
+    def copy_skills
+      src = File.join(source_dir, "skills")
+      dest = File.join(@target_dir, "skills")
+      copy_tree(src, dest)
+      count = Dir[File.join(dest, "*")].count { |d| File.directory?(d) }
+      puts "  \u2713 Installed #{count} skills"
     end
 
     def copy_content
       src = File.join(source_dir, "ariadna")
       dest = File.join(@target_dir, "ariadna")
       copy_tree(src, dest)
-      puts "  \u2713 Installed ariadna/ (workflows, templates, references)"
+      puts "  \u2713 Installed ariadna/ (workflows, templates)"
     end
 
     def write_version
@@ -240,7 +236,7 @@ module Ariadna
 
     def generate_manifest_entries
       entries = {}
-      %w[commands/ariadna agents guides ariadna].each do |subdir|
+      %w[commands/ariadna agents skills ariadna].each do |subdir|
         dir = File.join(@target_dir, subdir)
         next unless File.directory?(dir)
 

data/lib/ariadna/tools/cli.rb

@@ -30,9 +30,6 @@ module Ariadna
         when "verify-path-exists"
           require_relative "utilities"
           Utilities.verify_path_exists(argv, raw: raw)
-        when "verify-summary"
-          require_relative "verification"
-          Verification.verify_summary(argv, raw: raw)
         when "config-ensure-section"
           require_relative "config_manager"
           ConfigManager.ensure_section(argv, raw: raw)
@@ -42,12 +39,6 @@ module Ariadna
         when "history-digest"
           require_relative "state_manager"
           StateManager.history_digest(argv, raw: raw)
-        when "summary-extract"
-          require_relative "state_manager"
-          StateManager.summary_extract(argv, raw: raw)
-        when "state-snapshot"
-          require_relative "state_manager"
-          StateManager.snapshot(argv, raw: raw)
         when "phase-plan-index"
           require_relative "phase_manager"
           PhaseManager.plan_index(argv, raw: raw)
@@ -63,9 +54,6 @@ module Ariadna
         when "milestone"
           require_relative "phase_manager"
           PhaseManager.milestone_dispatch(argv, raw: raw)
-        when "validate"
-          require_relative "verification"
-          Verification.validate_dispatch(argv, raw: raw)
         when "progress"
           require_relative "roadmap_analyzer"
           RoadmapAnalyzer.progress(argv, raw: raw)

data/lib/ariadna/tools/config_manager.rb

@@ -7,70 +7,25 @@ module Ariadna
     module ConfigManager
       DEFAULTS = {
         "model_profile" => "balanced",
-        "commit_docs" => true,
-        "search_gitignored" => false,
+        "verifier" => true,
         "branching_strategy" => "none",
         "phase_branch_template" => "ariadna/phase-{phase}-{slug}",
         "milestone_branch_template" => "ariadna/{milestone}-{slug}",
-        "research" => false,
-        "plan_checker" => true,
-        "verifier" => true,
-        "parallelization" => true,
-        "execution_mode" => "vertical",
-        "team_execution" => false
+        "commit_docs" => true,
+        "search_gitignored" => false,
+        "parallelization" => true
       }.freeze
 
       def self.load_config(cwd = Dir.pwd)
         config_path = File.join(cwd, ".ariadna_planning", "config.json")
         return DEFAULTS.dup unless File.exist?(config_path)
 
-        raw = File.read(config_path)
-        parsed = JSON.parse(raw)
-
-        get = lambda do |key, nested = nil|
-          return parsed[key] if parsed.key?(key)
-
-          if nested && parsed[nested[:section]].is_a?(Hash)
-            val = parsed[nested[:section]][nested[:field]]
-            return val unless val.nil?
-          end
-          nil
-        end
-
-        parallelization = begin
-          val = get.call("parallelization")
-          if val.is_a?(Hash) && val.key?("enabled")
-            val["enabled"]
-          elsif [true, false].include?(val)
-            val
-          else
-            DEFAULTS["parallelization"]
-          end
+        parsed = JSON.parse(File.read(config_path))
+        result = DEFAULTS.dup
+        DEFAULTS.each_key do |key|
+          result[key] = parsed[key] unless parsed[key].nil?
         end
-
-        # nil_or helper: use default only when value is nil (preserves false)
-        nil_or = ->(val, default) { val.nil? ? default : val }
-
-        {
-          "model_profile" => get.call("model_profile") || DEFAULTS["model_profile"],
-          "commit_docs" => nil_or.call(get.call("commit_docs", { section: "planning", field: "commit_docs" }), DEFAULTS["commit_docs"]),
-          "search_gitignored" => nil_or.call(get.call("search_gitignored", { section: "planning", field: "search_gitignored" }), DEFAULTS["search_gitignored"]),
-          "branching_strategy" => get.call("branching_strategy", { section: "git", field: "branching_strategy" }) || DEFAULTS["branching_strategy"],
-          "phase_branch_template" => get.call("phase_branch_template", { section: "git", field: "phase_branch_template" }) || DEFAULTS["phase_branch_template"],
-          "milestone_branch_template" => get.call("milestone_branch_template", { section: "git", field: "milestone_branch_template" }) || DEFAULTS["milestone_branch_template"],
-          "research" => nil_or.call(get.call("research", { section: "workflow", field: "research" }), DEFAULTS["research"]),
-          "plan_checker" => nil_or.call(get.call("plan_checker", { section: "workflow", field: "plan_check" }), DEFAULTS["plan_checker"]),
-          "verifier" => nil_or.call(get.call("verifier", { section: "workflow", field: "verifier" }), DEFAULTS["verifier"]),
-          "parallelization" => parallelization,
-          "execution_mode" => get.call("execution_mode", { section: "execution", field: "mode" }) || DEFAULTS["execution_mode"],
-          "team_execution" => begin
-            val = get.call("team_execution", { section: "execution", field: "team" })
-            case val
-            when "auto", true, false then val
-            else DEFAULTS["team_execution"]
-            end
-          end
-        }
+        result
       rescue JSON::ParserError
         DEFAULTS.dup
       end
@@ -87,24 +42,7 @@ module Ariadna
           return
         end
 
-        defaults = {
-          model_profile: "balanced",
-          commit_docs: true,
-          search_gitignored: false,
-          branching_strategy: "none",
-          phase_branch_template: "ariadna/phase-{phase}-{slug}",
-          milestone_branch_template: "ariadna/{milestone}-{slug}",
-          workflow: {
-            research: false,
-            plan_check: true,
-            verifier: true
-          },
-          parallelization: true,
-          execution_mode: "vertical",
-          team_execution: false
-        }
-
-        File.write(config_path, JSON.pretty_generate(defaults))
+        File.write(config_path, JSON.pretty_generate(DEFAULTS))
         Output.json({ created: true, path: ".ariadna_planning/config.json" }, raw: raw, raw_value: "created")
       end
 

data/lib/ariadna/tools/frontmatter.rb

@@ -7,9 +7,15 @@ module Ariadna
       SCHEMAS = {
         "plan" => %w[phase plan type],
         "summary" => %w[phase plan subsystem],
-        "verification" => %w[phase]
+        "verification" => %w[phase],
+        "skill" => %w[name description]
       }.freeze
 
+      SKILL_RESERVED_WORDS = %w[anthropic claude].freeze
+      SKILL_NAME_PATTERN = /\A[a-z][a-z0-9-]*\z/
+      SKILL_NAME_MAX = 64
+      SKILL_DESCRIPTION_MAX = 1024
+
       def self.dispatch(argv, raw: false)
         subcommand = argv.shift
         file = argv.shift
@@ -191,6 +197,22 @@ module Ariadna
         Output.error("File not found: #{file}")
       end
 
+      def self.validate_skill(fm)
+        errors = []
+        name = fm["name"].to_s
+        description = fm["description"].to_s
+
+        errors << "name must match lowercase-hyphens pattern" unless name.match?(SKILL_NAME_PATTERN)
+        errors << "name must be #{SKILL_NAME_MAX} chars or fewer" if name.length > SKILL_NAME_MAX
+        if SKILL_RESERVED_WORDS.any? { |w| name.include?(w) }
+          errors << "name contains reserved word"
+        end
+        errors << "description must not be empty" if description.empty?
+        errors << "description must be #{SKILL_DESCRIPTION_MAX} chars or fewer" if description.length > SKILL_DESCRIPTION_MAX
+
+        errors
+      end
+
       # --- Private helpers ---
 
       def self.parse_yaml(yaml_str)