coplan-engine 0.1.0

data/app/models/coplan/automated_plan_reviewer.rb

@@ -0,0 +1,62 @@
+module CoPlan
+  class AutomatedPlanReviewer < ApplicationRecord
+    ACTOR_TYPE = "cloud_persona"
+    AI_PROVIDERS = %w[openai anthropic].freeze
+
+    DEFAULT_REVIEWERS = [
+      { key: "security-reviewer", name: "Security Reviewer", prompt_file: "prompts/reviewers/security.md",
+        trigger_statuses: [ "considering" ], ai_model: "gpt-4o" },
+      { key: "scalability-reviewer", name: "Scalability Reviewer", prompt_file: "prompts/reviewers/scalability.md",
+        trigger_statuses: [ "considering", "developing" ], ai_model: "gpt-4o" },
+      { key: "routing-reviewer", name: "Routing Reviewer", prompt_file: "prompts/reviewers/routing.md",
+        trigger_statuses: [], ai_model: "gpt-4o" }
+    ].freeze
+
+    after_initialize { self.trigger_statuses ||= [] }
+
+    validates :key, presence: true,
+      format: { with: /\A[a-z0-9-]+\z/, message: "only allows lowercase letters, numbers, and hyphens" }
+    validates :key, uniqueness: true
+    validates :name, presence: true
+    validates :prompt_text, presence: true
+    validates :ai_provider, presence: true, inclusion: { in: AI_PROVIDERS }
+    validates :ai_model, presence: true
+    validate :validate_trigger_statuses
+
+    scope :enabled, -> { where(enabled: true) }
+
+    def self.create_defaults
+      DEFAULT_REVIEWERS.each do |template|
+        find_or_create_by!(key: template[:key]) do |r|
+          r.name = template[:name]
+          r.prompt_text = File.read(CoPlan::Engine.root.join(template[:prompt_file]))
+          r.trigger_statuses = template[:trigger_statuses]
+          r.ai_model = template[:ai_model]
+        end
+      end
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id key name enabled ai_provider ai_model created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[]
+    end
+
+    def triggers_on_status?(status)
+      trigger_statuses.include?(status.to_s)
+    end
+
+    private
+
+    def validate_trigger_statuses
+      return if trigger_statuses.blank?
+
+      invalid = trigger_statuses - Plan::STATUSES
+      if invalid.any?
+        errors.add(:trigger_statuses, "contains invalid status: #{invalid.join(', ')}. Valid statuses are: #{Plan::STATUSES.join(', ')}")
+      end
+    end
+  end
+end

data/app/models/coplan/comment.rb

@@ -0,0 +1,24 @@
+module CoPlan
+  class Comment < ApplicationRecord
+    AUTHOR_TYPES = %w[human local_agent cloud_persona system].freeze
+
+    belongs_to :comment_thread
+
+    validates :body_markdown, presence: true
+    validates :author_type, presence: true, inclusion: { in: AUTHOR_TYPES }
+    validates :agent_name, presence: { message: "is required for agent comments" }, if: -> { author_type == "local_agent" }
+    validates :agent_name, length: { maximum: 20 }, allow_nil: true
+
+    after_create_commit :notify_plan_author, if: :first_comment_in_thread?
+
+    private
+
+    def first_comment_in_thread?
+      self == comment_thread.comments.order(:created_at).first
+    end
+
+    def notify_plan_author
+      CoPlan::NotificationJob.perform_later("comment_created", { comment_thread_id: comment_thread_id })
+    end
+  end
+end

data/app/models/coplan/comment_thread.rb

