rcrewai 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05099e1309676b2a0d1028fc658aead2c212aa39903a0e75f13a944063897806'
-  data.tar.gz: 39a53213a82a4e6d5f44d71eca94ac2b960e657c07fc42af4f2290e162188ab7
+  metadata.gz: f742fcf06518c80cbf29191d0eff275830ee618c9b896c3d443258b06aa120ff
+  data.tar.gz: 5cc9c03182d0bd80d73d99edb08f2267252684f64a23da1626d2d61e0abe1683
 SHA512:
-  metadata.gz: 500fcf358b1473741b0248f6ce12b721d6d8d2d5f55bf849d6bec9c74faa525e7e067794613de89983470c9d8b1c10d4375eef4867e7ffc4058c441fc0cd607a
-  data.tar.gz: 428121cbe207d084507671874f786563357d48b18fe1517ab01a7c83460ddaf1604211f9d9d934d170ecdce82b0e69f5d7373bfdc63876b435bcb209f25d7d70
+  metadata.gz: 0c32e4110a5bbabac9b120262e2ebe0e86b0c58c3b4213a11214efcff647024d9714fcee12934f4b734c9f64184e1f802d82b97ec50e5dc7ceab424c4cec38f1
+  data.tar.gz: 8a678ae53008c7c6a73cf365b460b80989da05f22eb646cf3a9126028a0d6dd220e6af75ef4dee80c02d73e69b536fb3d2b7c23f827e929078b76ed450d8f1ce

data/.rubocop.yml

@@ -0,0 +1,21 @@
+inherit_from: .rubocop_todo.yml
+
+Naming/MethodParameterName:
+  # `k` (top-k retrieval) and short math vars for vector similarity are
+  # conventional and clearer than forced longer names. The rest are RuboCop's
+  # defaults, restated because AllowedNames replaces rather than extends.
+  AllowedNames:
+    - k
+    - a
+    - b
+    - io
+    - id
+    - to
+    - by
+    - 'on'
+    - in
+    - at
+    - ip
+    - db
+    - os
+    - pp

data/.rubocop_todo.yml

@@ -0,0 +1,99 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2026-05-12 09:06:14 UTC using RuboCop version 1.78.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 2
+Lint/DuplicateMethods:
+  Exclude:
+    - 'lib/rcrewai/configuration.rb'
+
+# Offense count: 55
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 61
+
+# Offense count: 30
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+# AllowedMethods: refine
+Metrics/BlockLength:
+  Max: 325
+
+# Offense count: 1
+# Configuration parameters: CountBlocks, CountModifierForms.
+Metrics/BlockNesting:
+  Max: 4
+
+# Offense count: 14
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ClassLength:
+  Max: 408
+
+# Offense count: 33
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/CyclomaticComplexity:
+  Max: 21
+
+# Offense count: 99
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 67
+
+# Offense count: 1
+# Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
+Metrics/ParameterLists:
+  Max: 6
+
+# Offense count: 18
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/PerceivedComplexity:
+  Max: 21
+
+# Offense count: 1
+# Configuration parameters: NamePrefix, ForbiddenPrefixes, AllowedMethods, MethodDefinitionMacros, UseSorbetSigs.
+# NamePrefix: is_, has_, have_, does_
+# ForbiddenPrefixes: is_, has_, have_, does_
+# AllowedMethods: is_a?
+# MethodDefinitionMacros: define_method, define_singleton_method
+Naming/PredicatePrefix:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/rcrewai/agent.rb'
+
+# Offense count: 32
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Enabled: false
+
+# Offense count: 23
+# This cop supports safe autocorrection (--autocorrect).
+Style/IfUnlessModifier:
+  Exclude:
+    - 'lib/rcrewai/agent.rb'
+    - 'lib/rcrewai/human_input.rb'
+    - 'lib/rcrewai/llm_clients/ollama.rb'
+    - 'lib/rcrewai/memory.rb'
+    - 'lib/rcrewai/process.rb'
+    - 'lib/rcrewai/tools/code_executor.rb'
+    - 'lib/rcrewai/tools/email_sender.rb'
+    - 'lib/rcrewai/tools/file_writer.rb'
+    - 'lib/rcrewai/tools/pdf_processor.rb'
+    - 'lib/rcrewai/tools/sql_database.rb'
+
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: ExactNameMatch, AllowPredicates, AllowDSLWriters, IgnoreClassMethods, AllowedMethods.
+# AllowedMethods: to_ary, to_a, to_c, to_enum, to_h, to_hash, to_i, to_int, to_io, to_open, to_path, to_proc, to_r, to_regexp, to_str, to_s, to_sym
+Style/TrivialAccessors:
+  Exclude:
+    - 'lib/rcrewai/process.rb'
+
+# Offense count: 16
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, IgnoreCopDirectives, AllowedPatterns, SplitStrings.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 201

