トレーニング：PoC 構築ワークショップ — ゼロから72時間で動くものを作る

# db/migrate/002_create_tasks.rb
class CreateTasks < ActiveRecord::Migration[7.1]
  def change
    create_table :tasks do |t|
      t.references :project, null: false, foreign_key: true
      t.string :title, null: false
      t.text :description
      t.string :category
      t.integer :priority, default: 0
      t.string :status, default: "open"
      t.string :assigned_to
      t.date :due_date
      t.timestamps
    end
 
    add_index :tasks, %i[project_id status]
  end
end
 
# db/migrate/003_create_ai_suggestions.rb
class CreateAiSuggestions < ActiveRecord::Migration[7.1]
  def change
    create_table :ai_suggestions do |t|
      t.references :task, null: false, foreign_key: true
      t.string :suggestion_type, null: false
      t.jsonb :payload, default: {}
      t.float :confidence, default: 0.0
      t.string :status, default: "pending"
      t.datetime :accepted_at
      t.timestamps
    end
  end
end

# app/models/task.rb
class Task < ApplicationRecord
  belongs_to :project
  has_many :ai_suggestions, dependent: :destroy
 
  validates :title, presence: true
  enum :priority, { low: 0, medium: 1, high: 2, critical: 3 }
 
  scope :open_tasks, -> { where(status: "open") }
  scope :overdue, -> { where(status: "open").where("due_date < ?", Date.current) }
end
 
# app/models/ai_suggestion.rb
class AiSuggestion < ApplicationRecord
  belongs_to :task
  validates :suggestion_type, inclusion: { in: %w[classification priority risk_alert] }
 
  scope :pending, -> { where(status: "pending") }
 
  def accept!
    update!(status: "accepted", accepted_at: Time.current)
  end
end

# app/services/arclight_client.rb
class ArclightClient
  BASE_URL = ENV.fetch("ARCLIGHT_API_URL", "https://api.arclight.ai/v1")
 
  class ApiError < StandardError; end
  class RateLimitError < ApiError; end
 
  def initialize
    @api_key = ENV.fetch("ARCLIGHT_API_KEY")
    @conn = Faraday.new(url: BASE_URL) do |f|
      f.request :json
      f.response :json
      f.request :retry, max: 2, interval: 0.5
      f.options.timeout = 10
    end
  end
 
  def classify(text, categories:)
    request(:post, "/classify", { text: text, categories: categories, language: "ja" })
  end
 
  def suggest_priority(task_data)
    request(:post, "/analyze/priority", task_data)
  end
 
  def detect_risk(project_data)
    request(:post, "/analyze/risk", project_data)
  end
 
  private
 
  def request(method, path, body)
    response = @conn.send(method, path) do |req|
      req.headers["Authorization"] = "Bearer #{@api_key}"
      req.body = body
    end
 
    case response.status
    when 200..299 then response.body
    when 429 then raise RateLimitError, "レートリミット超過"
    else raise ApiError, "API エラー: #{response.status}"
    end
  rescue Faraday::TimeoutError
    raise ApiError, "Arclight API タイムアウト"
  end
end

# app/services/task_classifier.rb
class TaskClassifier
  CATEGORIES = %w[バグ修正 機能追加 改善 インフラ セキュリティ パフォーマンス リファクタリング ドキュメント].freeze
 
  def initialize(client: ArclightClient.new)
    @client = client
  end
 
  def classify(task)
    cache_key = "classify:#{task.id}:#{task.updated_at.to_i}"
 
    result = Rails.cache.fetch(cache_key, expires_in: 1.hour) do
      @client.classify("#{task.title} #{task.description}", categories: CATEGORIES)
    end
 
    task.ai_suggestions.create!(
      suggestion_type: "classification",
      payload: { category: result["category"], alternatives: result["alternatives"] },
      confidence: result["confidence"]
    )
  rescue ArclightClient::ApiError => e
    Rails.logger.error("[TaskClassifier] #{e.message}")
    nil
  end
end

# app/services/natural_language_task_creator.rb
class NaturalLanguageTaskCreator
  def initialize(client: ArclightClient.new)
    @client = client
  end
 
  def create(project:, natural_text:)
    parsed = @client.classify(natural_text, categories: ["task_parsing"])
 
    task = project.tasks.create!(
      title: parsed.dig("parsed", "title") || natural_text.truncate(100),
      description: parsed.dig("parsed", "description"),
      due_date: safe_parse_date(parsed.dig("parsed", "due_date"))
    )
 
    AiAnalysisJob.perform_later(task.id)
    task
  end
 
  private
 
  def safe_parse_date(str)
    str.present? ? Date.parse(str) : nil
  rescue Date::Error
    nil
  end
end

# app/jobs/ai_analysis_job.rb
class AiAnalysisJob < ApplicationJob
  queue_as :ai_analysis
  retry_on ArclightClient::RateLimitError, wait: 30.seconds, attempts: 3
 
  def perform(task_id)
    task = Task.find(task_id)
    TaskClassifier.new.classify(task)
 
    Turbo::StreamsChannel.broadcast_replace_to(
      "project_#{task.project_id}_tasks",
      target: "task_#{task.id}",
      partial: "tasks/task",
      locals: { task: task.reload }
    )
  end
end

# app/controllers/tasks_controller.rb
class TasksController < ApplicationController
  before_action :set_project
 
  def create
    @task = if params[:natural_text].present?
              NaturalLanguageTaskCreator.new.create(
                project: @project, natural_text: params[:natural_text]
              )
            else
              @project.tasks.create!(task_params).tap do |t|
                AiAnalysisJob.perform_later(t.id)
              end
            end
 
    respond_to do |format|
      format.turbo_stream
      format.html { redirect_to project_tasks_path(@project) }
    end
  end
 
  def accept_suggestion
    task = @project.tasks.find(params[:id])
    suggestion = task.ai_suggestions.find(params[:suggestion_id])
    suggestion.accept!
 
    case suggestion.suggestion_type
    when "classification"
      task.update!(category: suggestion.payload["category"])
    when "priority"
      task.update!(priority: suggestion.payload["suggested_priority"])
    end
 
    respond_to do |format|
      format.turbo_stream
      format.html { redirect_to project_task_path(@project, task) }
    end
  end
 
  private
 
  def set_project = @project = Project.find(params[:project_id])
  def task_params = params.require(:task).permit(:title, :description, :due_date)
end

# spec/services/task_classifier_spec.rb
RSpec.describe TaskClassifier do
  let(:client) { instance_double(ArclightClient) }
  let(:classifier) { described_class.new(client: client) }
  let(:task) { create(:task, title: "ログイン画面が表示されない") }
 
  context "API が正常にレスポンスを返す場合" do
    before do
      allow(client).to receive(:classify).and_return(
        { "category" => "バグ修正", "confidence" => 0.92, "alternatives" => [] }
      )
    end
 
    it "AiSuggestion を作成する" do
      expect { classifier.classify(task) }.to change { task.ai_suggestions.count }.by(1)
    end
 
    it "正しいカテゴリと confidence を保存する" do
      suggestion = classifier.classify(task)
      expect(suggestion.payload["category"]).to eq("バグ修正")
      expect(suggestion.confidence).to eq(0.92)
    end
  end
 
  context "API がエラーを返す場合" do
    before do
      allow(client).to receive(:classify)
        .and_raise(ArclightClient::ApiError, "Internal Server Error")
    end
 
    it "nil を返しクラッシュしない" do
      expect(classifier.classify(task)).to be_nil
    end
  end
end