@@ -0,0 +1,151 @@
+module CoPlan
+  class CommentThread < ApplicationRecord
+    STATUSES = %w[open resolved accepted dismissed].freeze
+
+    attr_accessor :anchor_occurrence
+
+    belongs_to :plan
+    belongs_to :plan_version
+    belongs_to :created_by_user, class_name: "CoPlan::User"
+    belongs_to :resolved_by_user, class_name: "CoPlan::User", optional: true
+    belongs_to :out_of_date_since_version, class_name: "PlanVersion", optional: true
+    belongs_to :addressed_in_plan_version, class_name: "PlanVersion", optional: true
+    has_many :comments, dependent: :destroy
+
+    validates :status, presence: true, inclusion: { in: STATUSES }
+
+    before_create :resolve_anchor_position
+
+    scope :open_threads, -> { where(status: "open") }
+    scope :current, -> { where(out_of_date: false) }
+    scope :active, -> { where(status: "open", out_of_date: false) }
+    scope :archived, -> { where("status != 'open' OR out_of_date = ?", true) }
+
+    # Transforms anchor positions through intervening version edits using OT.
+    # Threads without positional data (anchor_start/anchor_end/anchor_revision)
+    # are marked out-of-date unconditionally — all new threads resolve positions
+    # on creation via resolve_anchor_position.
+    def self.mark_out_of_date_for_new_version!(new_version)
+      threads = where(out_of_date: false).where.not(plan_version_id: new_version.id)
+      anchored_threads = threads.select(&:anchored?)
+
+      # Pre-fetch all versions that any thread might need (from the oldest
+      # anchor_revision to the new version) in a single query.
+      min_anchor_rev = anchored_threads
+        .filter_map { |t| t.anchor_revision if t.anchor_start.present? && t.anchor_end.present? && t.anchor_revision.present? }
+        .min
+
+      all_versions = if min_anchor_rev
+        new_version.plan.plan_versions
+          .where("revision > ? AND revision <= ?", min_anchor_rev, new_version.revision)
+          .order(revision: :asc)
+          .to_a
+      else
+        []
+      end
+
+      anchored_threads.each do |thread|
+        unless thread.anchor_start.present? && thread.anchor_end.present? && thread.anchor_revision.present?
+          thread.update_columns(out_of_date: true, out_of_date_since_version_id: new_version.id)
+          next
+        end
+
+        intervening = all_versions.select { |v| v.revision > thread.anchor_revision && v.revision <= new_version.revision }
+
+        begin
+          new_range = Plans::TransformRange.transform_through_versions(
+            [thread.anchor_start, thread.anchor_end],
+            intervening
+          )
+          thread.update_columns(
+            anchor_start: new_range[0],
+            anchor_end: new_range[1],
+            anchor_revision: new_version.revision
+          )
+        rescue Plans::TransformRange::Conflict
+          thread.update_columns(
+            out_of_date: true,
+            out_of_date_since_version_id: new_version.id
+          )
+        end
+      end
+    end
+
+    def anchored?
+      anchor_text.present?
+    end
+
+    def line_specific?
+      start_line.present?
+    end
+
+    def line_range_text
+      return nil unless line_specific?
+      start_line == end_line ? "Line #{start_line}" : "Lines #{start_line}–#{end_line}"
+    end
+
+    def anchor_preview(max_length: 80)
+      return nil unless anchored?
+      anchor_text.length > max_length ? "#{anchor_text[0...max_length]}…" : anchor_text
+    end
+
+    def resolve!(user)
+      update!(status: "resolved", resolved_by_user: user)
+    end
+
+    def accept!(user)
+      update!(status: "accepted", resolved_by_user: user)
+    end
+
+    def dismiss!(user)
+      update!(status: "dismissed", resolved_by_user: user)
+    end
+
+    def anchor_valid?
+      return true unless anchored?
+      !out_of_date
+    end
+
+    def anchor_context_with_highlight(chars: 100)
+      return nil unless anchored? && anchor_start.present?
+
+      content = plan.current_content
+      return nil unless content.present?
+
+      context_start = [anchor_start - chars, 0].max
+      context_end = [anchor_end + chars, content.length].min
+
+      before = content[context_start...anchor_start]
+      anchor = content[anchor_start...anchor_end]
+      after = content[anchor_end...context_end]
+
+      "#{before}**#{anchor}**#{after}"
+    end
+
+    private
+
+    def resolve_anchor_position
+      return unless anchor_text.present?
+
+      content = plan.current_content
+      return unless content.present?
+
+      occurrence = self.anchor_occurrence || 1
+      return if occurrence < 1
+
+      ranges = []
+      start_pos = 0
+      while (idx = content.index(anchor_text, start_pos))
+        ranges << [idx, idx + anchor_text.length]
+        start_pos = idx + anchor_text.length
+      end
+
+      if ranges.length >= occurrence
+        range = ranges[occurrence - 1]
+        self.anchor_start = range[0]
+        self.anchor_end = range[1]
+        self.anchor_revision = plan.current_revision
+      end
+    end
+  end
+end