data/CHANGELOG.md

@@ -7,6 +7,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-07-03
+
+This release closes the feature-parity gap with the modern CrewAI framework,
+adding its second pillar (**Flows**) alongside **Knowledge (RAG)**, structured
+output, guardrails, planning, and training/testing. See `ROADMAP.md`.
+
+### Added
+
+#### Flows (#11)
+- `RCrewAI::Flow` — an event-driven workflow engine (CrewAI's second pillar). Subclass it and declare methods with a class-level DSL: `start`, `listen`, `router`, and the `and_` / `or_` trigger combinators. `kickoff` runs the graph to a fixed point; routers emit labels that listeners trigger on.
+- Flow state (`Flow::State`) is a schemaless object with an automatic UUID, seedable via `kickoff(inputs:)`.
+- Flow persistence: pluggable state stores (`Flow::MemoryStateStore`, `Flow::FileStateStore`, or any `#save`/`#load` object); `flow.restore(id)` resumes a persisted run.
+- Flows can invoke a `Crew` as a step and pause for input via `#human_feedback`.
+
+#### Knowledge / RAG (#9)
+- `RCrewAI::Knowledge` module adds retrieval-augmented context. Sources (`StringSource`, `FileSource`, `PdfSource`, `CsvSource`, `UrlSource`) are chunked, embedded, and stored in an in-memory cosine-similarity vector store (no external DB required).
+- Attach via `Agent.new(knowledge:)` / `knowledge_sources:` (role-specific) or `Crew.new(knowledge:)` / `knowledge_sources:` (shared with all agents); relevant chunks are injected into each task's prompt at execution.
+- The embedder (`Knowledge::Embedder`, default OpenAI `text-embedding-3-small`) and vector store are pluggable.
+
+#### Task output processing (#6, #7, #8)
+- Structured output: `Task.new(output_schema:)` validates and coerces the agent's output against a JSON-schema subset, exposing the parsed object via `Task#structured_output` (and the raw string via `Task#raw_result`). JSON embedded in surrounding prose or a fenced code block is extracted automatically; output that doesn't conform re-runs the agent with the error fed back.
+- Guardrails: `Task.new(guardrail:)` takes a callable returning `[ok, value_or_error]` to validate and transform output before it flows downstream, retrying up to `guardrail_max_retries` (default 3) with the rejection reason fed back to the agent.
+- Output persistence & formatting: `Task.new(output_file:)` writes the result to disk (`create_directory:` controls parent-dir creation, default true), and `markdown: true` prepends a heading when the output isn't already a markdown document.
+- `RCrewAI::OutputSchema` — a small JSON-schema-subset validator/coercer used by structured task output.
+
+#### Per-agent LLM (#5)
+- `Agent.new(llm:)` accepts a provider symbol (`:anthropic`), an options hash (`{ provider:, model:, api_key:, temperature: }`), or a pre-built client instance. Agents in the same crew can use different providers/models (e.g. a cheap worker model and a stronger manager model). Omitting `llm:` keeps the previous global-configuration behavior.
+- `Configuration#with_overrides` returns a copy of the configuration with per-agent overrides applied, leaving global state untouched.
+
+#### Planning (#10)
+- `Crew.new(planning: true)` runs a single planner pass before execution that asks an LLM to draft a short plan for each task and folds it into the task's description. Optional `planning_llm:` selects the planner client (defaults to the global provider). Best-effort — a planner error or unparseable output leaves tasks unchanged and execution proceeds.
+- `Task#enrich_description` appends supplementary guidance (used by the planner) without discarding the original instructions.
+
+#### Training & testing (#12)
+- `Crew#train(n_iterations:, filename:)` runs the crew repeatedly, collects feedback after each iteration (via a `feedback:` callable, defaulting to a human prompt), and persists it as JSON.
+- `Crew#test(n_iterations:)` runs the crew repeatedly and reports per-run and average scores (via a `scorer:` callable, defaulting to the run's success rate).
+
+## [0.3.0] - 2026-05-12
+
+### Added
+- Native function calling across all five providers (OpenAI, Anthropic, Google, Azure, Ollama). Tools declare a JSON schema via the new DSL (`tool_name`, `description`, `param`) on `Tools::Base`.
+- Typed streaming event model (`RCrewAI::Events::*`) covering text deltas, tool-call lifecycle, usage, and errors. Pass `stream:` to `crew.execute` or `agent.execute_task`.
+- MCP (Model Context Protocol) client. Connect to stdio or HTTP MCP servers and expose their tools as ordinary RCrewAI tools (`RCrewAI::MCP::Client.with_connection`).
+- Per-model price table (`RCrewAI::Pricing`) and `cost_usd` on `Events::Usage` for cost tracking.
+- `Tools::Base#execute_with_validation` coerces and validates args against the DSL schema.
+- New `ToolRunner` (native function calling loop) and `LegacyReactRunner` (extracted `USE_TOOL[]` parsing loop).
+- `RCrewAI::SSEParser` — reusable Server-Sent Events parser used by all providers and MCP HTTP transport.
+
+### Changed
+- `Agent#execute_task` now delegates to `ToolRunner` (native function calling) or `LegacyReactRunner` (existing `USE_TOOL[]` parsing, used as fallback for legacy models or tools without a DSL declaration).
+- `Agent#execute_task` return value is now a hash including `:content`, `:tool_calls_history`, `:usage`, `:iterations`, `:finish_reason`. `task.result` continues to hold the string content.
+- `LLMClients::Base#chat` gains `tools:`, `tool_choice:`, and `stream:` keyword arguments.
+- Provider clients return symbolic `finish_reason` (`:stop`, `:tool_calls`, `:length`) and symbol-keyed `usage`.
+
+### Breaking
+- Subclasses of `LLMClients::Base` that override `chat` with an explicit kwarg list must add `tools: nil, stream: nil` to the signature (or accept `**options`).
+- Tools without DSL declarations now receive a permissive fallback schema and emit a one-time deprecation warning to stderr.
+
+### Migration
+- See `docs/upgrading-to-0.3.md` for step-by-step migration.
+
 ## [0.1.0] - 2025-01-12
 
 ### Added
@@ -104,5 +165,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - CLI usage documentation
 - Real-world use cases and examples
 
-[Unreleased]: https://github.com/gkosmo/rcrewAI/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/gkosmo/rcrewAI/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/gkosmo/rcrewAI/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/gkosmo/rcrewAI/compare/v0.1.0...v0.3.0
 [0.1.0]: https://github.com/gkosmo/rcrewAI/releases/tag/v0.1.0

data/README.md

@@ -19,6 +19,8 @@ RCrewAI is a Ruby implementation of the CrewAI framework, allowing you to create
 - **🏗️ Hierarchical Teams**: Manager agents that coordinate and delegate tasks to specialist agents
 - **🔒 Production Ready**: Security controls, error handling, logging, monitoring, and sandboxing
 - **🎯 Flexible Orchestration**: Sequential, hierarchical, and concurrent execution modes
+- **🌊 Flows**: Event-driven workflows with `start`/`listen`/`router`, branching, and persistent state
+- **📚 Knowledge (RAG)**: Ground agents in your own documents with built-in retrieval
 - **💎 Ruby-First Design**: Built specifically for Ruby developers with idiomatic patterns
 
 ## 📦 Installation
@@ -169,6 +171,172 @@ RCrewAI.configure do |config|
 end
 ```
 
+### Per-agent LLM
+
+The `RCrewAI.configure` block sets the crew-wide default. Any agent can override
+it with the `llm:` option, so a single crew can mix providers and models — for
+example a cheap model for workers and a stronger one for the manager:
+
+```ruby
+# Provider only (uses that provider's configured model + key)
+researcher = RCrewAI::Agent.new(name: 'researcher', role: '...', goal: '...',
+                                llm: :anthropic)
+
+# Provider + model (and optionally api_key / temperature)
+manager = RCrewAI::Agent.new(name: 'manager', role: '...', goal: '...',
+                             llm: { provider: :anthropic, model: 'claude-3-opus-20240229' })
+
+worker = RCrewAI::Agent.new(name: 'worker', role: '...', goal: '...',
+                            llm: { provider: :openai, model: 'gpt-4o-mini' })
+
+# Or pass a pre-built client instance
+worker = RCrewAI::Agent.new(name: 'worker', role: '...', goal: '...',
+                            llm: my_client)
+```
+
+Omit `llm:` to use the global `RCrewAI.configure` settings. Overrides never
+mutate the global configuration.
+
+## 📤 Structured Output, Guardrails & File Output
+
+Tasks can validate, transform, and persist their output:
+
+```ruby
+task = RCrewAI::Task.new(
+  name: 'extract',
+  description: 'Extract the article title and word count as JSON',
+  agent: analyst,
+
+  # Structured output — validated & coerced against a JSON schema.
+  # Non-conforming output re-runs the agent with the error fed back.
+  output_schema: {
+    type: 'object',
+    properties: { title: { type: 'string' }, words: { type: 'integer' } },
+    required: ['title']
+  },
+
+  # Guardrail — ->(output) { [ok, value_or_error] }. On rejection the agent
+  # re-runs (up to guardrail_max_retries) with the reason appended.
+  guardrail: ->(out) { [out.length < 5000, 'must be under 5000 chars'] },
+  guardrail_max_retries: 3,
+
+  # Persist the result. Parent dirs are created unless create_directory: false.
+  output_file: 'out/report.md',
+  markdown: true
+)
+
+task.execute
+task.structured_output  # => { "title" => "...", "words" => 1234 }
+task.raw_result         # => the unprocessed string the agent produced
+```
+
+## 🗺️ Planning
+
+Enable `planning:` on a crew to run a planner pass before execution. The planner
+drafts a short plan for each task and folds it into the task description, giving
+the executing agent a head start:
+
+```ruby
+crew = RCrewAI::Crew.new('research_crew', planning: true)
+# Optionally use a dedicated (e.g. stronger) planner model:
+crew = RCrewAI::Crew.new('research_crew', planning: true,
+                         planning_llm: { provider: :anthropic, model: 'claude-3-opus-20240229' })
+```
+
+Planning is best-effort: if the planner errors or returns unparseable output,
+the crew runs with the original tasks unchanged.
+
+## 🏋️ Training & Testing
+
+Iterate on a crew by training it with feedback or scoring repeated runs:
+
+```ruby
+# Train: run N times, collect feedback after each run, persist to JSON.
+crew.train(n_iterations: 3, filename: 'training.json')
+
+# Provide feedback programmatically instead of prompting a human:
+crew.train(n_iterations: 3, filename: 'training.json',
+           feedback: ->(iteration, result) { "run #{iteration}: #{result[:success_rate]}%" })
+
+# Test: run N times and score each run (defaults to success_rate).
+crew.test(n_iterations: 5)
+# => { iterations: 5, scores: [...], average_score: 92.0 }
+```
+
+## 📚 Knowledge (RAG)
+
+Ground agents in your own documents. Sources are chunked, embedded, and stored
+in an in-memory vector store; the most relevant chunks are injected into each
+task's prompt automatically.
+
+```ruby
+kb = RCrewAI::Knowledge::Base.new(sources: [
+  RCrewAI::Knowledge::StringSource.new('Our refund window is 30 days.'),
+  RCrewAI::Knowledge::FileSource.new('docs/policy.txt'),
+  RCrewAI::Knowledge::PdfSource.new('handbook.pdf'),
+  RCrewAI::Knowledge::UrlSource.new('https://example.com/faq')
+])
+
+# Agent-level (role-specific) knowledge:
+support = RCrewAI::Agent.new(name: 'support', role: '...', goal: '...', knowledge: kb)
+
+# Or pass raw sources and let the agent build the base:
+support = RCrewAI::Agent.new(name: 'support', role: '...', goal: '...',
+                             knowledge_sources: [RCrewAI::Knowledge::StringSource.new('...')])
+
+# Crew-level knowledge is shared with every agent:
+crew = RCrewAI::Crew.new('support_crew', knowledge: kb)
+```
+
+Embeddings default to OpenAI's `text-embedding-3-small`; pass a custom
+`embedder:` (anything responding to `embed(texts)`) or vector store to swap the
+backend.
+
+## 🌊 Flows
+
+Beyond crews, RCrewAI has **Flows** — an event-driven workflow engine for
+orchestrating steps (and whole crews) with explicit branching and state:
+
+```ruby
+class ArticleFlow < RCrewAI::Flow
+  start :outline
+  def outline
+    state.sections = %w[intro body conclusion]
+    state.sections.length
+  end
+
+  listen :outline
+  def draft(section_count)
+    state.words = section_count * 100
+    state.words
+  end
+
+  router :draft
+  def review(words)
+    words >= 250 ? :publish : :expand
+  end
+
+  listen :publish
+  def publish = state.status = 'published'
+
+  listen :expand
+  def expand = state.status = 'needs more work'
+end
+
+flow = ArticleFlow.new
+flow.kickoff(inputs: { author: 'me' })
+flow.state.status      # => "published"
+flow.state.id          # => automatic UUID
+```
+
+- `start` / `listen` / `router` wire methods into a graph; a listener receives
+  its trigger's return value.
+- Combine triggers with `and_(:a, :b)` (all) and `or_(:a, :b)` (any).
+- **State** is a schemaless object with a UUID, seedable via `kickoff(inputs:)`.
+- **Persistence**: pass `state_store:` (`RCrewAI::Flow::FileStateStore.new(dir)`
+  or your own `#save`/`#load`) and call `flow.restore(id)` to resume.
+- Invoke a `Crew` inside any step, or pause with `human_feedback('Approve?')`.
+
 ## 💡 Examples
 
 ### Hierarchical Team with Human Oversight
@@ -303,7 +471,7 @@ RCrewAI provides a flexible, production-ready architecture:
 
 ### rcrew RAILS
 
-For Rails applications, use the **rcrew RAILS** gem (`rcrewai-rails`) which provides:
+For Rails applications, use the **rcrew RAILS** gem (`rcrewai-rails`) [(repo here)](https://github.com/gkosmo/rcrewai-rails) which provides:
 
 - **🏗️ Rails Engine**: Mountable engine with web UI for managing crews
 - **💾 ActiveRecord Integration**: Database persistence for agents, tasks, and executions
@@ -357,4 +525,4 @@ RCrewAI is released under the [MIT License](LICENSE).
 
 ---
 
-Made with ❤️ by the RCrewAI community
+Made with ❤️ by the RCrewAI community

data/ROADMAP.md

@@ -0,0 +1,84 @@
+# RCrewAI Roadmap
+
+This roadmap tracks feature parity between **RCrewAI** (Ruby) and the upstream
+[**crewai**](https://pypi.org/project/crewai/) Python framework.
+
+## Current status
+
+- **RCrewAI:** `0.3.0` (2026-05-12)
+- **Upstream crewai:** `1.15.x` (mid-2026)
+
+RCrewAI is a faithful port of CrewAI's **"Crews"** mental model (Agents / Tasks /
+Crew, sequential + hierarchical processes, tools, memory, human-in-the-loop). As
+of `0.3.0` the LLM plumbing is modern: native function calling across all five
+providers, a tool-schema DSL, typed streaming events, MCP client, and per-model
+pricing.
+
+Since CrewAI's `1.0`, the framework grew a second pillar (**Flows**) plus
+**Knowledge (RAG)**, **Guardrails**, **structured output**, **Planning**, and
+**Training/Testing**. As of the `[Unreleased]` changes, RCrewAI now implements
+all of these — see the matrix below. Only backlog polish items remain.
+
+**Status: all milestone issues (#5–#12) are complete.** The remaining backlog
+covers smaller polish items (reasoning, rate-limiting, batch kickoff, kickoff
+hooks, multimodal).
+
+## Parity matrix
+
+| Concept | crewai | RCrewAI 0.3.0 | Target |
+|---|---|---|---|
+| Agents / Tasks / Crew | ✅ | ✅ | — |
+| Sequential / hierarchical process | ✅ | ✅ | — |
+| Native function calling + tool DSL | ✅ | ✅ (0.3.0) | — |
+| Streaming events | ✅ | ✅ (0.3.0) | — |
+| MCP client | ✅ | ✅ (0.3.0) | — |
+| Per-model pricing / cost | ✅ | ✅ (0.3.0) | — |
+| Per-agent LLM override | ✅ | ✅ (#5) | ✅ done |
+| Structured output (schema) | ✅ | ✅ (#6) | ✅ done |
+| Task guardrails | ✅ | ✅ (#7) | ✅ done |
+| `output_file` / markdown | ✅ | ✅ (#8) | ✅ done |
+| Knowledge / RAG | ✅ | ✅ (#9) | ✅ done |
+| Planning | ✅ | ✅ (#10) | ✅ done |
+| Flows (`start`/`listen`/`router`) | ✅ | ✅ (#11) | ✅ done |
+| Flow state + persistence | ✅ | ✅ (#11) | ✅ done |
+| Training / Testing | ✅ | ✅ (#12) | ✅ done |
+| Reasoning, rate-limiting, batch kickoff | ✅ | ❌ | backlog |
+
+## Milestones (highest leverage first)
+
+### 0.3.1 — Per-agent LLM override
+Let `Agent.new(llm:)` accept a provider/model, instead of only the global
+`RCrewAI.configure`. Unblocks mixed-model crews (cheap model for workers, strong
+model for the manager).
+
+### 0.4.0 — Structured output & guardrails
+Builds directly on the 0.3.0 tool-schema/JSON-schema plumbing.
+- `Task.new(output_schema:)` → validated, coerced structured result.
+- `Task.new(guardrail:)` → proc/object that validates & transforms output, with
+  bounded retries (`guardrail_max_retries`).
+- `output_file:` + `markdown:` output formatting.
+
+### 0.5.0 — Knowledge (RAG) & Planning
+- Knowledge sources: string, `.txt`, PDF (have `pdf-reader`), CSV, JSON, URL
+  (have `nokogiri`). Embeddings client + a pluggable vector store (start with an
+  in-memory / SQLite cosine store; no hard Chroma dependency).
+- Attach at agent **and** crew level.
+- `Crew.new(planning: true)` → a planner pass that drafts a step plan before
+  execution.
+
+### 0.6.0 — Flows
+The flagship. A Ruby DSL mirroring CrewAI Flows:
+- `start`, `listen`, `router` decorators/class-methods.
+- `and_` / `or_` trigger combinators.
+- Structured flow **state** (a plain struct/`Data` or dry-struct) with a UUID.
+- `@persist`-equivalent state persistence across restarts.
+- `human_feedback` pause/resume point.
+
+### 0.7.0 — Training & Testing
+- `crew.train(n_iterations:, filename:)` capturing human feedback.
+- `crew.test(n_iterations:, model:)` scoring runs.
+
+### Backlog
+Per-agent reasoning (`reasoning:`, `max_reasoning_attempts:`), `max_rpm`
+rate-limiting, `respect_context_window`, `kickoff_for_each` batch execution,
+`before_kickoff` / `after_kickoff` hooks, multimodal agents.

data/Rakefile

@@ -1,130 +1,130 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "rubocop/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 # Default task
-task default: [:spec, :rubocop]
+task default: %i[spec rubocop]
 
 # RSpec task
 RSpec::Core::RakeTask.new(:spec) do |task|
-  task.rspec_opts = "--color --format documentation"
+  task.rspec_opts = '--color --format documentation'
 end
 
 # RuboCop task
 RuboCop::RakeTask.new do |task|
-  task.options = ["--display-cop-names", "--display-style-guide"]
+  task.options = ['--display-cop-names', '--display-style-guide']
 end
 
 # Test with coverage
-desc "Run specs with coverage report"
+desc 'Run specs with coverage report'
 task :spec_coverage do
   ENV['COVERAGE'] = 'true'
   Rake::Task[:spec].invoke
 end
 
 # Clean coverage files
-desc "Clean coverage files"
+desc 'Clean coverage files'
 task :clean_coverage do
-  FileUtils.rm_rf("coverage/")
+  FileUtils.rm_rf('coverage/')
 end
 
 # Build and install gem locally
-desc "Build and install gem locally"
+desc 'Build and install gem locally'
 task :install_local do
-  sh "gem build rcrewai.gemspec"
-  sh "gem install rcrewai-*.gem"
-  FileUtils.rm(Dir.glob("rcrewai-*.gem"))
+  sh 'gem build rcrewai.gemspec'
+  sh 'gem install rcrewai-*.gem'
+  FileUtils.rm(Dir.glob('rcrewai-*.gem'))
 end
 
 # Run all tests and checks
-desc "Run all tests and code quality checks"
+desc 'Run all tests and code quality checks'
 task :ci do
-  puts "Running RSpec tests..."
+  puts 'Running RSpec tests...'
   Rake::Task[:spec].invoke
-  
+
   puts "\nRunning RuboCop..."
   Rake::Task[:rubocop].invoke
-  
+
   puts "\nAll checks passed! ✅"
 end
 
 # Console task for development
-desc "Start interactive console with gem loaded"
+desc 'Start interactive console with gem loaded'
 task :console do
-  require "irb"
-  require_relative "lib/rcrewai"
+  require 'irb'
+  require_relative 'lib/rcrewai'
   IRB.start
 end
 
 # Generate documentation
-desc "Generate documentation"
+desc 'Generate documentation'
 task :docs do
-  sh "yard doc lib/**/*.rb"
-  puts "Documentation generated in doc/ directory"
+  sh 'yard doc lib/**/*.rb'
+  puts 'Documentation generated in doc/ directory'
 end
 
 # Benchmark task
-desc "Run performance benchmarks"
+desc 'Run performance benchmarks'
 task :benchmark do
-  require_relative "lib/rcrewai"
-  
+  require_relative 'lib/rcrewai'
+
   # Simple benchmark example
-  require "benchmark"
-  
+  require 'benchmark'
+
   RCrewAI.configure do |config|
     config.llm_provider = :openai
-    config.api_key = "test-key"
+    config.api_key = 'test-key'
   end
-  
+
   agent = RCrewAI::Agent.new(
-    name: "benchmark_agent",
-    role: "Test Agent",
-    goal: "Run benchmarks"
+    name: 'benchmark_agent',
+    role: 'Test Agent',
+    goal: 'Run benchmarks'
   )
-  
+
   task = RCrewAI::Task.new(
-    name: "benchmark_task",
-    description: "Test task",
+    name: 'benchmark_task',
+    description: 'Test task',
     agent: agent
   )
-  
-  crew = RCrewAI::Crew.new("benchmark_crew")
+
+  crew = RCrewAI::Crew.new('benchmark_crew')
   crew.add_agent(agent)
   crew.add_task(task)
-  
+
   puts "\nBenchmarking crew creation and setup..."
   result = Benchmark.measure do
     100.times do
       test_crew = RCrewAI::Crew.new("test_#{rand(1000)}")
       test_agent = RCrewAI::Agent.new(
-        name: "test_agent",
-        role: "Test Agent",
-        goal: "Test performance"
+        name: 'test_agent',
+        role: 'Test Agent',
+        goal: 'Test performance'
       )
       test_crew.add_agent(test_agent)
     end
   end
-  
+
   puts "Created 100 crews with agents in: #{result.real.round(4)}s"
 end
 
 # Development setup
-desc "Set up development environment"
+desc 'Set up development environment'
 task :setup do
-  puts "Setting up development environment..."
-  
+  puts 'Setting up development environment...'
+
   # Install dependencies
-  sh "bundle install"
-  
+  sh 'bundle install'
+
   # Create necessary directories
-  FileUtils.mkdir_p("spec/vcr_cassettes") unless Dir.exist?("spec/vcr_cassettes")
-  FileUtils.mkdir_p("coverage") unless Dir.exist?("coverage")
-  FileUtils.mkdir_p("doc") unless Dir.exist?("doc")
-  
+  FileUtils.mkdir_p('spec/vcr_cassettes') unless Dir.exist?('spec/vcr_cassettes')
+  FileUtils.mkdir_p('coverage') unless Dir.exist?('coverage')
+  FileUtils.mkdir_p('doc') unless Dir.exist?('doc')
+
   puts "\n✅ Development environment set up successfully!"
   puts "\nRun 'rake spec' to run tests"
   puts "Run 'rake console' to start an interactive session"
   puts "Run 'rake ci' to run all checks"
-end
+end