cover/Elixir.LabsJidoAgent.Application.html| 1 | ++ | defmodule LabsJidoAgent.Application do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Application for Jido Agent labs demonstrating AI agent patterns in Elixir. |
+
| 4 | ++ | """ |
+
| 5 | ++ | |
+
| 6 | ++ | use Application |
+
| 7 | ++ | |
+
| 8 | ++ | @impl true |
+
| 9 | ++ | def start(_type, _args) do |
+
| 10 | +:-( |
+ children = [ |
+
| 11 | ++ | # Agent registry for dynamic agent management |
+
| 12 | ++ | {Registry, keys: :unique, name: LabsJidoAgent.Registry} |
+
| 13 | ++ | ] |
+
| 14 | ++ | |
+
| 15 | +:-( |
+ opts = [strategy: :one_for_one, name: LabsJidoAgent.Supervisor] |
+
| 16 | +:-( |
+ Supervisor.start_link(children, opts) |
+
| 17 | ++ | end |
+
| 18 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.CodeReviewAction.html| 1 | ++ | defmodule LabsJidoAgent.CodeReviewAction do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | A Jido Action that reviews Elixir code using LLM-powered analysis. |
+
| 4 | ++ | |
+
| 5 | ++ | This action demonstrates: |
+
| 6 | ++ | - Using Jido.Action behavior |
+
| 7 | ++ | - LLM integration via Instructor |
+
| 8 | ++ | - Structured parameter validation |
+
| 9 | ++ | - Educational feedback generation |
+
| 10 | ++ | |
+
| 11 | ++ | ## LLM vs Simulated Mode |
+
| 12 | ++ | |
+
| 13 | ++ | By default, uses real LLM if configured (via OPENAI_API_KEY, etc). |
+
| 14 | ++ | Falls back to simulated pattern-based analysis if LLM unavailable. |
+
| 15 | ++ | |
+
| 16 | ++ | ## Examples |
+
| 17 | ++ | |
+
| 18 | ++ | # With LLM configured |
+
| 19 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAction.review(code, phase: 1) |
+
| 20 | ++ | |
+
| 21 | ++ | # Force simulated mode |
+
| 22 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAction.review(code, |
+
| 23 | ++ | phase: 1, use_llm: false) |
+
| 24 | ++ | """ |
+
| 25 | ++ | |
+
| 26 | ++ | use Jido.Action, |
+
| 27 | ++ | name: "code_review", |
+
| 28 | ++ | description: "Reviews Elixir code for quality, idioms, and best practices", |
+
| 29 | ++ | category: "education", |
+
| 30 | ++ | tags: ["code-review", "elixir", "education", "llm"], |
+
| 31 | ++ | schema: [ |
+
| 32 | ++ | code: [type: :string, required: true, doc: "The Elixir code to review"], |
+
| 33 | ++ | phase: [type: :integer, default: 1, doc: "Learning phase (1-15)"], |
+
| 34 | ++ | focus: [ |
+
| 35 | ++ | type: {:in, [:quality, :performance, :idioms, :all]}, |
+
| 36 | ++ | default: :all, |
+
| 37 | ++ | doc: "Review focus area" |
+
| 38 | ++ | ], |
+
| 39 | ++ | use_llm: [type: :boolean, default: true, doc: "Use LLM if available"] |
+
| 40 | ++ | ] |
+
| 41 | ++ | |
+
| 42 | ++ | alias LabsJidoAgent.{LLM, Schemas} |
+
| 43 | ++ | |
+
| 44 | ++ | @impl true |
+
| 45 | ++ | def run(params, _context) do |
+
| 46 | +12 | + code = params.code |
+
| 47 | +12 | + phase = params.phase |
+
| 48 | +12 | + focus = params.focus |
+
| 49 | +12 | + use_llm = params.use_llm |
+
| 50 | ++ | |
+
| 51 | +12 | + if use_llm and LLM.available?() do |
+
| 52 | +4 | + llm_review(code, phase, focus) |
+
| 53 | ++ | else |
+
| 54 | +8 | + simulated_review(code, phase, focus) |
+
| 55 | ++ | end |
+
| 56 | ++ | end |
+
| 57 | ++ | |
+
| 58 | ++ | # LLM-powered review |
+
| 59 | ++ | defp llm_review(code, phase, focus) do |
+
| 60 | +4 | + prompt = build_review_prompt(code, phase, focus) |
+
| 61 | ++ | |
+
| 62 | +4 | + case LLM.chat_structured(prompt, |
+
| 63 | ++ | response_model: Schemas.CodeReviewResponse, |
+
| 64 | ++ | model: :smart, |
+
| 65 | ++ | temperature: 0.3 |
+
| 66 | ++ | ) do |
+
| 67 | ++ | {:ok, %Schemas.CodeReviewResponse{} = review} -> |
+
| 68 | ++ | # Convert Ecto schema to plain map (issues are already maps now) |
+
| 69 | +:-( |
+ feedback = %{ |
+
| 70 | +:-( |
+ score: review.score, |
+
| 71 | +:-( |
+ issues: review.issues || [], |
+
| 72 | +:-( |
+ suggestions: format_suggestions(review.suggestions, review.issues), |
+
| 73 | ++ | aspects_reviewed: get_review_aspects(phase, focus), |
+
| 74 | ++ | phase: phase, |
+
| 75 | ++ | llm_powered: true |
+
| 76 | ++ | } |
+
| 77 | ++ | |
+
| 78 | ++ | {:ok, feedback} |
+
| 79 | ++ | |
+
| 80 | ++ | {:error, reason} -> |
+
| 81 | ++ | # Fall back to simulated on LLM error |
+
| 82 | +4 | + IO.warn("LLM review failed: #{inspect(reason)}, falling back to simulated") |
+
| 83 | +4 | + simulated_review(code, phase, focus) |
+
| 84 | ++ | end |
+
| 85 | ++ | end |
+
| 86 | ++ | |
+
| 87 | ++ | defp build_review_prompt(code, phase, focus) do |
+
| 88 | +4 | + aspects = get_review_aspects(phase, focus) |
+
| 89 | +4 | + aspects_text = Enum.join(aspects, ", ") |
+
| 90 | ++ | |
+
| 91 | +4 | + """ |
+
| 92 | ++ | You are an expert Elixir code reviewer for educational purposes. |
+
| 93 | ++ | |
+
| 94 | +4 | + Review the following Elixir code for a student in Phase #{phase} of learning. |
+
| 95 | ++ | |
+
| 96 | +4 | + Focus areas: #{aspects_text} |
+
| 97 | ++ | |
+
| 98 | ++ | Code to review: |
+
| 99 | ++ | ```elixir |
+
| 100 | +4 | + #{code} |
+
| 101 | ++ | ``` |
+
| 102 | ++ | |
+
| 103 | ++ | Provide: |
+
| 104 | ++ | 1. A score (0-100) based on code quality |
+
| 105 | ++ | 2. A brief summary of overall quality |
+
| 106 | ++ | 3. Specific issues found (type, severity, line number if identifiable, message, suggestion) |
+
| 107 | ++ | 4. General suggestions for improvement |
+
| 108 | ++ | 5. Learning resources relevant to the issues |
+
| 109 | ++ | |
+
| 110 | ++ | Be constructive and educational. Prioritize teaching over criticism. |
+
| 111 | +4 | + For Phase #{phase}, focus on concepts appropriate for that level. |
+
| 112 | ++ | """ |
+
| 113 | ++ | end |
+
| 114 | ++ | |
+
| 115 | ++ | defp format_suggestions(general_suggestions, issues) do |
+
| 116 | +:-( |
+ issue_suggestions = |
+
| 117 | +:-( |
+ Enum.map(issues || [], fn issue -> |
+
| 118 | ++ | # Handle both map (from LLM) and struct (not used anymore) formats |
+
| 119 | +:-( |
+ type = if is_map(issue), do: Map.get(issue, "type") || Map.get(issue, :type), else: issue.type |
+
| 120 | +:-( |
+ message = if is_map(issue), do: Map.get(issue, "message") || Map.get(issue, :message), else: issue.message |
+
| 121 | +:-( |
+ suggestion = if is_map(issue), do: Map.get(issue, "suggestion") || Map.get(issue, :suggestion), else: issue.suggestion |
+
| 122 | ++ | |
+
| 123 | +:-( |
+ %{ |
+
| 124 | ++ | original_issue: message, |
+
| 125 | ++ | suggestion: suggestion, |
+
| 126 | ++ | resources: get_resources_for_type(type) |
+
| 127 | ++ | } |
+
| 128 | ++ | end) |
+
| 129 | ++ | |
+
| 130 | ++ | # Add general suggestions |
+
| 131 | +:-( |
+ general = |
+
| 132 | +:-( |
+ Enum.map(general_suggestions || [], fn sug -> |
+
| 133 | +:-( |
+ %{ |
+
| 134 | ++ | original_issue: "General improvement", |
+
| 135 | ++ | suggestion: sug, |
+
| 136 | ++ | resources: [] |
+
| 137 | ++ | } |
+
| 138 | ++ | end) |
+
| 139 | ++ | |
+
| 140 | +:-( |
+ issue_suggestions ++ general |
+
| 141 | ++ | end |
+
| 142 | ++ | |
+
| 143 | ++ | # Simulated review (fallback when no LLM) |
+
| 144 | ++ | defp simulated_review(code, phase, focus) do |
+
| 145 | +12 | + review_aspects = get_review_aspects(phase, focus) |
+
| 146 | +12 | + issues = analyze_code_structure(code, review_aspects) |
+
| 147 | +12 | + suggestions = generate_suggestions(issues, phase) |
+
| 148 | +12 | + score = calculate_score(issues) |
+
| 149 | ++ | |
+
| 150 | +12 | + feedback = %{ |
+
| 151 | ++ | score: score, |
+
| 152 | ++ | issues: issues, |
+
| 153 | ++ | suggestions: suggestions, |
+
| 154 | ++ | aspects_reviewed: review_aspects, |
+
| 155 | ++ | phase: phase, |
+
| 156 | ++ | llm_powered: false |
+
| 157 | ++ | } |
+
| 158 | ++ | |
+
| 159 | ++ | {:ok, feedback} |
+
| 160 | ++ | end |
+
| 161 | ++ | |
+
| 162 | ++ | # Review aspects based on phase |
+
| 163 | ++ | defp get_review_aspects(phase, focus) when focus == :all do |
+
| 164 | +13 | + base_aspects = [:pattern_matching, :function_heads, :documentation] |
+
| 165 | ++ | |
+
| 166 | +13 | + phase_aspects = |
+
| 167 | ++ | case phase do |
+
| 168 | +11 | + 1 -> [:recursion, :tail_optimization, :enum_vs_stream] |
+
| 169 | +:-( |
+ 2 -> [:process_design, :message_passing] |
+
| 170 | +:-( |
+ 3 -> [:genserver_patterns, :supervision] |
+
| 171 | +:-( |
+ 4 -> [:naming, :registry_usage] |
+
| 172 | +1 | + 5 -> [:ecto_schemas, :changesets, :transactions] |
+
| 173 | +1 | + _ -> [] |
+
| 174 | ++ | end |
+
| 175 | ++ | |
+
| 176 | +13 | + base_aspects ++ phase_aspects |
+
| 177 | ++ | end |
+
| 178 | ++ | |
+
| 179 | +3 | + defp get_review_aspects(_phase, focus), do: [focus] |
+
| 180 | ++ | |
+
| 181 | ++ | # Simulated code analysis |
+
| 182 | ++ | defp analyze_code_structure(code, aspects) do |
+
| 183 | +12 | + issues = [] |
+
| 184 | ++ | |
+
| 185 | ++ | # Check for non-tail recursion |
+
| 186 | +12 | + issues = |
+
| 187 | +12 | + if :recursion in aspects and String.contains?(code, "+ sum(") do |
+
| 188 | ++ | [ |
+
| 189 | ++ | %{ |
+
| 190 | ++ | type: :performance, |
+
| 191 | ++ | severity: :medium, |
+
| 192 | ++ | line: find_line(code, "+ sum("), |
+
| 193 | ++ | message: "Non-tail-recursive function detected", |
+
| 194 | ++ | suggestion: "Consider using an accumulator for tail-call optimization" |
+
| 195 | ++ | } |
+
| 196 | ++ | | issues |
+
| 197 | ++ | ] |
+
| 198 | ++ | else |
+
| 199 | +11 | + issues |
+
| 200 | ++ | end |
+
| 201 | ++ | |
+
| 202 | ++ | # Check for missing documentation |
+
| 203 | +12 | + issues = |
+
| 204 | +12 | + if :documentation in aspects and not String.contains?(code, "@doc") do |
+
| 205 | ++ | [ |
+
| 206 | ++ | %{ |
+
| 207 | ++ | type: :quality, |
+
| 208 | ++ | severity: :low, |
+
| 209 | ++ | line: 1, |
+
| 210 | ++ | message: "Missing module or function documentation", |
+
| 211 | ++ | suggestion: "Add @moduledoc and @doc attributes" |
+
| 212 | ++ | } |
+
| 213 | ++ | | issues |
+
| 214 | ++ | ] |
+
| 215 | ++ | else |
+
| 216 | +4 | + issues |
+
| 217 | ++ | end |
+
| 218 | ++ | |
+
| 219 | ++ | # Check pattern matching usage |
+
| 220 | +12 | + issues = |
+
| 221 | +12 | + if :pattern_matching in aspects and String.contains?(code, "if ") do |
+
| 222 | ++ | [ |
+
| 223 | ++ | %{ |
+
| 224 | ++ | type: :idioms, |
+
| 225 | ++ | severity: :low, |
+
| 226 | ++ | line: find_line(code, "if "), |
+
| 227 | ++ | message: "Consider using pattern matching instead of if/else", |
+
| 228 | ++ | suggestion: "Elixir idioms favor pattern matching in function heads" |
+
| 229 | ++ | } |
+
| 230 | ++ | | issues |
+
| 231 | ++ | ] |
+
| 232 | ++ | else |
+
| 233 | +12 | + issues |
+
| 234 | ++ | end |
+
| 235 | ++ | |
+
| 236 | +12 | + issues |
+
| 237 | ++ | end |
+
| 238 | ++ | |
+
| 239 | ++ | defp find_line(code, pattern) do |
+
| 240 | ++ | code |
+
| 241 | ++ | |> String.split("\n") |
+
| 242 | +3 | + |> Enum.find_index(&String.contains?(&1, pattern)) |
+
| 243 | +1 | + |> case do |
+
| 244 | +:-( |
+ nil -> nil |
+
| 245 | +1 | + idx -> idx + 1 |
+
| 246 | ++ | end |
+
| 247 | ++ | end |
+
| 248 | ++ | |
+
| 249 | ++ | defp generate_suggestions(issues, _phase) do |
+
| 250 | +12 | + Enum.map(issues, fn issue -> |
+
| 251 | +9 | + %{ |
+
| 252 | +9 | + original_issue: issue.message, |
+
| 253 | +9 | + suggestion: issue.suggestion, |
+
| 254 | +9 | + resources: get_resources_for_type(issue.type) |
+
| 255 | ++ | } |
+
| 256 | ++ | end) |
+
| 257 | ++ | end |
+
| 258 | ++ | |
+
| 259 | +1 | + defp get_resources_for_type(:performance) do |
+
| 260 | ++ | [ |
+
| 261 | ++ | "Elixir docs: Recursion and tail-call optimization", |
+
| 262 | ++ | "Livebook: phase-01-core/02-recursion.livemd" |
+
| 263 | ++ | ] |
+
| 264 | ++ | end |
+
| 265 | ++ | |
+
| 266 | +8 | + defp get_resources_for_type(:quality) do |
+
| 267 | ++ | [ |
+
| 268 | ++ | "Elixir docs: Writing documentation", |
+
| 269 | ++ | "ExDoc documentation" |
+
| 270 | ++ | ] |
+
| 271 | ++ | end |
+
| 272 | ++ | |
+
| 273 | +:-( |
+ defp get_resources_for_type(:idioms) do |
+
| 274 | ++ | [ |
+
| 275 | ++ | "Elixir Style Guide", |
+
| 276 | ++ | "Livebook: phase-01-core/01-pattern-matching.livemd" |
+
| 277 | ++ | ] |
+
| 278 | ++ | end |
+
| 279 | ++ | |
+
| 280 | +:-( |
+ defp get_resources_for_type(_), do: [] |
+
| 281 | ++ | |
+
| 282 | ++ | defp calculate_score(issues) do |
+
| 283 | +12 | + base_score = 100 |
+
| 284 | ++ | |
+
| 285 | +12 | + deductions = |
+
| 286 | ++ | Enum.reduce(issues, 0, fn issue, acc -> |
+
| 287 | +9 | + case issue.severity do |
+
| 288 | +:-( |
+ :critical -> acc + 20 |
+
| 289 | +:-( |
+ :high -> acc + 10 |
+
| 290 | +1 | + :medium -> acc + 5 |
+
| 291 | +8 | + :low -> acc + 2 |
+
| 292 | ++ | end |
+
| 293 | ++ | end) |
+
| 294 | ++ | |
+
| 295 | +12 | + max(0, base_score - deductions) |
+
| 296 | ++ | end |
+
| 297 | ++ | |
+
| 298 | ++ | ## Public Helper API |
+
| 299 | ++ | |
+
| 300 | ++ | @doc """ |
+
| 301 | ++ | Reviews code and provides feedback (convenience wrapper). |
+
| 302 | ++ | |
+
| 303 | ++ | ## Options |
+
| 304 | ++ | * `:phase` - Learning phase (1-15), default: 1 |
+
| 305 | ++ | * `:focus` - Review focus (`:quality`, `:performance`, `:idioms`, `:all`), default: `:all` |
+
| 306 | ++ | * `:use_llm` - Use LLM if available, default: true |
+
| 307 | ++ | |
+
| 308 | ++ | ## Examples |
+
| 309 | ++ | |
+
| 310 | ++ | code = "defmodule Example do\\n def hello, do: :world\\nend" |
+
| 311 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAction.review(code, phase: 1) |
+
| 312 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAction.review(code, phase: 1, use_llm: false) |
+
| 313 | ++ | """ |
+
| 314 | +:-( |
+ def review(code, opts \\ []) do |
+
| 315 | +:-( |
+ params = %{ |
+
| 316 | ++ | code: code, |
+
| 317 | ++ | phase: Keyword.get(opts, :phase, 1), |
+
| 318 | ++ | focus: Keyword.get(opts, :focus, :all), |
+
| 319 | ++ | use_llm: Keyword.get(opts, :use_llm, true) |
+
| 320 | ++ | } |
+
| 321 | ++ | |
+
| 322 | +:-( |
+ run(params, %{}) |
+
| 323 | ++ | end |
+
| 324 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.CodeReviewAgent.html| 1 | ++ | defmodule LabsJidoAgent.CodeReviewAgent do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | An Agent that reviews Elixir code using the CodeReviewAction. |
+
| 4 | ++ | |
+
| 5 | ++ | This demonstrates the Jido Agent + Action pattern for educational AI assistance. |
+
| 6 | ++ | |
+
| 7 | ++ | ## Examples |
+
| 8 | ++ | |
+
| 9 | ++ | # Create agent and review code |
+
| 10 | ++ | {:ok, agent} = LabsJidoAgent.CodeReviewAgent.new() |
+
| 11 | ++ | {:ok, agent} = LabsJidoAgent.CodeReviewAgent.set(agent, |
+
| 12 | ++ | code: code_string, |
+
| 13 | ++ | phase: 1, |
+
| 14 | ++ | focus: :all |
+
| 15 | ++ | ) |
+
| 16 | ++ | {:ok, agent} = LabsJidoAgent.CodeReviewAgent.plan(agent, LabsJidoAgent.CodeReviewAction) |
+
| 17 | ++ | {:ok, agent} = LabsJidoAgent.CodeReviewAgent.run(agent) |
+
| 18 | ++ | |
+
| 19 | ++ | feedback = agent.result |
+
| 20 | ++ | IO.inspect(feedback.issues) |
+
| 21 | ++ | |
+
| 22 | ++ | # Or use the convenient helper |
+
| 23 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAgent.review(code, phase: 1) |
+
| 24 | ++ | """ |
+
| 25 | ++ | |
+
| 26 | +:-( |
+ use Jido.Agent, |
+
| 27 | ++ | name: "code_review_agent", |
+
| 28 | ++ | description: "Reviews Elixir code for quality, idioms, and best practices", |
+
| 29 | ++ | category: "education", |
+
| 30 | ++ | tags: ["code-review", "elixir"], |
+
| 31 | ++ | schema: [ |
+
| 32 | ++ | code: [type: :string, doc: "The Elixir code to review"], |
+
| 33 | ++ | phase: [type: :integer, default: 1, doc: "Learning phase (1-15)"], |
+
| 34 | ++ | focus: [ |
+
| 35 | ++ | type: {:in, [:quality, :performance, :idioms, :all]}, |
+
| 36 | ++ | default: :all, |
+
| 37 | ++ | doc: "Review focus area" |
+
| 38 | ++ | ] |
+
| 39 | ++ | ], |
+
| 40 | ++ | actions: [LabsJidoAgent.CodeReviewAction] |
+
| 41 | ++ | |
+
| 42 | ++ | @doc """ |
+
| 43 | ++ | Convenience function to review code without manually managing agent lifecycle. |
+
| 44 | ++ | |
+
| 45 | ++ | ## Options |
+
| 46 | ++ | * `:phase` - Learning phase (1-15), default: 1 |
+
| 47 | ++ | * `:focus` - Review focus (`:quality`, `:performance`, `:idioms`, `:all`), default: `:all` |
+
| 48 | ++ | |
+
| 49 | ++ | ## Examples |
+
| 50 | ++ | |
+
| 51 | ++ | code = ''' |
+
| 52 | ++ | defmodule MyList do |
+
| 53 | ++ | def sum([]), do: 0 |
+
| 54 | ++ | def sum([h | t]), do: h + sum(t) |
+
| 55 | ++ | end |
+
| 56 | ++ | ''' |
+
| 57 | ++ | |
+
| 58 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAgent.review(code, phase: 1) |
+
| 59 | ++ | IO.inspect(feedback.issues) |
+
| 60 | ++ | """ |
+
| 61 | +:-( |
+ def review(code, opts \\ []) do |
+
| 62 | +4 | + phase = Keyword.get(opts, :phase, 1) |
+
| 63 | +4 | + focus = Keyword.get(opts, :focus, :all) |
+
| 64 | +4 | + use_llm = Keyword.get(opts, :use_llm, true) |
+
| 65 | ++ | |
+
| 66 | ++ | # Build params and call action directly for convenience |
+
| 67 | +4 | + params = %{code: code, phase: phase, focus: focus, use_llm: use_llm} |
+
| 68 | +4 | + LabsJidoAgent.CodeReviewAction.run(params, %{}) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.LLM.html| 1 | ++ | defmodule LabsJidoAgent.LLM do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Centralized LLM configuration and client for Jido agents. |
+
| 4 | ++ | |
+
| 5 | ++ | Supports multiple providers: OpenAI, Anthropic, Google Gemini. |
+
| 6 | ++ | |
+
| 7 | ++ | ## Configuration |
+
| 8 | ++ | |
+
| 9 | ++ | Set via environment variables: |
+
| 10 | ++ | |
+
| 11 | ++ | export LLM_PROVIDER=openai # or anthropic, gemini |
+
| 12 | ++ | export OPENAI_API_KEY=sk-... |
+
| 13 | ++ | export ANTHROPIC_API_KEY=sk-ant-... |
+
| 14 | ++ | export GEMINI_API_KEY=... |
+
| 15 | ++ | |
+
| 16 | ++ | ## Usage |
+
| 17 | ++ | |
+
| 18 | ++ | # Simple text completion |
+
| 19 | ++ | {:ok, response} = LabsJidoAgent.LLM.chat("Explain recursion", model: :fast) |
+
| 20 | ++ | |
+
| 21 | ++ | # Structured output with validation |
+
| 22 | ++ | {:ok, result} = LabsJidoAgent.LLM.chat_structured( |
+
| 23 | ++ | "Review this code: ...", |
+
| 24 | ++ | response_model: CodeReviewResponse, |
+
| 25 | ++ | model: :smart |
+
| 26 | ++ | ) |
+
| 27 | ++ | """ |
+
| 28 | ++ | |
+
| 29 | ++ | @doc """ |
+
| 30 | ++ | Get the configured LLM provider. |
+
| 31 | ++ | Defaults to :openai if not set. |
+
| 32 | ++ | """ |
+
| 33 | ++ | def provider do |
+
| 34 | +100 | + case System.get_env("LLM_PROVIDER", "openai") do |
+
| 35 | +11 | + "anthropic" -> :anthropic |
+
| 36 | +8 | + "gemini" -> :gemini |
+
| 37 | +81 | + _ -> :openai |
+
| 38 | ++ | end |
+
| 39 | ++ | end |
+
| 40 | ++ | |
+
| 41 | ++ | @doc """ |
+
| 42 | ++ | Get the model name for the specified tier. |
+
| 43 | ++ | |
+
| 44 | ++ | ## Tiers |
+
| 45 | ++ | - `:fast` - Quick, cheaper responses |
+
| 46 | ++ | - `:smart` - Better quality, more expensive |
+
| 47 | ++ | - `:balanced` - Middle ground |
+
| 48 | ++ | """ |
+
| 49 | +1 | + def model_name(tier \\ :balanced) do |
+
| 50 | +32 | + get_model_for_provider(provider(), tier) |
+
| 51 | ++ | end |
+
| 52 | ++ | |
+
| 53 | +1 | + defp get_model_for_provider(:openai, :fast), do: "gpt-5-nano" |
+
| 54 | +17 | + defp get_model_for_provider(:openai, :balanced), do: "gpt-5-mini" |
+
| 55 | +5 | + defp get_model_for_provider(:openai, :smart), do: "gpt-5" |
+
| 56 | +2 | + defp get_model_for_provider(:anthropic, :fast), do: "claude-haiku-4-5" |
+
| 57 | +2 | + defp get_model_for_provider(:anthropic, :balanced), do: "claude-sonnet-4-5" |
+
| 58 | +1 | + defp get_model_for_provider(:anthropic, :smart), do: "claude-opus-4-1" |
+
| 59 | +1 | + defp get_model_for_provider(:gemini, :fast), do: "gemini-2.5-flash" |
+
| 60 | +2 | + defp get_model_for_provider(:gemini, :balanced), do: "gemini-2.5-flash" |
+
| 61 | +1 | + defp get_model_for_provider(:gemini, :smart), do: "gemini-2.5-pro" |
+
| 62 | ++ | |
+
| 63 | ++ | @doc """ |
+
| 64 | ++ | Simple chat completion returning text response. |
+
| 65 | ++ | |
+
| 66 | ++ | ## Options |
+
| 67 | ++ | - `:model` - Model tier (`:fast`, `:balanced`, `:smart`) |
+
| 68 | ++ | - `:temperature` - Creativity (0.0-2.0, default 0.7) |
+
| 69 | ++ | - `:max_tokens` - Max response length |
+
| 70 | ++ | """ |
+
| 71 | +2 | + def chat(prompt, opts \\ []) do |
+
| 72 | +3 | + model = Keyword.get(opts, :model, :balanced) |
+
| 73 | +3 | + temperature = Keyword.get(opts, :temperature, 0.7) |
+
| 74 | +3 | + max_tokens = Keyword.get(opts, :max_tokens, 2000) |
+
| 75 | ++ | |
+
| 76 | +3 | + params = %{ |
+
| 77 | ++ | model: model_name(model), |
+
| 78 | ++ | temperature: temperature, |
+
| 79 | ++ | max_tokens: max_tokens, |
+
| 80 | ++ | messages: [ |
+
| 81 | ++ | %{role: "user", content: prompt} |
+
| 82 | ++ | ] |
+
| 83 | ++ | } |
+
| 84 | ++ | |
+
| 85 | +3 | + case call_llm(params) do |
+
| 86 | +:-( |
+ {:ok, response} -> {:ok, extract_text(response)} |
+
| 87 | +3 | + error -> error |
+
| 88 | ++ | end |
+
| 89 | ++ | end |
+
| 90 | ++ | |
+
| 91 | ++ | @doc """ |
+
| 92 | ++ | Structured chat completion with validation via Instructor. |
+
| 93 | ++ | |
+
| 94 | ++ | ## Options |
+
| 95 | ++ | - `:response_model` - Ecto schema or map of types for validation |
+
| 96 | ++ | - `:model` - Model tier (`:fast`, `:balanced`, `:smart`) |
+
| 97 | ++ | - `:temperature` - Creativity (0.0-2.0) |
+
| 98 | ++ | - `:max_retries` - Retry count for validation failures (default 2) |
+
| 99 | ++ | """ |
+
| 100 | ++ | def chat_structured(prompt, opts) do |
+
| 101 | +20 | + response_model = Keyword.fetch!(opts, :response_model) |
+
| 102 | +19 | + model = Keyword.get(opts, :model, :balanced) |
+
| 103 | +19 | + temperature = Keyword.get(opts, :temperature, 0.7) |
+
| 104 | +19 | + max_retries = Keyword.get(opts, :max_retries, 2) |
+
| 105 | ++ | |
+
| 106 | ++ | # Get API key based on provider |
+
| 107 | +19 | + api_key = case provider() do |
+
| 108 | +17 | + :openai -> System.get_env("OPENAI_API_KEY") |
+
| 109 | +1 | + :anthropic -> System.get_env("ANTHROPIC_API_KEY") |
+
| 110 | +1 | + :gemini -> System.get_env("GEMINI_API_KEY") |
+
| 111 | ++ | end |
+
| 112 | ++ | |
+
| 113 | +19 | + params = [ |
+
| 114 | ++ | model: model_name(model), |
+
| 115 | ++ | temperature: temperature, |
+
| 116 | ++ | response_model: response_model, |
+
| 117 | ++ | max_retries: max_retries, |
+
| 118 | ++ | messages: [ |
+
| 119 | ++ | %{role: "user", content: prompt} |
+
| 120 | ++ | ] |
+
| 121 | ++ | ] |
+
| 122 | ++ | |
+
| 123 | ++ | # Config with API key and options is passed as second argument |
+
| 124 | ++ | # API URL depends on provider |
+
| 125 | +19 | + api_url = case provider() do |
+
| 126 | +17 | + :openai -> "https://api.openai.com" |
+
| 127 | +1 | + :anthropic -> "https://api.anthropic.com" |
+
| 128 | +1 | + :gemini -> "https://generativelanguage.googleapis.com" |
+
| 129 | ++ | end |
+
| 130 | ++ | |
+
| 131 | +19 | + config = [ |
+
| 132 | ++ | api_key: api_key, |
+
| 133 | ++ | api_url: api_url, |
+
| 134 | ++ | http_options: [receive_timeout: 60_000] |
+
| 135 | ++ | ] |
+
| 136 | ++ | |
+
| 137 | +19 | + Instructor.chat_completion(params, config) |
+
| 138 | ++ | end |
+
| 139 | ++ | |
+
| 140 | ++ | @doc """ |
+
| 141 | ++ | Check if LLM is configured and available. |
+
| 142 | ++ | """ |
+
| 143 | ++ | def available? do |
+
| 144 | +23 | + case provider() do |
+
| 145 | +20 | + :openai -> System.get_env("OPENAI_API_KEY") != nil |
+
| 146 | +2 | + :anthropic -> System.get_env("ANTHROPIC_API_KEY") != nil |
+
| 147 | +1 | + :gemini -> System.get_env("GEMINI_API_KEY") != nil |
+
| 148 | ++ | end |
+
| 149 | ++ | end |
+
| 150 | ++ | |
+
| 151 | ++ | # Private functions |
+
| 152 | ++ | |
+
| 153 | ++ | defp call_llm(params) do |
+
| 154 | +3 | + if available?() do |
+
| 155 | ++ | # Use Instructor for all calls (it handles provider differences) |
+
| 156 | +:-( |
+ Instructor.chat_completion(params) |
+
| 157 | ++ | else |
+
| 158 | +3 | + {:error, "LLM not configured. Set #{provider_env_var()} environment variable."} |
+
| 159 | ++ | end |
+
| 160 | ++ | end |
+
| 161 | ++ | |
+
| 162 | +:-( |
+ defp extract_text(%{choices: [%{message: %{content: content}} | _]}), do: content |
+
| 163 | +:-( |
+ defp extract_text(response) when is_binary(response), do: response |
+
| 164 | +:-( |
+ defp extract_text(_), do: "" |
+
| 165 | ++ | |
+
| 166 | ++ | defp provider_env_var do |
+
| 167 | +3 | + case provider() do |
+
| 168 | +2 | + :openai -> "OPENAI_API_KEY" |
+
| 169 | +1 | + :anthropic -> "ANTHROPIC_API_KEY" |
+
| 170 | +:-( |
+ :gemini -> "GEMINI_API_KEY" |
+
| 171 | ++ | end |
+
| 172 | ++ | end |
+
| 173 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.ProgressCoachAction.html| 1 | ++ | defmodule LabsJidoAgent.ProgressCoachAction do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | A Jido Action that analyzes learning progress and provides personalized recommendations. |
+
| 4 | ++ | |
+
| 5 | ++ | This action: |
+
| 6 | ++ | - Reads `.progress.json` to analyze completion |
+
| 7 | ++ | - Identifies strengths and challenges |
+
| 8 | ++ | - Suggests next phases |
+
| 9 | ++ | - Estimates time to completion |
+
| 10 | ++ | |
+
| 11 | ++ | ## Examples |
+
| 12 | ++ | |
+
| 13 | ++ | params = %{student_id: "student_123", progress_data: %{}} |
+
| 14 | ++ | {:ok, advice} = LabsJidoAgent.ProgressCoachAction.run(params, %{}) |
+
| 15 | ++ | """ |
+
| 16 | ++ | |
+
| 17 | ++ | use Jido.Action, |
+
| 18 | ++ | name: "progress_coach", |
+
| 19 | ++ | description: "Analyzes learning progress and provides personalized guidance", |
+
| 20 | ++ | category: "education", |
+
| 21 | ++ | tags: ["progress", "coaching", "analytics", "llm"], |
+
| 22 | ++ | schema: [ |
+
| 23 | ++ | student_id: [type: :string, required: true, doc: "Student identifier"], |
+
| 24 | ++ | progress_data: [type: :map, default: %{}, doc: "Progress JSON data (optional)"], |
+
| 25 | ++ | use_llm: [type: :boolean, default: true, doc: "Use LLM if available"] |
+
| 26 | ++ | ] |
+
| 27 | ++ | |
+
| 28 | ++ | alias LabsJidoAgent.{LLM, Schemas} |
+
| 29 | ++ | |
+
| 30 | ++ | @impl true |
+
| 31 | ++ | def run(params, _context) do |
+
| 32 | +10 | + student_id = params.student_id |
+
| 33 | +10 | + progress_data = params.progress_data |
+
| 34 | +10 | + use_llm = params.use_llm |
+
| 35 | ++ | |
+
| 36 | ++ | # Load progress from file if not provided |
+
| 37 | +10 | + progress = if progress_data == %{}, do: load_progress(), else: progress_data |
+
| 38 | ++ | |
+
| 39 | +10 | + if use_llm and LLM.available?() do |
+
| 40 | +5 | + llm_coaching(student_id, progress) |
+
| 41 | ++ | else |
+
| 42 | +5 | + simulated_coaching(student_id, progress) |
+
| 43 | ++ | end |
+
| 44 | ++ | end |
+
| 45 | ++ | |
+
| 46 | ++ | # LLM-powered coaching |
+
| 47 | ++ | defp llm_coaching(student_id, progress) do |
+
| 48 | ++ | # Analyze for context |
+
| 49 | +5 | + analysis = analyze_student_progress(progress) |
+
| 50 | +5 | + prompt = build_coaching_prompt(student_id, analysis) |
+
| 51 | ++ | |
+
| 52 | +5 | + case LLM.chat_structured(prompt, |
+
| 53 | ++ | response_model: Schemas.ProgressAnalysis, |
+
| 54 | ++ | model: :balanced, |
+
| 55 | ++ | temperature: 0.6 |
+
| 56 | ++ | ) do |
+
| 57 | ++ | {:ok, %Schemas.ProgressAnalysis{} = coach_response} -> |
+
| 58 | +:-( |
+ result = %{ |
+
| 59 | ++ | student_id: student_id, |
+
| 60 | ++ | recommendations: |
+
| 61 | +:-( |
+ Enum.map(coach_response.recommendations, &recommendation_to_map/1), |
+
| 62 | ++ | next_phase: suggest_next_phase(analysis), |
+
| 63 | ++ | review_areas: identify_review_areas(analysis), |
+
| 64 | +:-( |
+ strengths: coach_response.strengths || analysis.strengths, |
+
| 65 | +:-( |
+ challenges: coach_response.challenges || [], |
+
| 66 | ++ | estimated_time_to_next: estimate_time_to_completion(analysis, suggest_next_phase(analysis)), |
+
| 67 | ++ | llm_powered: true |
+
| 68 | ++ | } |
+
| 69 | ++ | |
+
| 70 | ++ | {:ok, result} |
+
| 71 | ++ | |
+
| 72 | ++ | {:error, reason} -> |
+
| 73 | +5 | + IO.warn("LLM coaching failed: #{inspect(reason)}, falling back to simulated") |
+
| 74 | +5 | + simulated_coaching(student_id, progress) |
+
| 75 | ++ | end |
+
| 76 | ++ | end |
+
| 77 | ++ | |
+
| 78 | ++ | defp build_coaching_prompt(student_id, analysis) do |
+
| 79 | +5 | + completion = round(analysis.overall_completion) |
+
| 80 | ++ | |
+
| 81 | +5 | + phase_summary = |
+
| 82 | +5 | + analysis.phase_stats |
+
| 83 | ++ | |> Enum.take(5) |
+
| 84 | ++ | |> Enum.map_join("\n", fn stat -> |
+
| 85 | +25 | + "- #{stat.phase}: #{round(stat.percentage)}% complete (#{stat.completed}/#{stat.total})" |
+
| 86 | ++ | end) |
+
| 87 | ++ | |
+
| 88 | +5 | + """ |
+
| 89 | ++ | You are an encouraging programming coach analyzing a student's progress. |
+
| 90 | ++ | |
+
| 91 | +5 | + Student ID: #{student_id} |
+
| 92 | +5 | + Overall completion: #{completion}% |
+
| 93 | ++ | |
+
| 94 | ++ | Progress by phase: |
+
| 95 | +5 | + #{phase_summary} |
+
| 96 | ++ | |
+
| 97 | ++ | Provide personalized coaching: |
+
| 98 | ++ | 1. Specific recommendations (with priority and actionable steps) |
+
| 99 | ++ | 2. Strengths to celebrate |
+
| 100 | ++ | 3. Challenges to address |
+
| 101 | ++ | 4. Next phase suggestion with reasoning |
+
| 102 | ++ | |
+
| 103 | ++ | Be encouraging, specific, and actionable. Focus on growth mindset and achievable goals. |
+
| 104 | ++ | """ |
+
| 105 | ++ | end |
+
| 106 | ++ | |
+
| 107 | ++ | defp recommendation_to_map(rec) when is_map(rec) do |
+
| 108 | ++ | # Handle both map (from LLM) and struct formats |
+
| 109 | +:-( |
+ %{ |
+
| 110 | +:-( |
+ priority: Map.get(rec, "priority") || Map.get(rec, :priority), |
+
| 111 | +:-( |
+ type: Map.get(rec, "type") || Map.get(rec, :type), |
+
| 112 | +:-( |
+ message: Map.get(rec, "message") || Map.get(rec, :message), |
+
| 113 | +:-( |
+ action: Map.get(rec, "action") || Map.get(rec, :action) |
+
| 114 | ++ | } |
+
| 115 | ++ | end |
+
| 116 | ++ | |
+
| 117 | ++ | # Simulated coaching (fallback) |
+
| 118 | ++ | defp simulated_coaching(student_id, progress) do |
+
| 119 | ++ | # Analyze current state |
+
| 120 | +10 | + analysis = analyze_student_progress(progress) |
+
| 121 | ++ | |
+
| 122 | ++ | # Generate personalized recommendations |
+
| 123 | +10 | + recommendations = generate_recommendations(analysis) |
+
| 124 | ++ | |
+
| 125 | ++ | # Determine next best phase |
+
| 126 | +10 | + next_phase = suggest_next_phase(analysis) |
+
| 127 | ++ | |
+
| 128 | ++ | # Identify areas needing review |
+
| 129 | +10 | + review_areas = identify_review_areas(analysis) |
+
| 130 | ++ | |
+
| 131 | +10 | + result = %{ |
+
| 132 | ++ | student_id: student_id, |
+
| 133 | ++ | recommendations: recommendations, |
+
| 134 | ++ | next_phase: next_phase, |
+
| 135 | ++ | review_areas: review_areas, |
+
| 136 | +10 | + strengths: analysis.strengths, |
+
| 137 | +10 | + challenges: analysis.challenges, |
+
| 138 | ++ | estimated_time_to_next: estimate_time_to_completion(analysis, next_phase), |
+
| 139 | ++ | llm_powered: false |
+
| 140 | ++ | } |
+
| 141 | ++ | |
+
| 142 | ++ | {:ok, result} |
+
| 143 | ++ | end |
+
| 144 | ++ | |
+
| 145 | ++ | # Private functions |
+
| 146 | ++ | |
+
| 147 | ++ | defp load_progress do |
+
| 148 | +3 | + progress_file = "livebooks/.progress.json" |
+
| 149 | ++ | |
+
| 150 | +3 | + case File.read(progress_file) do |
+
| 151 | +:-( |
+ {:ok, content} -> Jason.decode!(content) |
+
| 152 | +3 | + {:error, _} -> %{} |
+
| 153 | ++ | end |
+
| 154 | ++ | end |
+
| 155 | ++ | |
+
| 156 | ++ | defp analyze_student_progress(progress) do |
+
| 157 | +15 | + phases = get_all_phases() |
+
| 158 | ++ | |
+
| 159 | +15 | + phase_stats = |
+
| 160 | ++ | Enum.map(phases, fn phase -> |
+
| 161 | +225 | + phase_data = Map.get(progress, phase, %{}) |
+
| 162 | +225 | + checkpoints = Map.keys(phase_data) |
+
| 163 | +225 | + completed = Enum.count(checkpoints, fn cp -> Map.get(phase_data, cp) == true end) |
+
| 164 | +225 | + total = get_checkpoint_count(phase) |
+
| 165 | ++ | |
+
| 166 | +225 | + %{ |
+
| 167 | ++ | phase: phase, |
+
| 168 | ++ | completed: completed, |
+
| 169 | ++ | total: total, |
+
| 170 | +225 | + percentage: if(total > 0, do: completed / total * 100, else: 0), |
+
| 171 | ++ | status: determine_phase_status(completed, total) |
+
| 172 | ++ | } |
+
| 173 | ++ | end) |
+
| 174 | ++ | |
+
| 175 | +15 | + current_phase = find_current_phase(phase_stats) |
+
| 176 | +15 | + strengths = identify_strengths(phase_stats) |
+
| 177 | +15 | + challenges = identify_challenges(phase_stats) |
+
| 178 | ++ | |
+
| 179 | +15 | + %{ |
+
| 180 | ++ | current_phase: current_phase, |
+
| 181 | ++ | phase_stats: phase_stats, |
+
| 182 | ++ | overall_completion: calculate_overall_completion(phase_stats), |
+
| 183 | ++ | strengths: strengths, |
+
| 184 | ++ | challenges: challenges |
+
| 185 | ++ | } |
+
| 186 | ++ | end |
+
| 187 | ++ | |
+
| 188 | +17 | + defp get_all_phases do |
+
| 189 | ++ | [ |
+
| 190 | ++ | "phase-01-core", |
+
| 191 | ++ | "phase-02-processes", |
+
| 192 | ++ | "phase-03-genserver", |
+
| 193 | ++ | "phase-04-naming", |
+
| 194 | ++ | "phase-05-data", |
+
| 195 | ++ | "phase-06-phoenix", |
+
| 196 | ++ | "phase-07-jobs", |
+
| 197 | ++ | "phase-08-caching", |
+
| 198 | ++ | "phase-09-distribution", |
+
| 199 | ++ | "phase-10-observability", |
+
| 200 | ++ | "phase-11-testing", |
+
| 201 | ++ | "phase-12-delivery", |
+
| 202 | ++ | "phase-13-capstone", |
+
| 203 | ++ | "phase-14-cto", |
+
| 204 | ++ | "phase-15-ai" |
+
| 205 | ++ | ] |
+
| 206 | ++ | end |
+
| 207 | ++ | |
+
| 208 | +15 | + defp get_checkpoint_count("phase-01-core"), do: 7 |
+
| 209 | +210 | + defp get_checkpoint_count(_), do: 5 |
+
| 210 | ++ | |
+
| 211 | ++ | defp determine_phase_status(completed, total) do |
+
| 212 | +225 | + percentage = if total > 0, do: completed / total * 100, else: 0 |
+
| 213 | ++ | |
+
| 214 | +225 | + cond do |
+
| 215 | +219 | + percentage == 0 -> :not_started |
+
| 216 | +6 | + percentage == 100 -> :completed |
+
| 217 | +4 | + percentage >= 50 -> :in_progress_strong |
+
| 218 | +2 | + true -> :in_progress |
+
| 219 | ++ | end |
+
| 220 | ++ | end |
+
| 221 | ++ | |
+
| 222 | ++ | defp find_current_phase(phase_stats) do |
+
| 223 | ++ | phase_stats |
+
| 224 | ++ | |> Enum.find(fn stat -> |
+
| 225 | +169 | + stat.status in [:in_progress, :in_progress_strong] |
+
| 226 | ++ | end) |
+
| 227 | +15 | + |> case do |
+
| 228 | ++ | nil -> |
+
| 229 | ++ | # Find first incomplete phase |
+
| 230 | +11 | + Enum.find(phase_stats, fn stat -> stat.status == :not_started end) |
+
| 231 | ++ | |
+
| 232 | ++ | phase -> |
+
| 233 | +4 | + phase |
+
| 234 | ++ | end |
+
| 235 | ++ | end |
+
| 236 | ++ | |
+
| 237 | ++ | defp calculate_overall_completion(phase_stats) do |
+
| 238 | +15 | + total_checkpoints = Enum.sum(Enum.map(phase_stats, & &1.total)) |
+
| 239 | +15 | + completed_checkpoints = Enum.sum(Enum.map(phase_stats, & &1.completed)) |
+
| 240 | ++ | |
+
| 241 | +15 | + if total_checkpoints > 0 do |
+
| 242 | +15 | + completed_checkpoints / total_checkpoints * 100 |
+
| 243 | ++ | else |
+
| 244 | ++ | 0 |
+
| 245 | ++ | end |
+
| 246 | ++ | end |
+
| 247 | ++ | |
+
| 248 | ++ | defp identify_strengths(phase_stats) do |
+
| 249 | ++ | phase_stats |
+
| 250 | +225 | + |> Enum.filter(fn stat -> stat.percentage == 100 end) |
+
| 251 | +15 | + |> Enum.map(fn stat -> phase_to_concept(stat.phase) end) |
+
| 252 | ++ | end |
+
| 253 | ++ | |
+
| 254 | ++ | defp identify_challenges(phase_stats) do |
+
| 255 | ++ | phase_stats |
+
| 256 | ++ | |> Enum.filter(fn stat -> |
+
| 257 | +225 | + stat.status == :in_progress and stat.percentage < 50 and stat.percentage > 0 |
+
| 258 | ++ | end) |
+
| 259 | +15 | + |> Enum.map(fn stat -> %{phase: stat.phase, completion: stat.percentage} end) |
+
| 260 | ++ | end |
+
| 261 | ++ | |
+
| 262 | +2 | + defp phase_to_concept("phase-01-core"), do: "Elixir fundamentals" |
+
| 263 | +:-( |
+ defp phase_to_concept("phase-02-processes"), do: "Process management" |
+
| 264 | +:-( |
+ defp phase_to_concept("phase-03-genserver"), do: "GenServer & supervision" |
+
| 265 | +:-( |
+ defp phase_to_concept(phase), do: phase |
+
| 266 | ++ | |
+
| 267 | ++ | defp generate_recommendations(analysis) do |
+
| 268 | +10 | + recommendations = [] |
+
| 269 | ++ | |
+
| 270 | ++ | # Recommend next phase if current is nearly complete |
+
| 271 | +10 | + recommendations = |
+
| 272 | +10 | + if analysis.current_phase && analysis.current_phase.percentage >= 80 do |
+
| 273 | ++ | [ |
+
| 274 | ++ | %{ |
+
| 275 | ++ | priority: :high, |
+
| 276 | ++ | type: :progress, |
+
| 277 | ++ | message: |
+
| 278 | +1 | + "You're doing great on #{analysis.current_phase.phase}! Consider moving to the next phase soon.", |
+
| 279 | ++ | action: "Review remaining checkpoints and advance" |
+
| 280 | ++ | } |
+
| 281 | ++ | | recommendations |
+
| 282 | ++ | ] |
+
| 283 | ++ | else |
+
| 284 | +9 | + recommendations |
+
| 285 | ++ | end |
+
| 286 | ++ | |
+
| 287 | ++ | # Add encouragement for strengths |
+
| 288 | +10 | + recommendations = |
+
| 289 | +10 | + if length(analysis.strengths) > 0 do |
+
| 290 | ++ | [ |
+
| 291 | ++ | %{ |
+
| 292 | ++ | priority: :low, |
+
| 293 | ++ | type: :encouragement, |
+
| 294 | +1 | + message: "Great work mastering: #{Enum.join(analysis.strengths, ", ")}!", |
+
| 295 | ++ | action: "Keep up the momentum" |
+
| 296 | ++ | } |
+
| 297 | ++ | | recommendations |
+
| 298 | ++ | ] |
+
| 299 | ++ | else |
+
| 300 | +9 | + recommendations |
+
| 301 | ++ | end |
+
| 302 | ++ | |
+
| 303 | ++ | # Default recommendation if empty |
+
| 304 | +10 | + if recommendations == [] do |
+
| 305 | ++ | [ |
+
| 306 | ++ | %{ |
+
| 307 | ++ | priority: :medium, |
+
| 308 | ++ | type: :start, |
+
| 309 | ++ | message: "Ready to start your Elixir journey?", |
+
| 310 | ++ | action: "Begin with Phase 1: Elixir Core" |
+
| 311 | ++ | } |
+
| 312 | ++ | ] |
+
| 313 | ++ | else |
+
| 314 | +2 | + recommendations |
+
| 315 | ++ | end |
+
| 316 | ++ | end |
+
| 317 | ++ | |
+
| 318 | ++ | defp suggest_next_phase(analysis) do |
+
| 319 | +10 | + cond do |
+
| 320 | +10 | + is_nil(analysis.current_phase) -> |
+
| 321 | +:-( |
+ %{ |
+
| 322 | ++ | phase: "phase-01-core", |
+
| 323 | ++ | reason: "Start here for Elixir fundamentals", |
+
| 324 | ++ | prerequisite_met: true |
+
| 325 | ++ | } |
+
| 326 | ++ | |
+
| 327 | +10 | + analysis.current_phase.percentage >= 80 -> |
+
| 328 | +1 | + current_index = |
+
| 329 | +1 | + Enum.find_index(get_all_phases(), fn p -> p == analysis.current_phase.phase end) |
+
| 330 | ++ | |
+
| 331 | +1 | + next_phase = Enum.at(get_all_phases(), current_index + 1) |
+
| 332 | ++ | |
+
| 333 | +1 | + %{ |
+
| 334 | ++ | phase: next_phase, |
+
| 335 | +1 | + reason: "You've completed #{round(analysis.current_phase.percentage)}% of #{analysis.current_phase.phase}", |
+
| 336 | ++ | prerequisite_met: true |
+
| 337 | ++ | } |
+
| 338 | ++ | |
+
| 339 | +9 | + true -> |
+
| 340 | +9 | + %{ |
+
| 341 | +9 | + phase: analysis.current_phase.phase, |
+
| 342 | ++ | reason: "Complete remaining checkpoints first", |
+
| 343 | ++ | prerequisite_met: false |
+
| 344 | ++ | } |
+
| 345 | ++ | end |
+
| 346 | ++ | end |
+
| 347 | ++ | |
+
| 348 | ++ | defp identify_review_areas(analysis) do |
+
| 349 | +10 | + Enum.map(analysis.challenges, fn challenge -> |
+
| 350 | +1 | + %{ |
+
| 351 | +1 | + phase: challenge.phase, |
+
| 352 | +1 | + completion: challenge.completion, |
+
| 353 | ++ | suggested_action: "Review checkpoints and complete exercises", |
+
| 354 | +1 | + resources: ["Livebook: #{challenge.phase}", "Study guide"] |
+
| 355 | ++ | } |
+
| 356 | ++ | end) |
+
| 357 | ++ | end |
+
| 358 | ++ | |
+
| 359 | ++ | defp estimate_time_to_completion(_analysis, next_phase) do |
+
| 360 | +10 | + days = get_estimated_days(next_phase.phase) |
+
| 361 | ++ | |
+
| 362 | +10 | + %{ |
+
| 363 | ++ | estimate_days: days, |
+
| 364 | ++ | estimate_hours: days * 6, |
+
| 365 | ++ | confidence: :medium |
+
| 366 | ++ | } |
+
| 367 | ++ | end |
+
| 368 | ++ | |
+
| 369 | +8 | + defp get_estimated_days("phase-01-core"), do: 7 |
+
| 370 | +2 | + defp get_estimated_days(_), do: 7 |
+
| 371 | ++ | |
+
| 372 | ++ | ## Public Helper API |
+
| 373 | ++ | |
+
| 374 | ++ | @doc """ |
+
| 375 | ++ | Analyzes student progress and provides coaching recommendations (convenience wrapper). |
+
| 376 | ++ | |
+
| 377 | ++ | ## Examples |
+
| 378 | ++ | |
+
| 379 | ++ | {:ok, advice} = LabsJidoAgent.ProgressCoachAction.analyze_progress("student_123") |
+
| 380 | ++ | IO.inspect(advice.recommendations) |
+
| 381 | ++ | """ |
+
| 382 | +:-( |
+ def analyze_progress(student_id, progress_data \\ %{}, opts \\ []) do |
+
| 383 | +:-( |
+ params = %{ |
+
| 384 | ++ | student_id: student_id, |
+
| 385 | ++ | progress_data: progress_data, |
+
| 386 | ++ | use_llm: Keyword.get(opts, :use_llm, true) |
+
| 387 | ++ | } |
+
| 388 | ++ | |
+
| 389 | +:-( |
+ run(params, %{}) |
+
| 390 | ++ | end |
+
| 391 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.ProgressCoachAgent.html| 1 | ++ | defmodule LabsJidoAgent.ProgressCoachAgent do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | An Agent that monitors student progress and provides personalized recommendations. |
+
| 4 | ++ | |
+
| 5 | ++ | Features: |
+
| 6 | ++ | - Reads `.progress.json` automatically |
+
| 7 | ++ | - Identifies strengths and challenges |
+
| 8 | ++ | - Suggests next phases |
+
| 9 | ++ | - Recommends review areas |
+
| 10 | ++ | - Estimates time to completion |
+
| 11 | ++ | |
+
| 12 | ++ | ## Examples |
+
| 13 | ++ | |
+
| 14 | ++ | {:ok, advice} = LabsJidoAgent.ProgressCoachAgent.analyze_progress("student_123") |
+
| 15 | ++ | IO.inspect(advice.recommendations) |
+
| 16 | ++ | IO.inspect(advice.next_phase) |
+
| 17 | ++ | """ |
+
| 18 | ++ | |
+
| 19 | +:-( |
+ use Jido.Agent, |
+
| 20 | ++ | name: "progress_coach_agent", |
+
| 21 | ++ | description: "Analyzes learning progress and provides personalized guidance", |
+
| 22 | ++ | category: "education", |
+
| 23 | ++ | tags: ["progress", "analytics"], |
+
| 24 | ++ | schema: [ |
+
| 25 | ++ | student_id: [type: :string, doc: "Student identifier"], |
+
| 26 | ++ | progress_data: [type: :map, default: %{}, doc: "Progress JSON data"] |
+
| 27 | ++ | ], |
+
| 28 | ++ | actions: [LabsJidoAgent.ProgressCoachAction] |
+
| 29 | ++ | |
+
| 30 | ++ | @doc """ |
+
| 31 | ++ | Analyzes student progress and provides coaching recommendations (convenience wrapper). |
+
| 32 | ++ | |
+
| 33 | ++ | ## Examples |
+
| 34 | ++ | |
+
| 35 | ++ | {:ok, advice} = LabsJidoAgent.ProgressCoachAgent.analyze_progress("student_123") |
+
| 36 | ++ | IO.inspect(advice.recommendations) |
+
| 37 | ++ | IO.inspect(advice.next_phase) |
+
| 38 | ++ | """ |
+
| 39 | +5 | + def analyze_progress(student_id, progress_data \\ %{}, opts \\ []) do |
+
| 40 | +5 | + use_llm = Keyword.get(opts, :use_llm, true) |
+
| 41 | ++ | |
+
| 42 | ++ | # Build params and call action directly for convenience |
+
| 43 | +5 | + params = %{student_id: student_id, progress_data: progress_data, use_llm: use_llm} |
+
| 44 | +5 | + LabsJidoAgent.ProgressCoachAction.run(params, %{}) |
+
| 45 | ++ | end |
+
| 46 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.Schemas.CodeIssue.html| 1 | ++ | defmodule LabsJidoAgent.Schemas do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Ecto schemas for structured LLM responses. |
+
| 4 | ++ | |
+
| 5 | ++ | These schemas define the expected structure of LLM outputs, |
+
| 6 | ++ | enabling validation and type safety via Instructor. |
+
| 7 | ++ | """ |
+
| 8 | ++ | |
+
| 9 | ++ | defmodule CodeIssue do |
+
| 10 | ++ | @moduledoc "Represents a code quality issue" |
+
| 11 | ++ | use Ecto.Schema |
+
| 12 | ++ | import Ecto.Changeset |
+
| 13 | ++ | |
+
| 14 | ++ | @primary_key false |
+
| 15 | +4 | + embedded_schema do |
+
| 16 | ++ | field(:type, Ecto.Enum, values: [:quality, :performance, :idioms, :security]) |
+
| 17 | ++ | field(:severity, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 18 | ++ | field(:line, :integer) |
+
| 19 | ++ | field(:message, :string) |
+
| 20 | ++ | field(:suggestion, :string) |
+
| 21 | ++ | end |
+
| 22 | ++ | |
+
| 23 | ++ | def changeset(issue, attrs) do |
+
| 24 | ++ | issue |
+
| 25 | ++ | |> cast(attrs, [:type, :severity, :line, :message, :suggestion]) |
+
| 26 | +2 | + |> validate_required([:type, :severity, :message, :suggestion]) |
+
| 27 | ++ | end |
+
| 28 | ++ | end |
+
| 29 | ++ | |
+
| 30 | ++ | defmodule CodeReviewResponse do |
+
| 31 | ++ | @moduledoc "Structured code review response from LLM" |
+
| 32 | ++ | use Ecto.Schema |
+
| 33 | ++ | import Ecto.Changeset |
+
| 34 | ++ | |
+
| 35 | ++ | @primary_key false |
+
| 36 | ++ | embedded_schema do |
+
| 37 | ++ | field(:score, :integer) |
+
| 38 | ++ | field(:summary, :string) |
+
| 39 | ++ | field(:issues, {:array, :map}) |
+
| 40 | ++ | field(:suggestions, {:array, :string}) |
+
| 41 | ++ | field(:resources, {:array, :string}) |
+
| 42 | ++ | end |
+
| 43 | ++ | |
+
| 44 | ++ | def changeset(review, attrs) do |
+
| 45 | ++ | review |
+
| 46 | ++ | |> cast(attrs, [:score, :summary, :issues, :suggestions, :resources]) |
+
| 47 | ++ | |> validate_required([:score, :summary]) |
+
| 48 | ++ | |> validate_number(:score, greater_than_or_equal_to: 0, less_than_or_equal_to: 100) |
+
| 49 | ++ | end |
+
| 50 | ++ | end |
+
| 51 | ++ | |
+
| 52 | ++ | defmodule StudyResponse do |
+
| 53 | ++ | @moduledoc "Structured study/Q&A response from LLM" |
+
| 54 | ++ | use Ecto.Schema |
+
| 55 | ++ | import Ecto.Changeset |
+
| 56 | ++ | |
+
| 57 | ++ | @primary_key false |
+
| 58 | ++ | embedded_schema do |
+
| 59 | ++ | field(:answer, :string) |
+
| 60 | ++ | field(:concepts, {:array, :string}) |
+
| 61 | ++ | field(:resources, {:array, :string}) |
+
| 62 | ++ | field(:follow_ups, {:array, :string}) |
+
| 63 | ++ | end |
+
| 64 | ++ | |
+
| 65 | ++ | def changeset(response, attrs) do |
+
| 66 | ++ | response |
+
| 67 | ++ | |> cast(attrs, [:answer, :concepts, :resources, :follow_ups]) |
+
| 68 | ++ | |> validate_required([:answer]) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| 71 | ++ | |
+
| 72 | ++ | defmodule ProgressRecommendation do |
+
| 73 | ++ | @moduledoc "A single progress recommendation" |
+
| 74 | ++ | use Ecto.Schema |
+
| 75 | ++ | import Ecto.Changeset |
+
| 76 | ++ | |
+
| 77 | ++ | @primary_key false |
+
| 78 | ++ | embedded_schema do |
+
| 79 | ++ | field(:priority, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 80 | ++ | field(:type, Ecto.Enum, |
+
| 81 | ++ | values: [:progress, :review, :encouragement, :start, :challenge] |
+
| 82 | ++ | ) |
+
| 83 | ++ | |
+
| 84 | ++ | field(:message, :string) |
+
| 85 | ++ | field(:action, :string) |
+
| 86 | ++ | end |
+
| 87 | ++ | |
+
| 88 | ++ | def changeset(rec, attrs) do |
+
| 89 | ++ | rec |
+
| 90 | ++ | |> cast(attrs, [:priority, :type, :message, :action]) |
+
| 91 | ++ | |> validate_required([:priority, :type, :message, :action]) |
+
| 92 | ++ | end |
+
| 93 | ++ | end |
+
| 94 | ++ | |
+
| 95 | ++ | defmodule ProgressAnalysis do |
+
| 96 | ++ | @moduledoc "Structured progress coaching response from LLM" |
+
| 97 | ++ | use Ecto.Schema |
+
| 98 | ++ | import Ecto.Changeset |
+
| 99 | ++ | |
+
| 100 | ++ | @primary_key false |
+
| 101 | ++ | embedded_schema do |
+
| 102 | ++ | field(:recommendations, {:array, :map}) |
+
| 103 | ++ | field(:strengths, {:array, :string}) |
+
| 104 | ++ | field(:challenges, {:array, :string}) |
+
| 105 | ++ | field(:next_phase_suggestion, :string) |
+
| 106 | ++ | end |
+
| 107 | ++ | |
+
| 108 | ++ | def changeset(analysis, attrs) do |
+
| 109 | ++ | analysis |
+
| 110 | ++ | |> cast(attrs, [:recommendations, :strengths, :challenges, :next_phase_suggestion]) |
+
| 111 | ++ | |> validate_required([:recommendations]) |
+
| 112 | ++ | end |
+
| 113 | ++ | end |
+
| 114 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.Schemas.CodeReviewResponse.html| 1 | ++ | defmodule LabsJidoAgent.Schemas do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Ecto schemas for structured LLM responses. |
+
| 4 | ++ | |
+
| 5 | ++ | These schemas define the expected structure of LLM outputs, |
+
| 6 | ++ | enabling validation and type safety via Instructor. |
+
| 7 | ++ | """ |
+
| 8 | ++ | |
+
| 9 | ++ | defmodule CodeIssue do |
+
| 10 | ++ | @moduledoc "Represents a code quality issue" |
+
| 11 | ++ | use Ecto.Schema |
+
| 12 | ++ | import Ecto.Changeset |
+
| 13 | ++ | |
+
| 14 | ++ | @primary_key false |
+
| 15 | ++ | embedded_schema do |
+
| 16 | ++ | field(:type, Ecto.Enum, values: [:quality, :performance, :idioms, :security]) |
+
| 17 | ++ | field(:severity, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 18 | ++ | field(:line, :integer) |
+
| 19 | ++ | field(:message, :string) |
+
| 20 | ++ | field(:suggestion, :string) |
+
| 21 | ++ | end |
+
| 22 | ++ | |
+
| 23 | ++ | def changeset(issue, attrs) do |
+
| 24 | ++ | issue |
+
| 25 | ++ | |> cast(attrs, [:type, :severity, :line, :message, :suggestion]) |
+
| 26 | ++ | |> validate_required([:type, :severity, :message, :suggestion]) |
+
| 27 | ++ | end |
+
| 28 | ++ | end |
+
| 29 | ++ | |
+
| 30 | ++ | defmodule CodeReviewResponse do |
+
| 31 | ++ | @moduledoc "Structured code review response from LLM" |
+
| 32 | ++ | use Ecto.Schema |
+
| 33 | ++ | import Ecto.Changeset |
+
| 34 | ++ | |
+
| 35 | ++ | @primary_key false |
+
| 36 | +46 | + embedded_schema do |
+
| 37 | ++ | field(:score, :integer) |
+
| 38 | ++ | field(:summary, :string) |
+
| 39 | ++ | field(:issues, {:array, :map}) |
+
| 40 | ++ | field(:suggestions, {:array, :string}) |
+
| 41 | ++ | field(:resources, {:array, :string}) |
+
| 42 | ++ | end |
+
| 43 | ++ | |
+
| 44 | ++ | def changeset(review, attrs) do |
+
| 45 | ++ | review |
+
| 46 | ++ | |> cast(attrs, [:score, :summary, :issues, :suggestions, :resources]) |
+
| 47 | ++ | |> validate_required([:score, :summary]) |
+
| 48 | +3 | + |> validate_number(:score, greater_than_or_equal_to: 0, less_than_or_equal_to: 100) |
+
| 49 | ++ | end |
+
| 50 | ++ | end |
+
| 51 | ++ | |
+
| 52 | ++ | defmodule StudyResponse do |
+
| 53 | ++ | @moduledoc "Structured study/Q&A response from LLM" |
+
| 54 | ++ | use Ecto.Schema |
+
| 55 | ++ | import Ecto.Changeset |
+
| 56 | ++ | |
+
| 57 | ++ | @primary_key false |
+
| 58 | ++ | embedded_schema do |
+
| 59 | ++ | field(:answer, :string) |
+
| 60 | ++ | field(:concepts, {:array, :string}) |
+
| 61 | ++ | field(:resources, {:array, :string}) |
+
| 62 | ++ | field(:follow_ups, {:array, :string}) |
+
| 63 | ++ | end |
+
| 64 | ++ | |
+
| 65 | ++ | def changeset(response, attrs) do |
+
| 66 | ++ | response |
+
| 67 | ++ | |> cast(attrs, [:answer, :concepts, :resources, :follow_ups]) |
+
| 68 | ++ | |> validate_required([:answer]) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| 71 | ++ | |
+
| 72 | ++ | defmodule ProgressRecommendation do |
+
| 73 | ++ | @moduledoc "A single progress recommendation" |
+
| 74 | ++ | use Ecto.Schema |
+
| 75 | ++ | import Ecto.Changeset |
+
| 76 | ++ | |
+
| 77 | ++ | @primary_key false |
+
| 78 | ++ | embedded_schema do |
+
| 79 | ++ | field(:priority, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 80 | ++ | field(:type, Ecto.Enum, |
+
| 81 | ++ | values: [:progress, :review, :encouragement, :start, :challenge] |
+
| 82 | ++ | ) |
+
| 83 | ++ | |
+
| 84 | ++ | field(:message, :string) |
+
| 85 | ++ | field(:action, :string) |
+
| 86 | ++ | end |
+
| 87 | ++ | |
+
| 88 | ++ | def changeset(rec, attrs) do |
+
| 89 | ++ | rec |
+
| 90 | ++ | |> cast(attrs, [:priority, :type, :message, :action]) |
+
| 91 | ++ | |> validate_required([:priority, :type, :message, :action]) |
+
| 92 | ++ | end |
+
| 93 | ++ | end |
+
| 94 | ++ | |
+
| 95 | ++ | defmodule ProgressAnalysis do |
+
| 96 | ++ | @moduledoc "Structured progress coaching response from LLM" |
+
| 97 | ++ | use Ecto.Schema |
+
| 98 | ++ | import Ecto.Changeset |
+
| 99 | ++ | |
+
| 100 | ++ | @primary_key false |
+
| 101 | ++ | embedded_schema do |
+
| 102 | ++ | field(:recommendations, {:array, :map}) |
+
| 103 | ++ | field(:strengths, {:array, :string}) |
+
| 104 | ++ | field(:challenges, {:array, :string}) |
+
| 105 | ++ | field(:next_phase_suggestion, :string) |
+
| 106 | ++ | end |
+
| 107 | ++ | |
+
| 108 | ++ | def changeset(analysis, attrs) do |
+
| 109 | ++ | analysis |
+
| 110 | ++ | |> cast(attrs, [:recommendations, :strengths, :challenges, :next_phase_suggestion]) |
+
| 111 | ++ | |> validate_required([:recommendations]) |
+
| 112 | ++ | end |
+
| 113 | ++ | end |
+
| 114 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.Schemas.ProgressAnalysis.html| 1 | ++ | defmodule LabsJidoAgent.Schemas do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Ecto schemas for structured LLM responses. |
+
| 4 | ++ | |
+
| 5 | ++ | These schemas define the expected structure of LLM outputs, |
+
| 6 | ++ | enabling validation and type safety via Instructor. |
+
| 7 | ++ | """ |
+
| 8 | ++ | |
+
| 9 | ++ | defmodule CodeIssue do |
+
| 10 | ++ | @moduledoc "Represents a code quality issue" |
+
| 11 | ++ | use Ecto.Schema |
+
| 12 | ++ | import Ecto.Changeset |
+
| 13 | ++ | |
+
| 14 | ++ | @primary_key false |
+
| 15 | ++ | embedded_schema do |
+
| 16 | ++ | field(:type, Ecto.Enum, values: [:quality, :performance, :idioms, :security]) |
+
| 17 | ++ | field(:severity, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 18 | ++ | field(:line, :integer) |
+
| 19 | ++ | field(:message, :string) |
+
| 20 | ++ | field(:suggestion, :string) |
+
| 21 | ++ | end |
+
| 22 | ++ | |
+
| 23 | ++ | def changeset(issue, attrs) do |
+
| 24 | ++ | issue |
+
| 25 | ++ | |> cast(attrs, [:type, :severity, :line, :message, :suggestion]) |
+
| 26 | ++ | |> validate_required([:type, :severity, :message, :suggestion]) |
+
| 27 | ++ | end |
+
| 28 | ++ | end |
+
| 29 | ++ | |
+
| 30 | ++ | defmodule CodeReviewResponse do |
+
| 31 | ++ | @moduledoc "Structured code review response from LLM" |
+
| 32 | ++ | use Ecto.Schema |
+
| 33 | ++ | import Ecto.Changeset |
+
| 34 | ++ | |
+
| 35 | ++ | @primary_key false |
+
| 36 | ++ | embedded_schema do |
+
| 37 | ++ | field(:score, :integer) |
+
| 38 | ++ | field(:summary, :string) |
+
| 39 | ++ | field(:issues, {:array, :map}) |
+
| 40 | ++ | field(:suggestions, {:array, :string}) |
+
| 41 | ++ | field(:resources, {:array, :string}) |
+
| 42 | ++ | end |
+
| 43 | ++ | |
+
| 44 | ++ | def changeset(review, attrs) do |
+
| 45 | ++ | review |
+
| 46 | ++ | |> cast(attrs, [:score, :summary, :issues, :suggestions, :resources]) |
+
| 47 | ++ | |> validate_required([:score, :summary]) |
+
| 48 | ++ | |> validate_number(:score, greater_than_or_equal_to: 0, less_than_or_equal_to: 100) |
+
| 49 | ++ | end |
+
| 50 | ++ | end |
+
| 51 | ++ | |
+
| 52 | ++ | defmodule StudyResponse do |
+
| 53 | ++ | @moduledoc "Structured study/Q&A response from LLM" |
+
| 54 | ++ | use Ecto.Schema |
+
| 55 | ++ | import Ecto.Changeset |
+
| 56 | ++ | |
+
| 57 | ++ | @primary_key false |
+
| 58 | ++ | embedded_schema do |
+
| 59 | ++ | field(:answer, :string) |
+
| 60 | ++ | field(:concepts, {:array, :string}) |
+
| 61 | ++ | field(:resources, {:array, :string}) |
+
| 62 | ++ | field(:follow_ups, {:array, :string}) |
+
| 63 | ++ | end |
+
| 64 | ++ | |
+
| 65 | ++ | def changeset(response, attrs) do |
+
| 66 | ++ | response |
+
| 67 | ++ | |> cast(attrs, [:answer, :concepts, :resources, :follow_ups]) |
+
| 68 | ++ | |> validate_required([:answer]) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| 71 | ++ | |
+
| 72 | ++ | defmodule ProgressRecommendation do |
+
| 73 | ++ | @moduledoc "A single progress recommendation" |
+
| 74 | ++ | use Ecto.Schema |
+
| 75 | ++ | import Ecto.Changeset |
+
| 76 | ++ | |
+
| 77 | ++ | @primary_key false |
+
| 78 | ++ | embedded_schema do |
+
| 79 | ++ | field(:priority, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 80 | ++ | field(:type, Ecto.Enum, |
+
| 81 | ++ | values: [:progress, :review, :encouragement, :start, :challenge] |
+
| 82 | ++ | ) |
+
| 83 | ++ | |
+
| 84 | ++ | field(:message, :string) |
+
| 85 | ++ | field(:action, :string) |
+
| 86 | ++ | end |
+
| 87 | ++ | |
+
| 88 | ++ | def changeset(rec, attrs) do |
+
| 89 | ++ | rec |
+
| 90 | ++ | |> cast(attrs, [:priority, :type, :message, :action]) |
+
| 91 | ++ | |> validate_required([:priority, :type, :message, :action]) |
+
| 92 | ++ | end |
+
| 93 | ++ | end |
+
| 94 | ++ | |
+
| 95 | ++ | defmodule ProgressAnalysis do |
+
| 96 | ++ | @moduledoc "Structured progress coaching response from LLM" |
+
| 97 | ++ | use Ecto.Schema |
+
| 98 | ++ | import Ecto.Changeset |
+
| 99 | ++ | |
+
| 100 | ++ | @primary_key false |
+
| 101 | +49 | + embedded_schema do |
+
| 102 | ++ | field(:recommendations, {:array, :map}) |
+
| 103 | ++ | field(:strengths, {:array, :string}) |
+
| 104 | ++ | field(:challenges, {:array, :string}) |
+
| 105 | ++ | field(:next_phase_suggestion, :string) |
+
| 106 | ++ | end |
+
| 107 | ++ | |
+
| 108 | ++ | def changeset(analysis, attrs) do |
+
| 109 | ++ | analysis |
+
| 110 | ++ | |> cast(attrs, [:recommendations, :strengths, :challenges, :next_phase_suggestion]) |
+
| 111 | +2 | + |> validate_required([:recommendations]) |
+
| 112 | ++ | end |
+
| 113 | ++ | end |
+
| 114 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.Schemas.ProgressRecommendation.html| 1 | ++ | defmodule LabsJidoAgent.Schemas do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Ecto schemas for structured LLM responses. |
+
| 4 | ++ | |
+
| 5 | ++ | These schemas define the expected structure of LLM outputs, |
+
| 6 | ++ | enabling validation and type safety via Instructor. |
+
| 7 | ++ | """ |
+
| 8 | ++ | |
+
| 9 | ++ | defmodule CodeIssue do |
+
| 10 | ++ | @moduledoc "Represents a code quality issue" |
+
| 11 | ++ | use Ecto.Schema |
+
| 12 | ++ | import Ecto.Changeset |
+
| 13 | ++ | |
+
| 14 | ++ | @primary_key false |
+
| 15 | ++ | embedded_schema do |
+
| 16 | ++ | field(:type, Ecto.Enum, values: [:quality, :performance, :idioms, :security]) |
+
| 17 | ++ | field(:severity, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 18 | ++ | field(:line, :integer) |
+
| 19 | ++ | field(:message, :string) |
+
| 20 | ++ | field(:suggestion, :string) |
+
| 21 | ++ | end |
+
| 22 | ++ | |
+
| 23 | ++ | def changeset(issue, attrs) do |
+
| 24 | ++ | issue |
+
| 25 | ++ | |> cast(attrs, [:type, :severity, :line, :message, :suggestion]) |
+
| 26 | ++ | |> validate_required([:type, :severity, :message, :suggestion]) |
+
| 27 | ++ | end |
+
| 28 | ++ | end |
+
| 29 | ++ | |
+
| 30 | ++ | defmodule CodeReviewResponse do |
+
| 31 | ++ | @moduledoc "Structured code review response from LLM" |
+
| 32 | ++ | use Ecto.Schema |
+
| 33 | ++ | import Ecto.Changeset |
+
| 34 | ++ | |
+
| 35 | ++ | @primary_key false |
+
| 36 | ++ | embedded_schema do |
+
| 37 | ++ | field(:score, :integer) |
+
| 38 | ++ | field(:summary, :string) |
+
| 39 | ++ | field(:issues, {:array, :map}) |
+
| 40 | ++ | field(:suggestions, {:array, :string}) |
+
| 41 | ++ | field(:resources, {:array, :string}) |
+
| 42 | ++ | end |
+
| 43 | ++ | |
+
| 44 | ++ | def changeset(review, attrs) do |
+
| 45 | ++ | review |
+
| 46 | ++ | |> cast(attrs, [:score, :summary, :issues, :suggestions, :resources]) |
+
| 47 | ++ | |> validate_required([:score, :summary]) |
+
| 48 | ++ | |> validate_number(:score, greater_than_or_equal_to: 0, less_than_or_equal_to: 100) |
+
| 49 | ++ | end |
+
| 50 | ++ | end |
+
| 51 | ++ | |
+
| 52 | ++ | defmodule StudyResponse do |
+
| 53 | ++ | @moduledoc "Structured study/Q&A response from LLM" |
+
| 54 | ++ | use Ecto.Schema |
+
| 55 | ++ | import Ecto.Changeset |
+
| 56 | ++ | |
+
| 57 | ++ | @primary_key false |
+
| 58 | ++ | embedded_schema do |
+
| 59 | ++ | field(:answer, :string) |
+
| 60 | ++ | field(:concepts, {:array, :string}) |
+
| 61 | ++ | field(:resources, {:array, :string}) |
+
| 62 | ++ | field(:follow_ups, {:array, :string}) |
+
| 63 | ++ | end |
+
| 64 | ++ | |
+
| 65 | ++ | def changeset(response, attrs) do |
+
| 66 | ++ | response |
+
| 67 | ++ | |> cast(attrs, [:answer, :concepts, :resources, :follow_ups]) |
+
| 68 | ++ | |> validate_required([:answer]) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| 71 | ++ | |
+
| 72 | ++ | defmodule ProgressRecommendation do |
+
| 73 | ++ | @moduledoc "A single progress recommendation" |
+
| 74 | ++ | use Ecto.Schema |
+
| 75 | ++ | import Ecto.Changeset |
+
| 76 | ++ | |
+
| 77 | ++ | @primary_key false |
+
| 78 | +4 | + embedded_schema do |
+
| 79 | ++ | field(:priority, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 80 | ++ | field(:type, Ecto.Enum, |
+
| 81 | ++ | values: [:progress, :review, :encouragement, :start, :challenge] |
+
| 82 | ++ | ) |
+
| 83 | ++ | |
+
| 84 | ++ | field(:message, :string) |
+
| 85 | ++ | field(:action, :string) |
+
| 86 | ++ | end |
+
| 87 | ++ | |
+
| 88 | ++ | def changeset(rec, attrs) do |
+
| 89 | ++ | rec |
+
| 90 | ++ | |> cast(attrs, [:priority, :type, :message, :action]) |
+
| 91 | +2 | + |> validate_required([:priority, :type, :message, :action]) |
+
| 92 | ++ | end |
+
| 93 | ++ | end |
+
| 94 | ++ | |
+
| 95 | ++ | defmodule ProgressAnalysis do |
+
| 96 | ++ | @moduledoc "Structured progress coaching response from LLM" |
+
| 97 | ++ | use Ecto.Schema |
+
| 98 | ++ | import Ecto.Changeset |
+
| 99 | ++ | |
+
| 100 | ++ | @primary_key false |
+
| 101 | ++ | embedded_schema do |
+
| 102 | ++ | field(:recommendations, {:array, :map}) |
+
| 103 | ++ | field(:strengths, {:array, :string}) |
+
| 104 | ++ | field(:challenges, {:array, :string}) |
+
| 105 | ++ | field(:next_phase_suggestion, :string) |
+
| 106 | ++ | end |
+
| 107 | ++ | |
+
| 108 | ++ | def changeset(analysis, attrs) do |
+
| 109 | ++ | analysis |
+
| 110 | ++ | |> cast(attrs, [:recommendations, :strengths, :challenges, :next_phase_suggestion]) |
+
| 111 | ++ | |> validate_required([:recommendations]) |
+
| 112 | ++ | end |
+
| 113 | ++ | end |
+
| 114 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.Schemas.StudyResponse.html| 1 | ++ | defmodule LabsJidoAgent.Schemas do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Ecto schemas for structured LLM responses. |
+
| 4 | ++ | |
+
| 5 | ++ | These schemas define the expected structure of LLM outputs, |
+
| 6 | ++ | enabling validation and type safety via Instructor. |
+
| 7 | ++ | """ |
+
| 8 | ++ | |
+
| 9 | ++ | defmodule CodeIssue do |
+
| 10 | ++ | @moduledoc "Represents a code quality issue" |
+
| 11 | ++ | use Ecto.Schema |
+
| 12 | ++ | import Ecto.Changeset |
+
| 13 | ++ | |
+
| 14 | ++ | @primary_key false |
+
| 15 | ++ | embedded_schema do |
+
| 16 | ++ | field(:type, Ecto.Enum, values: [:quality, :performance, :idioms, :security]) |
+
| 17 | ++ | field(:severity, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 18 | ++ | field(:line, :integer) |
+
| 19 | ++ | field(:message, :string) |
+
| 20 | ++ | field(:suggestion, :string) |
+
| 21 | ++ | end |
+
| 22 | ++ | |
+
| 23 | ++ | def changeset(issue, attrs) do |
+
| 24 | ++ | issue |
+
| 25 | ++ | |> cast(attrs, [:type, :severity, :line, :message, :suggestion]) |
+
| 26 | ++ | |> validate_required([:type, :severity, :message, :suggestion]) |
+
| 27 | ++ | end |
+
| 28 | ++ | end |
+
| 29 | ++ | |
+
| 30 | ++ | defmodule CodeReviewResponse do |
+
| 31 | ++ | @moduledoc "Structured code review response from LLM" |
+
| 32 | ++ | use Ecto.Schema |
+
| 33 | ++ | import Ecto.Changeset |
+
| 34 | ++ | |
+
| 35 | ++ | @primary_key false |
+
| 36 | ++ | embedded_schema do |
+
| 37 | ++ | field(:score, :integer) |
+
| 38 | ++ | field(:summary, :string) |
+
| 39 | ++ | field(:issues, {:array, :map}) |
+
| 40 | ++ | field(:suggestions, {:array, :string}) |
+
| 41 | ++ | field(:resources, {:array, :string}) |
+
| 42 | ++ | end |
+
| 43 | ++ | |
+
| 44 | ++ | def changeset(review, attrs) do |
+
| 45 | ++ | review |
+
| 46 | ++ | |> cast(attrs, [:score, :summary, :issues, :suggestions, :resources]) |
+
| 47 | ++ | |> validate_required([:score, :summary]) |
+
| 48 | ++ | |> validate_number(:score, greater_than_or_equal_to: 0, less_than_or_equal_to: 100) |
+
| 49 | ++ | end |
+
| 50 | ++ | end |
+
| 51 | ++ | |
+
| 52 | ++ | defmodule StudyResponse do |
+
| 53 | ++ | @moduledoc "Structured study/Q&A response from LLM" |
+
| 54 | ++ | use Ecto.Schema |
+
| 55 | ++ | import Ecto.Changeset |
+
| 56 | ++ | |
+
| 57 | ++ | @primary_key false |
+
| 58 | +67 | + embedded_schema do |
+
| 59 | ++ | field(:answer, :string) |
+
| 60 | ++ | field(:concepts, {:array, :string}) |
+
| 61 | ++ | field(:resources, {:array, :string}) |
+
| 62 | ++ | field(:follow_ups, {:array, :string}) |
+
| 63 | ++ | end |
+
| 64 | ++ | |
+
| 65 | ++ | def changeset(response, attrs) do |
+
| 66 | ++ | response |
+
| 67 | ++ | |> cast(attrs, [:answer, :concepts, :resources, :follow_ups]) |
+
| 68 | +2 | + |> validate_required([:answer]) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| 71 | ++ | |
+
| 72 | ++ | defmodule ProgressRecommendation do |
+
| 73 | ++ | @moduledoc "A single progress recommendation" |
+
| 74 | ++ | use Ecto.Schema |
+
| 75 | ++ | import Ecto.Changeset |
+
| 76 | ++ | |
+
| 77 | ++ | @primary_key false |
+
| 78 | ++ | embedded_schema do |
+
| 79 | ++ | field(:priority, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 80 | ++ | field(:type, Ecto.Enum, |
+
| 81 | ++ | values: [:progress, :review, :encouragement, :start, :challenge] |
+
| 82 | ++ | ) |
+
| 83 | ++ | |
+
| 84 | ++ | field(:message, :string) |
+
| 85 | ++ | field(:action, :string) |
+
| 86 | ++ | end |
+
| 87 | ++ | |
+
| 88 | ++ | def changeset(rec, attrs) do |
+
| 89 | ++ | rec |
+
| 90 | ++ | |> cast(attrs, [:priority, :type, :message, :action]) |
+
| 91 | ++ | |> validate_required([:priority, :type, :message, :action]) |
+
| 92 | ++ | end |
+
| 93 | ++ | end |
+
| 94 | ++ | |
+
| 95 | ++ | defmodule ProgressAnalysis do |
+
| 96 | ++ | @moduledoc "Structured progress coaching response from LLM" |
+
| 97 | ++ | use Ecto.Schema |
+
| 98 | ++ | import Ecto.Changeset |
+
| 99 | ++ | |
+
| 100 | ++ | @primary_key false |
+
| 101 | ++ | embedded_schema do |
+
| 102 | ++ | field(:recommendations, {:array, :map}) |
+
| 103 | ++ | field(:strengths, {:array, :string}) |
+
| 104 | ++ | field(:challenges, {:array, :string}) |
+
| 105 | ++ | field(:next_phase_suggestion, :string) |
+
| 106 | ++ | end |
+
| 107 | ++ | |
+
| 108 | ++ | def changeset(analysis, attrs) do |
+
| 109 | ++ | analysis |
+
| 110 | ++ | |> cast(attrs, [:recommendations, :strengths, :challenges, :next_phase_suggestion]) |
+
| 111 | ++ | |> validate_required([:recommendations]) |
+
| 112 | ++ | end |
+
| 113 | ++ | end |
+
| 114 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.Schemas.html| 1 | ++ | defmodule LabsJidoAgent.Schemas do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Ecto schemas for structured LLM responses. |
+
| 4 | ++ | |
+
| 5 | ++ | These schemas define the expected structure of LLM outputs, |
+
| 6 | ++ | enabling validation and type safety via Instructor. |
+
| 7 | ++ | """ |
+
| 8 | ++ | |
+
| 9 | ++ | defmodule CodeIssue do |
+
| 10 | ++ | @moduledoc "Represents a code quality issue" |
+
| 11 | ++ | use Ecto.Schema |
+
| 12 | ++ | import Ecto.Changeset |
+
| 13 | ++ | |
+
| 14 | ++ | @primary_key false |
+
| 15 | ++ | embedded_schema do |
+
| 16 | ++ | field(:type, Ecto.Enum, values: [:quality, :performance, :idioms, :security]) |
+
| 17 | ++ | field(:severity, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 18 | ++ | field(:line, :integer) |
+
| 19 | ++ | field(:message, :string) |
+
| 20 | ++ | field(:suggestion, :string) |
+
| 21 | ++ | end |
+
| 22 | ++ | |
+
| 23 | ++ | def changeset(issue, attrs) do |
+
| 24 | ++ | issue |
+
| 25 | ++ | |> cast(attrs, [:type, :severity, :line, :message, :suggestion]) |
+
| 26 | ++ | |> validate_required([:type, :severity, :message, :suggestion]) |
+
| 27 | ++ | end |
+
| 28 | ++ | end |
+
| 29 | ++ | |
+
| 30 | ++ | defmodule CodeReviewResponse do |
+
| 31 | ++ | @moduledoc "Structured code review response from LLM" |
+
| 32 | ++ | use Ecto.Schema |
+
| 33 | ++ | import Ecto.Changeset |
+
| 34 | ++ | |
+
| 35 | ++ | @primary_key false |
+
| 36 | ++ | embedded_schema do |
+
| 37 | ++ | field(:score, :integer) |
+
| 38 | ++ | field(:summary, :string) |
+
| 39 | ++ | field(:issues, {:array, :map}) |
+
| 40 | ++ | field(:suggestions, {:array, :string}) |
+
| 41 | ++ | field(:resources, {:array, :string}) |
+
| 42 | ++ | end |
+
| 43 | ++ | |
+
| 44 | ++ | def changeset(review, attrs) do |
+
| 45 | ++ | review |
+
| 46 | ++ | |> cast(attrs, [:score, :summary, :issues, :suggestions, :resources]) |
+
| 47 | ++ | |> validate_required([:score, :summary]) |
+
| 48 | ++ | |> validate_number(:score, greater_than_or_equal_to: 0, less_than_or_equal_to: 100) |
+
| 49 | ++ | end |
+
| 50 | ++ | end |
+
| 51 | ++ | |
+
| 52 | ++ | defmodule StudyResponse do |
+
| 53 | ++ | @moduledoc "Structured study/Q&A response from LLM" |
+
| 54 | ++ | use Ecto.Schema |
+
| 55 | ++ | import Ecto.Changeset |
+
| 56 | ++ | |
+
| 57 | ++ | @primary_key false |
+
| 58 | ++ | embedded_schema do |
+
| 59 | ++ | field(:answer, :string) |
+
| 60 | ++ | field(:concepts, {:array, :string}) |
+
| 61 | ++ | field(:resources, {:array, :string}) |
+
| 62 | ++ | field(:follow_ups, {:array, :string}) |
+
| 63 | ++ | end |
+
| 64 | ++ | |
+
| 65 | ++ | def changeset(response, attrs) do |
+
| 66 | ++ | response |
+
| 67 | ++ | |> cast(attrs, [:answer, :concepts, :resources, :follow_ups]) |
+
| 68 | ++ | |> validate_required([:answer]) |
+
| 69 | ++ | end |
+
| 70 | ++ | end |
+
| 71 | ++ | |
+
| 72 | ++ | defmodule ProgressRecommendation do |
+
| 73 | ++ | @moduledoc "A single progress recommendation" |
+
| 74 | ++ | use Ecto.Schema |
+
| 75 | ++ | import Ecto.Changeset |
+
| 76 | ++ | |
+
| 77 | ++ | @primary_key false |
+
| 78 | ++ | embedded_schema do |
+
| 79 | ++ | field(:priority, Ecto.Enum, values: [:critical, :high, :medium, :low]) |
+
| 80 | ++ | field(:type, Ecto.Enum, |
+
| 81 | ++ | values: [:progress, :review, :encouragement, :start, :challenge] |
+
| 82 | ++ | ) |
+
| 83 | ++ | |
+
| 84 | ++ | field(:message, :string) |
+
| 85 | ++ | field(:action, :string) |
+
| 86 | ++ | end |
+
| 87 | ++ | |
+
| 88 | ++ | def changeset(rec, attrs) do |
+
| 89 | ++ | rec |
+
| 90 | ++ | |> cast(attrs, [:priority, :type, :message, :action]) |
+
| 91 | ++ | |> validate_required([:priority, :type, :message, :action]) |
+
| 92 | ++ | end |
+
| 93 | ++ | end |
+
| 94 | ++ | |
+
| 95 | ++ | defmodule ProgressAnalysis do |
+
| 96 | ++ | @moduledoc "Structured progress coaching response from LLM" |
+
| 97 | ++ | use Ecto.Schema |
+
| 98 | ++ | import Ecto.Changeset |
+
| 99 | ++ | |
+
| 100 | ++ | @primary_key false |
+
| 101 | ++ | embedded_schema do |
+
| 102 | ++ | field(:recommendations, {:array, :map}) |
+
| 103 | ++ | field(:strengths, {:array, :string}) |
+
| 104 | ++ | field(:challenges, {:array, :string}) |
+
| 105 | ++ | field(:next_phase_suggestion, :string) |
+
| 106 | ++ | end |
+
| 107 | ++ | |
+
| 108 | ++ | def changeset(analysis, attrs) do |
+
| 109 | ++ | analysis |
+
| 110 | ++ | |> cast(attrs, [:recommendations, :strengths, :challenges, :next_phase_suggestion]) |
+
| 111 | ++ | |> validate_required([:recommendations]) |
+
| 112 | ++ | end |
+
| 113 | ++ | end |
+
| 114 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.StudyBuddyAction.html| 1 | ++ | defmodule LabsJidoAgent.StudyBuddyAction do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | A Jido Action that answers questions about Elixir concepts. |
+
| 4 | ++ | |
+
| 5 | ++ | This action provides three response modes: |
+
| 6 | ++ | - `:explain` - Direct explanations with theory and examples |
+
| 7 | ++ | - `:socratic` - Guides learning through questions |
+
| 8 | ++ | - `:example` - Provides runnable code examples |
+
| 9 | ++ | |
+
| 10 | ++ | ## Examples |
+
| 11 | ++ | |
+
| 12 | ++ | params = %{question: "What is tail recursion?", phase: 1, mode: :explain} |
+
| 13 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAction.run(params, %{}) |
+
| 14 | ++ | """ |
+
| 15 | ++ | |
+
| 16 | ++ | use Jido.Action, |
+
| 17 | ++ | name: "study_buddy", |
+
| 18 | ++ | description: "Answers questions about Elixir concepts and guides learning", |
+
| 19 | ++ | category: "education", |
+
| 20 | ++ | tags: ["qa", "elixir", "learning", "llm"], |
+
| 21 | ++ | schema: [ |
+
| 22 | ++ | question: [type: :string, required: true, doc: "The student's question"], |
+
| 23 | ++ | phase: [type: :integer, default: 1, doc: "Current learning phase"], |
+
| 24 | ++ | mode: [ |
+
| 25 | ++ | type: {:in, [:explain, :socratic, :example]}, |
+
| 26 | ++ | default: :explain, |
+
| 27 | ++ | doc: "Response mode" |
+
| 28 | ++ | ], |
+
| 29 | ++ | use_llm: [type: :boolean, default: true, doc: "Use LLM if available"] |
+
| 30 | ++ | ] |
+
| 31 | ++ | |
+
| 32 | ++ | alias LabsJidoAgent.{LLM, Schemas} |
+
| 33 | ++ | |
+
| 34 | ++ | @impl true |
+
| 35 | ++ | def run(params, _context) do |
+
| 36 | +14 | + question = params.question |
+
| 37 | +14 | + phase = params.phase |
+
| 38 | +14 | + mode = params.mode |
+
| 39 | +14 | + use_llm = params.use_llm |
+
| 40 | ++ | |
+
| 41 | +14 | + if use_llm and LLM.available?() do |
+
| 42 | +7 | + llm_answer(question, phase, mode) |
+
| 43 | ++ | else |
+
| 44 | +7 | + simulated_answer(question, phase, mode) |
+
| 45 | ++ | end |
+
| 46 | ++ | end |
+
| 47 | ++ | |
+
| 48 | ++ | # LLM-powered Q&A |
+
| 49 | ++ | defp llm_answer(question, phase, mode) do |
+
| 50 | +7 | + prompt = build_study_prompt(question, phase, mode) |
+
| 51 | ++ | |
+
| 52 | +7 | + case LLM.chat_structured(prompt, |
+
| 53 | ++ | response_model: Schemas.StudyResponse, |
+
| 54 | ++ | model: :balanced, |
+
| 55 | ++ | temperature: 0.7 |
+
| 56 | ++ | ) do |
+
| 57 | +:-( |
+ {:ok, %Schemas.StudyResponse{} = response} -> |
+
| 58 | ++ | {:ok, |
+
| 59 | ++ | %{ |
+
| 60 | +:-( |
+ answer: response.answer, |
+
| 61 | +:-( |
+ concepts: response.concepts || [], |
+
| 62 | +:-( |
+ resources: response.resources || [], |
+
| 63 | +:-( |
+ follow_ups: response.follow_ups || [], |
+
| 64 | ++ | llm_powered: true |
+
| 65 | ++ | }} |
+
| 66 | ++ | |
+
| 67 | ++ | {:error, reason} -> |
+
| 68 | +7 | + IO.warn("LLM answer failed: #{inspect(reason)}, falling back to simulated") |
+
| 69 | +7 | + simulated_answer(question, phase, mode) |
+
| 70 | ++ | end |
+
| 71 | ++ | end |
+
| 72 | ++ | |
+
| 73 | ++ | defp build_study_prompt(question, phase, mode) do |
+
| 74 | +7 | + mode_instruction = |
+
| 75 | ++ | case mode do |
+
| 76 | +5 | + :explain -> |
+
| 77 | ++ | "Provide a clear, direct explanation with examples." |
+
| 78 | ++ | |
+
| 79 | +1 | + :socratic -> |
+
| 80 | ++ | "Guide learning through thoughtful questions. Help the student discover the answer." |
+
| 81 | ++ | |
+
| 82 | +1 | + :example -> |
+
| 83 | ++ | "Provide working code examples with explanations." |
+
| 84 | ++ | end |
+
| 85 | ++ | |
+
| 86 | +7 | + """ |
+
| 87 | +7 | + You are a helpful Elixir programming tutor for a student in Phase #{phase} of learning. |
+
| 88 | ++ | |
+
| 89 | +7 | + Student's question: #{question} |
+
| 90 | ++ | |
+
| 91 | +7 | + Response mode: #{mode_instruction} |
+
| 92 | ++ | |
+
| 93 | ++ | Provide: |
+
| 94 | ++ | 1. A helpful answer appropriate for their learning phase |
+
| 95 | ++ | 2. Key concepts involved (as a list) |
+
| 96 | ++ | 3. Relevant learning resources |
+
| 97 | ++ | 4. Follow-up questions or topics to explore next |
+
| 98 | ++ | |
+
| 99 | +7 | + Be encouraging and educational. Keep explanations clear and appropriate for Phase #{phase}. |
+
| 100 | ++ | """ |
+
| 101 | ++ | end |
+
| 102 | ++ | |
+
| 103 | ++ | # Simulated Q&A (fallback) |
+
| 104 | ++ | defp simulated_answer(question, phase, mode) do |
+
| 105 | ++ | # Determine what concepts are involved |
+
| 106 | +14 | + concepts = extract_concepts(question) |
+
| 107 | ++ | |
+
| 108 | ++ | # Find relevant resources |
+
| 109 | +14 | + resources = find_resources(concepts, phase) |
+
| 110 | ++ | |
+
| 111 | ++ | # Generate response based on mode |
+
| 112 | +14 | + answer = |
+
| 113 | ++ | case mode do |
+
| 114 | +10 | + :explain -> generate_explanation(concepts, question) |
+
| 115 | +2 | + :socratic -> generate_socratic_questions(concepts, question) |
+
| 116 | +2 | + :example -> generate_examples(concepts, question) |
+
| 117 | ++ | end |
+
| 118 | ++ | |
+
| 119 | +14 | + response = %{ |
+
| 120 | ++ | answer: answer, |
+
| 121 | ++ | concepts: concepts, |
+
| 122 | ++ | resources: resources, |
+
| 123 | ++ | follow_ups: generate_follow_ups(concepts, phase), |
+
| 124 | ++ | llm_powered: false |
+
| 125 | ++ | } |
+
| 126 | ++ | |
+
| 127 | ++ | {:ok, response} |
+
| 128 | ++ | end |
+
| 129 | ++ | |
+
| 130 | ++ | # Private functions |
+
| 131 | ++ | |
+
| 132 | ++ | defp extract_concepts(question) do |
+
| 133 | +14 | + question_lower = String.downcase(question) |
+
| 134 | +14 | + concepts = [] |
+
| 135 | ++ | |
+
| 136 | +14 | + concepts = |
+
| 137 | +5 | + if String.contains?(question_lower, ["recursion", "recursive"]) do |
+
| 138 | ++ | [:recursion | concepts] |
+
| 139 | ++ | else |
+
| 140 | +9 | + concepts |
+
| 141 | ++ | end |
+
| 142 | ++ | |
+
| 143 | +14 | + concepts = |
+
| 144 | +3 | + if String.contains?(question_lower, ["tail", "tail-call", "tco"]) do |
+
| 145 | ++ | [:tail_call_optimization | concepts] |
+
| 146 | ++ | else |
+
| 147 | +11 | + concepts |
+
| 148 | ++ | end |
+
| 149 | ++ | |
+
| 150 | +14 | + concepts = |
+
| 151 | +4 | + if String.contains?(question_lower, ["pattern", "match"]) do |
+
| 152 | ++ | [:pattern_matching | concepts] |
+
| 153 | ++ | else |
+
| 154 | +10 | + concepts |
+
| 155 | ++ | end |
+
| 156 | ++ | |
+
| 157 | +14 | + concepts = |
+
| 158 | +2 | + if String.contains?(question_lower, ["genserver", "gen_server"]) do |
+
| 159 | ++ | [:genserver | concepts] |
+
| 160 | ++ | else |
+
| 161 | +12 | + concepts |
+
| 162 | ++ | end |
+
| 163 | ++ | |
+
| 164 | +14 | + concepts = |
+
| 165 | +1 | + if String.contains?(question_lower, ["process", "spawn"]) do |
+
| 166 | ++ | [:processes | concepts] |
+
| 167 | ++ | else |
+
| 168 | +13 | + concepts |
+
| 169 | ++ | end |
+
| 170 | ++ | |
+
| 171 | +14 | + if concepts == [], do: [:general], else: concepts |
+
| 172 | ++ | end |
+
| 173 | ++ | |
+
| 174 | ++ | defp find_resources(concepts, phase) do |
+
| 175 | ++ | Enum.flat_map(concepts, fn concept -> |
+
| 176 | +17 | + get_resources_for_concept(concept, phase) |
+
| 177 | ++ | end) |
+
| 178 | +14 | + |> Enum.uniq() |
+
| 179 | ++ | end |
+
| 180 | ++ | |
+
| 181 | +5 | + defp get_resources_for_concept(:recursion, _phase) do |
+
| 182 | ++ | [ |
+
| 183 | ++ | "Livebook: phase-01-core/02-recursion.livemd", |
+
| 184 | ++ | "Official Elixir Guide: Recursion" |
+
| 185 | ++ | ] |
+
| 186 | ++ | end |
+
| 187 | ++ | |
+
| 188 | +4 | + defp get_resources_for_concept(:pattern_matching, _phase) do |
+
| 189 | ++ | [ |
+
| 190 | ++ | "Livebook: phase-01-core/01-pattern-matching.livemd", |
+
| 191 | ++ | "Official Elixir Guide: Pattern Matching" |
+
| 192 | ++ | ] |
+
| 193 | ++ | end |
+
| 194 | ++ | |
+
| 195 | +1 | + defp get_resources_for_concept(:genserver, phase) when phase >= 3 do |
+
| 196 | ++ | [ |
+
| 197 | ++ | "Livebook: phase-03-genserver/01-genserver-basics.livemd", |
+
| 198 | ++ | "Official Elixir docs: GenServer" |
+
| 199 | ++ | ] |
+
| 200 | ++ | end |
+
| 201 | ++ | |
+
| 202 | +1 | + defp get_resources_for_concept(:genserver, _phase) do |
+
| 203 | ++ | ["GenServer is covered in Phase 3"] |
+
| 204 | ++ | end |
+
| 205 | ++ | |
+
| 206 | +6 | + defp get_resources_for_concept(_, _), do: [] |
+
| 207 | ++ | |
+
| 208 | ++ | defp generate_explanation(concepts, _question) do |
+
| 209 | +14 | + case List.first(concepts) do |
+
| 210 | +2 | + :recursion -> |
+
| 211 | ++ | """ |
+
| 212 | ++ | **Recursion in Elixir** |
+
| 213 | ++ | |
+
| 214 | ++ | Recursion is when a function calls itself. In Elixir, it's fundamental for processing lists. |
+
| 215 | ++ | |
+
| 216 | ++ | **Key Concepts:** |
+
| 217 | ++ | 1. **Base case** - Stops recursion |
+
| 218 | ++ | 2. **Recursive case** - Calls itself with modified arguments |
+
| 219 | ++ | |
+
| 220 | ++ | **Example:** |
+
| 221 | ++ | ```elixir |
+
| 222 | ++ | def sum([]), do: 0 |
+
| 223 | ++ | def sum([h | t]), do: h + sum(t) |
+
| 224 | ++ | ``` |
+
| 225 | ++ | |
+
| 226 | ++ | **Important**: For large lists, use tail-call optimization with an accumulator. |
+
| 227 | ++ | """ |
+
| 228 | ++ | |
+
| 229 | +3 | + :tail_call_optimization -> |
+
| 230 | ++ | """ |
+
| 231 | ++ | **Tail-Call Optimization (TCO)** |
+
| 232 | ++ | |
+
| 233 | ++ | A tail-recursive function has the recursive call as the LAST operation. |
+
| 234 | ++ | |
+
| 235 | ++ | **Non-tail-recursive** (builds up stack): |
+
| 236 | ++ | ```elixir |
+
| 237 | ++ | def sum([]), do: 0 |
+
| 238 | ++ | def sum([h | t]), do: h + sum(t) # Addition happens AFTER |
+
| 239 | ++ | ``` |
+
| 240 | ++ | |
+
| 241 | ++ | **Tail-recursive** (constant stack): |
+
| 242 | ++ | ```elixir |
+
| 243 | ++ | def sum(list), do: sum(list, 0) |
+
| 244 | ++ | defp sum([], acc), do: acc |
+
| 245 | ++ | defp sum([h | t], acc), do: sum(t, acc + h) # Call is LAST |
+
| 246 | ++ | ``` |
+
| 247 | ++ | """ |
+
| 248 | ++ | |
+
| 249 | +4 | + :pattern_matching -> |
+
| 250 | ++ | """ |
+
| 251 | ++ | **Pattern Matching** |
+
| 252 | ++ | |
+
| 253 | ++ | The `=` operator matches left to right in Elixir. |
+
| 254 | ++ | |
+
| 255 | ++ | **Examples:** |
+
| 256 | ++ | - `{:ok, value} = {:ok, 42}` |
+
| 257 | ++ | - `[head | tail] = [1, 2, 3]` |
+
| 258 | ++ | - `%{name: n} = %{name: "Alice", age: 30}` |
+
| 259 | ++ | |
+
| 260 | ++ | Pattern matching in functions: |
+
| 261 | ++ | ```elixir |
+
| 262 | ++ | def greet({:ok, name}), do: "Hello, \#{name}!" |
+
| 263 | ++ | def greet({:error, _}), do: "Error!" |
+
| 264 | ++ | ``` |
+
| 265 | ++ | """ |
+
| 266 | ++ | |
+
| 267 | +5 | + _ -> |
+
| 268 | ++ | """ |
+
| 269 | ++ | I can help you learn about Elixir! Try asking about: |
+
| 270 | ++ | - Pattern matching |
+
| 271 | ++ | - Recursion and tail-call optimization |
+
| 272 | ++ | - Processes and message passing |
+
| 273 | ++ | - GenServer and OTP |
+
| 274 | ++ | """ |
+
| 275 | ++ | end |
+
| 276 | ++ | end |
+
| 277 | ++ | |
+
| 278 | ++ | defp generate_socratic_questions(concepts, question) do |
+
| 279 | +2 | + case List.first(concepts) do |
+
| 280 | +:-( |
+ :recursion -> |
+
| 281 | ++ | """ |
+
| 282 | ++ | Let's explore recursion together: |
+
| 283 | ++ | |
+
| 284 | ++ | 1. What happens to the call stack when you call a function recursively? |
+
| 285 | ++ | 2. In `def sum([h | t]), do: h + sum(t)`, what operation happens AFTER the recursive call? |
+
| 286 | ++ | 3. How could you modify this so the recursive call is the last operation? |
+
| 287 | ++ | 4. What role does an accumulator play in tail recursion? |
+
| 288 | ++ | |
+
| 289 | ++ | Think about these, then check the resources below. |
+
| 290 | ++ | """ |
+
| 291 | ++ | |
+
| 292 | ++ | _ -> |
+
| 293 | +2 | + generate_explanation(concepts, question) |
+
| 294 | ++ | end |
+
| 295 | ++ | end |
+
| 296 | ++ | |
+
| 297 | ++ | defp generate_examples(concepts, question) do |
+
| 298 | +2 | + case List.first(concepts) do |
+
| 299 | +:-( |
+ :recursion -> |
+
| 300 | ++ | """ |
+
| 301 | ++ | **Recursion Examples** |
+
| 302 | ++ | |
+
| 303 | ++ | **List Length:** |
+
| 304 | ++ | ```elixir |
+
| 305 | ++ | # Tail-recursive |
+
| 306 | ++ | def length(list), do: length(list, 0) |
+
| 307 | ++ | defp length([], acc), do: acc |
+
| 308 | ++ | defp length([_ | t], acc), do: length(t, acc + 1) |
+
| 309 | ++ | ``` |
+
| 310 | ++ | |
+
| 311 | ++ | **Map Implementation:** |
+
| 312 | ++ | ```elixir |
+
| 313 | ++ | def map(list, func), do: map(list, func, []) |
+
| 314 | ++ | |
+
| 315 | ++ | defp map([], _func, acc), do: Enum.reverse(acc) |
+
| 316 | ++ | defp map([h | t], func, acc), do: map(t, func, [func.(h) | acc]) |
+
| 317 | ++ | ``` |
+
| 318 | ++ | """ |
+
| 319 | ++ | |
+
| 320 | ++ | _ -> |
+
| 321 | +2 | + generate_explanation(concepts, question) |
+
| 322 | ++ | end |
+
| 323 | ++ | end |
+
| 324 | ++ | |
+
| 325 | ++ | defp generate_follow_ups(concepts, _phase) do |
+
| 326 | +14 | + base_suggestions = [ |
+
| 327 | ++ | "Try the interactive exercises in Livebook" |
+
| 328 | ++ | ] |
+
| 329 | ++ | |
+
| 330 | +14 | + concept_suggestions = |
+
| 331 | ++ | Enum.flat_map(concepts, fn concept -> |
+
| 332 | +17 | + case concept do |
+
| 333 | +5 | + :recursion -> ["Next: Learn about Enum vs Stream"] |
+
| 334 | +4 | + :pattern_matching -> ["Next: Learn about guards"] |
+
| 335 | +8 | + _ -> [] |
+
| 336 | ++ | end |
+
| 337 | ++ | end) |
+
| 338 | ++ | |
+
| 339 | +14 | + base_suggestions ++ concept_suggestions |
+
| 340 | ++ | end |
+
| 341 | ++ | |
+
| 342 | ++ | ## Public Helper API |
+
| 343 | ++ | |
+
| 344 | ++ | @doc """ |
+
| 345 | ++ | Ask a question (convenience wrapper). |
+
| 346 | ++ | |
+
| 347 | ++ | ## Examples |
+
| 348 | ++ | |
+
| 349 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAction.ask("What is recursion?") |
+
| 350 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAction.ask("How do I use GenServer?", |
+
| 351 | ++ | phase: 3, mode: :example) |
+
| 352 | ++ | """ |
+
| 353 | +:-( |
+ def ask(question, opts \\ []) do |
+
| 354 | +:-( |
+ params = %{ |
+
| 355 | ++ | question: question, |
+
| 356 | ++ | phase: Keyword.get(opts, :phase, 1), |
+
| 357 | ++ | mode: Keyword.get(opts, :mode, :explain), |
+
| 358 | ++ | use_llm: Keyword.get(opts, :use_llm, true) |
+
| 359 | ++ | } |
+
| 360 | ++ | |
+
| 361 | +:-( |
+ run(params, %{}) |
+
| 362 | ++ | end |
+
| 363 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.StudyBuddyAgent.html| 1 | ++ | defmodule LabsJidoAgent.StudyBuddyAgent do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | An Agent that answers questions about Elixir concepts using StudyBuddyAction. |
+
| 4 | ++ | |
+
| 5 | ++ | Provides three response modes: |
+
| 6 | ++ | - `:explain` - Direct explanations |
+
| 7 | ++ | - `:socratic` - Guided learning through questions |
+
| 8 | ++ | - `:example` - Code examples |
+
| 9 | ++ | |
+
| 10 | ++ | ## Examples |
+
| 11 | ++ | |
+
| 12 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAgent.ask("What is tail recursion?") |
+
| 13 | ++ | IO.puts(response.answer) |
+
| 14 | ++ | |
+
| 15 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAgent.ask("How do I use GenServer?", |
+
| 16 | ++ | phase: 3, mode: :example) |
+
| 17 | ++ | """ |
+
| 18 | ++ | |
+
| 19 | +:-( |
+ use Jido.Agent, |
+
| 20 | ++ | name: "study_buddy_agent", |
+
| 21 | ++ | description: "Answers questions about Elixir concepts and guides learning", |
+
| 22 | ++ | category: "education", |
+
| 23 | ++ | tags: ["qa", "learning"], |
+
| 24 | ++ | schema: [ |
+
| 25 | ++ | question: [type: :string, doc: "The student's question"], |
+
| 26 | ++ | phase: [type: :integer, default: 1, doc: "Current learning phase"], |
+
| 27 | ++ | mode: [ |
+
| 28 | ++ | type: {:in, [:explain, :socratic, :example]}, |
+
| 29 | ++ | default: :explain, |
+
| 30 | ++ | doc: "Response mode" |
+
| 31 | ++ | ] |
+
| 32 | ++ | ], |
+
| 33 | ++ | actions: [LabsJidoAgent.StudyBuddyAction] |
+
| 34 | ++ | |
+
| 35 | ++ | @doc """ |
+
| 36 | ++ | Ask a question and get an explanation (convenience wrapper). |
+
| 37 | ++ | |
+
| 38 | ++ | ## Options |
+
| 39 | ++ | * `:phase` - Current learning phase (1-15) |
+
| 40 | ++ | * `:mode` - Response mode (`:explain`, `:socratic`, `:example`) |
+
| 41 | ++ | |
+
| 42 | ++ | ## Examples |
+
| 43 | ++ | |
+
| 44 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAgent.ask("What is recursion?") |
+
| 45 | ++ | {:ok, response} = LabsJidoAgent.StudyBuddyAgent.ask("How do I use GenServer?", |
+
| 46 | ++ | phase: 3, mode: :example) |
+
| 47 | ++ | """ |
+
| 48 | +4 | + def ask(question, opts \\ []) do |
+
| 49 | +7 | + phase = Keyword.get(opts, :phase, 1) |
+
| 50 | +7 | + mode = Keyword.get(opts, :mode, :explain) |
+
| 51 | +7 | + use_llm = Keyword.get(opts, :use_llm, true) |
+
| 52 | ++ | |
+
| 53 | ++ | # Build params and call action directly for convenience |
+
| 54 | +7 | + params = %{question: question, phase: phase, mode: mode, use_llm: use_llm} |
+
| 55 | +7 | + LabsJidoAgent.StudyBuddyAction.run(params, %{}) |
+
| 56 | ++ | end |
+
| 57 | ++ | end |
+
| Line | +Hits | +Source | +
|---|
cover/Elixir.LabsJidoAgent.html| 1 | ++ | defmodule LabsJidoAgent do |
+
| 2 | ++ | @moduledoc """ |
+
| 3 | ++ | Educational lab demonstrating AI agent patterns using the Jido framework. |
+
| 4 | ++ | |
+
| 5 | ++ | This application provides three AI agents for learning assistance: |
+
| 6 | ++ | |
+
| 7 | ++ | - `LabsJidoAgent.CodeReviewAgent` - Reviews Elixir code for quality and idioms |
+
| 8 | ++ | - `LabsJidoAgent.StudyBuddyAgent` - Answers questions about Elixir concepts |
+
| 9 | ++ | - `LabsJidoAgent.ProgressCoachAgent` - Analyzes learning progress and provides guidance |
+
| 10 | ++ | |
+
| 11 | ++ | ## Quick Start |
+
| 12 | ++ | |
+
| 13 | ++ | # Review some code |
+
| 14 | ++ | {:ok, feedback} = LabsJidoAgent.CodeReviewAgent.review(code, phase: 1) |
+
| 15 | ++ | |
+
| 16 | ++ | # Ask a question |
+
| 17 | ++ | {:ok, answer} = LabsJidoAgent.StudyBuddyAgent.ask("What is tail recursion?") |
+
| 18 | ++ | |
+
| 19 | ++ | # Analyze progress |
+
| 20 | ++ | {:ok, advice} = LabsJidoAgent.ProgressCoachAgent.analyze_progress("student_123") |
+
| 21 | ++ | |
+
| 22 | ++ | See the README for full documentation and examples. |
+
| 23 | ++ | """ |
+
| 24 | ++ | |
+
| 25 | ++ | @doc """ |
+
| 26 | ++ | Returns the version of the labs_jido_agent application. |
+
| 27 | ++ | """ |
+
| 28 | ++ | def version do |
+
| 29 | +:-( |
+ Application.spec(:labs_jido_agent, :vsn) |> to_string() |
+
| 30 | ++ | end |
+
| 31 | ++ | end |
+
| Line | +Hits | +Source | +
|---|