data/app/models/coplan/current.rb

@@ -0,0 +1,5 @@
+module CoPlan
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :user
+  end
+end

data/app/models/coplan/edit_lease.rb

@@ -0,0 +1,57 @@
+module CoPlan
+  class EditLease < ApplicationRecord
+    HOLDER_TYPES = %w[local_agent cloud_persona system].freeze
+    LEASE_DURATION = 5.minutes
+
+    class Conflict < StandardError; end
+
+    belongs_to :plan
+
+    validates :holder_type, presence: true, inclusion: { in: HOLDER_TYPES }
+    validates :lease_token_digest, presence: true
+    validates :expires_at, presence: true
+    validates :last_heartbeat_at, presence: true
+
+    def self.acquire!(plan:, holder_type:, holder_id:, lease_token:)
+      digest = Digest::SHA256.hexdigest(lease_token)
+
+      ActiveRecord::Base.transaction do
+        lease = EditLease.lock.find_by(plan_id: plan.id)
+        if lease && lease.expires_at > Time.current && lease.lease_token_digest != digest
+          raise Conflict, "Plan is currently being edited by another agent"
+        end
+        lease ||= EditLease.new(plan_id: plan.id)
+        lease.update!(
+          holder_type: holder_type,
+          holder_id: holder_id,
+          lease_token_digest: digest,
+          expires_at: LEASE_DURATION.from_now,
+          last_heartbeat_at: Time.current
+        )
+        lease
+      end
+    end
+
+    def renew!(lease_token:)
+      digest = Digest::SHA256.hexdigest(lease_token)
+      raise Conflict, "Lease token mismatch" unless lease_token_digest == digest
+      update!(expires_at: LEASE_DURATION.from_now, last_heartbeat_at: Time.current)
+      self
+    end
+
+    def release!(lease_token:)
+      digest = Digest::SHA256.hexdigest(lease_token)
+      raise Conflict, "Lease token mismatch" unless lease_token_digest == digest
+      destroy!
+    end
+
+    def held?
+      expires_at > Time.current
+    end
+
+    def held_by?(lease_token:)
+      digest = Digest::SHA256.hexdigest(lease_token)
+      lease_token_digest == digest && held?
+    end
+  end
+end

data/app/models/coplan/edit_session.rb

@@ -0,0 +1,61 @@
+module CoPlan
+  class EditSession < ApplicationRecord
+    STATUSES = %w[open committed expired cancelled failed].freeze
+    ACTOR_TYPES = %w[human local_agent cloud_persona].freeze
+    LOCAL_AGENT_TTL = 10.minutes
+    CLOUD_PERSONA_TTL = 30.minutes
+
+    belongs_to :plan
+    belongs_to :plan_version, optional: true
+
+    after_initialize { self.operations_json ||= [] }
+    after_create :enqueue_expiry_job
+
+    validates :status, presence: true, inclusion: { in: STATUSES }
+    validates :actor_type, presence: true, inclusion: { in: ACTOR_TYPES }
+    validates :base_revision, presence: true
+    validates :expires_at, presence: true
+
+    scope :open_sessions, -> { where(status: "open") }
+    scope :expired_pending, -> { where(status: "open").where("expires_at < ?", Time.current) }
+
+    def open?
+      status == "open"
+    end
+
+    def active?
+      open? && (expires_at.nil? || expires_at > Time.current)
+    end
+
+    def committed?
+      status == "committed"
+    end
+
+    def expired?
+      open? && expires_at < Time.current
+    end
+
+    def has_operations?
+      operations_json.present? && operations_json.any?
+    end
+
+    def add_operation(op)
+      self.operations_json = operations_json + [op]
+      save!
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id status actor_type actor_id plan_id base_revision created_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[plan plan_version]
+    end
+
+    private
+
+    def enqueue_expiry_job
+      CommitExpiredSessionJob.set(wait_until: expires_at).perform_later(session_id: id)
+    end
+  end
+end

data/app/models/coplan/plan.rb

@@ -0,0 +1,28 @@
+module CoPlan
+  class Plan < ApplicationRecord
+    STATUSES = %w[brainstorm considering developing live abandoned].freeze
+
+    belongs_to :created_by_user, class_name: "CoPlan::User"
+    belongs_to :current_plan_version, class_name: "PlanVersion", optional: true
+    has_many :plan_versions, -> { order(revision: :asc) }, dependent: :destroy
+    has_many :plan_collaborators, dependent: :destroy
+    has_many :collaborators, through: :plan_collaborators, source: :user
+    has_many :comment_threads, dependent: :destroy
+    has_many :edit_sessions, dependent: :destroy
+    has_one :edit_lease, dependent: :destroy
+
+    after_initialize { self.tags ||= [] }
+    after_initialize { self.metadata ||= {} }
+
+    validates :title, presence: true
+    validates :status, presence: true, inclusion: { in: STATUSES }
+
+    def to_param
+      id
+    end
+
+    def current_content
+      current_plan_version&.content_markdown
+    end
+  end
+end

data/app/models/coplan/plan_collaborator.rb

@@ -0,0 +1,12 @@
+module CoPlan
+  class PlanCollaborator < ApplicationRecord
+    ROLES = %w[author reviewer viewer].freeze
+
+    belongs_to :plan
+    belongs_to :user, class_name: "CoPlan::User"
+    belongs_to :added_by_user, class_name: "CoPlan::User", optional: true
+
+    validates :role, presence: true, inclusion: { in: ROLES }
+    validates :user_id, uniqueness: { scope: :plan_id }
+  end
+end

data/app/models/coplan/plan_version.rb

@@ -0,0 +1,23 @@
+module CoPlan
+  class PlanVersion < ApplicationRecord
+    ACTOR_TYPES = %w[human local_agent cloud_persona system].freeze
+
+    belongs_to :plan
+    has_many :comment_threads, dependent: :nullify
+
+    after_initialize { self.operations_json ||= [] }
+
+    validates :revision, presence: true, uniqueness: { scope: :plan_id }
+    validates :content_markdown, presence: true
+    validates :content_sha256, presence: true
+    validates :actor_type, presence: true, inclusion: { in: ACTOR_TYPES }
+
+    before_validation :compute_sha256, if: -> { content_markdown.present? && content_sha256.blank? }
+
+    private
+
+    def compute_sha256
+      self.content_sha256 = Digest::SHA256.hexdigest(content_markdown)
+    end
+  end
+end

data/app/models/coplan/user.rb

@@ -0,0 +1,20 @@
+module CoPlan
+  class User < ApplicationRecord
+    has_many :api_tokens, dependent: :destroy
+    has_many :plan_collaborators, dependent: :destroy
+
+    validates :external_id, presence: true, uniqueness: true
+    validates :name, presence: true
+    validates :email, uniqueness: true, allow_nil: true
+
+    after_initialize { self.metadata ||= {} }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id external_id name email admin created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[api_tokens plan_collaborators]
+    end
+  end
+end

data/app/policies/coplan/application_policy.rb

@@ -0,0 +1,14 @@
+module CoPlan
+  class ApplicationPolicy
+    attr_reader :user, :record
+
+    def initialize(user, record)
+      @user = user
+      @record = record
+    end
+
+    def admin?
+      user.admin?
+    end
+  end
+end

data/app/policies/coplan/comment_thread_policy.rb

@@ -0,0 +1,23 @@
+module CoPlan
+  class CommentThreadPolicy < ApplicationPolicy
+    def create?
+      true
+    end
+
+    def resolve?
+      record.created_by_user_id == user.id || record.plan.created_by_user_id == user.id
+    end
+
+    def accept?
+      record.plan.created_by_user_id == user.id
+    end
+
+    def dismiss?
+      record.plan.created_by_user_id == user.id
+    end
+
+    def reopen?
+      record.created_by_user_id == user.id || record.plan.created_by_user_id == user.id
+    end
+  end
+end

data/app/policies/coplan/plan_policy.rb

@@ -0,0 +1,15 @@
+module CoPlan
+  class PlanPolicy < ApplicationPolicy
+    def show?
+      true
+    end
+
+    def update?
+      record.created_by_user_id == user.id
+    end
+
+    def update_status?
+      update?
+    end
+  end
+end

data/app/services/coplan/ai_providers/anthropic.rb

@@ -0,0 +1,21 @@
+module CoPlan
+  module AiProviders
+    class Anthropic
+      def self.call(system_prompt:, user_content:, model: "claude-sonnet-4-20250514")
+        new(system_prompt:, user_content:, model:).call
+      end
+
+      def initialize(system_prompt:, user_content:, model:)
+        @system_prompt = system_prompt
+        @user_content = user_content
+        @model = model
+      end
+
+      def call
+        raise Error, "Anthropic provider not yet implemented. Use OpenAI for now."
+      end
+
+      class Error < StandardError; end
+    end
+  end
+end

data/app/services/coplan/ai_providers/open_ai.rb

@@ -0,0 +1,44 @@
+module CoPlan
+  module AiProviders
+    class OpenAi
+      def self.call(system_prompt:, user_content:, model: "gpt-4o")
+        new(system_prompt:, user_content:, model:).call
+      end
+
+      def initialize(system_prompt:, user_content:, model:)
+        @system_prompt = system_prompt
+        @user_content = user_content
+        @model = model
+      end
+
+      def call
+        client = OpenAI::Client.new(access_token: api_key)
+
+        response = client.chat(
+          parameters: {
+            model: @model,
+            messages: [
+              { role: "system", content: @system_prompt },
+              { role: "user", content: @user_content }
+            ]
+          }
+        )
+
+        content = response.dig("choices", 0, "message", "content")
+        raise Error, "No response content from OpenAI" if content.blank?
+
+        content
+      end
+
+      private
+
+      def api_key
+        key = CoPlan.configuration.ai_api_key || Rails.application.credentials.dig(:openai, :api_key) || ENV["OPENAI_API_KEY"]
+        raise Error, "OpenAI API key not configured" if key.blank?
+        key
+      end
+
+      class Error < StandardError; end
+    end
+  end
+end

data/app/services/coplan/broadcaster.rb

@@ -0,0 +1,32 @@
+module CoPlan
+  module Broadcaster
+    class << self
+      def prepend_to(streamable, target:, partial:, locals: {})
+        Turbo::StreamsChannel.broadcast_prepend_to(streamable, target: target, html: render(partial:, locals:))
+      end
+
+      def append_to(streamable, target:, partial:, locals: {})
+        Turbo::StreamsChannel.broadcast_append_to(streamable, target: target, html: render(partial:, locals:))
+      end
+
+      def replace_to(streamable, target:, html: nil, partial: nil, locals: {})
+        html ||= render(partial:, locals:)
+        Turbo::StreamsChannel.broadcast_replace_to(streamable, target: target, html: html)
+      end
+
+      def update_to(streamable, target:, html:)
+        Turbo::StreamsChannel.broadcast_update_to(streamable, target: target, html: html)
+      end
+
+      def remove_to(streamable, target:)
+        Turbo::StreamsChannel.broadcast_remove_to(streamable, target: target)
+      end
+
+      private
+
+      def render(partial:, locals:)
+        CoPlan::ApplicationController.render(partial: partial, locals: locals)
+      end
+    end
+  end
+end