collavre 0.1.1 → 0.2.0

data/app/controllers/collavre/comments_controller.rb

@@ -1,8 +1,13 @@
 module Collavre
   class CommentsController < ApplicationController
+    layout "collavre/chat", only: [ :fullscreen ]
     before_action :set_creative
     before_action :set_comment, only: [ :destroy, :show, :update, :convert, :approve, :update_action ]
 
+    def fullscreen
+      @creative_snippet = @creative.creative_snippet
+    end
+
     def index
       limit = 20
 
@@ -355,7 +360,7 @@ module Collavre
     def participants
       users = [ @creative.user ].compact + @creative.all_shared_users(:feedback).map(&:user)
       users = users.uniq
-      data = users.map do |u|
+      user_data = users.map do |u|
         {
           id: u.id,
           email: u.email,
@@ -365,7 +370,18 @@ module Collavre
           initial: u.display_name[0].upcase
         }
       end
-      render json: data
+      render json: {
+        users: user_data,
+        can_share: @creative.has_permission?(Current.user, :admin)
+      }
+    end
+
+    def commands
+      unless @creative.has_permission?(Current.user, :read)
+        head :forbidden and return
+      end
+
+      render json: command_menu_items
     end
 
     def move
@@ -374,13 +390,33 @@ module Collavre
         render json: { error: I18n.t("collavre.comments.move_no_selection") }, status: :unprocessable_entity and return
       end
 
-      target_creative = Creative.find_by(id: params[:target_creative_id])
-      if target_creative.nil?
+      # Support moving to topic within same creative (target_topic_id only)
+      # or moving to different creative (target_creative_id)
+      target_topic_id = params[:target_topic_id]
+      target_creative_id = params[:target_creative_id]
+
+      # Determine target creative and topic
+      if target_creative_id.present?
+        # Moving to different creative
+        target_creative = Creative.find_by(id: target_creative_id)
+        if target_creative.nil?
+          render json: { error: I18n.t("collavre.comments.move_invalid_target") }, status: :unprocessable_entity and return
+        end
+        target_origin = target_creative.effective_origin
+        new_topic_id = nil # Reset topic when moving to different creative
+      elsif target_topic_id.present? || target_topic_id == ""
+        # Moving to topic within same creative (empty string means Main/no topic)
+        target_origin = @creative
+        new_topic_id = target_topic_id.presence # nil for Main topic
+
+        # Validate topic exists if specified
+        if new_topic_id.present? && !@creative.topics.exists?(id: new_topic_id)
+          render json: { error: I18n.t("collavre.comments.move_invalid_topic", default: "Invalid topic") }, status: :unprocessable_entity and return
+        end
+      else
         render json: { error: I18n.t("collavre.comments.move_invalid_target") }, status: :unprocessable_entity and return
       end
 
-      target_origin = target_creative.effective_origin
-
       unless @creative.has_permission?(Current.user, :feedback) && target_origin.has_permission?(Current.user, :feedback)
         render json: { error: I18n.t("collavre.comments.move_not_allowed") }, status: :forbidden and return
       end
@@ -398,20 +434,34 @@ module Collavre
         render json: { error: I18n.t("collavre.comments.move_not_allowed") }, status: :forbidden and return
       end
 
+      moved_count = 0
       ActiveRecord::Base.transaction do
         comments.each do |comment|
-          next if comment.creative_id == target_origin.id
+          # Skip if already in target location
+          same_creative = comment.creative_id == target_origin.id
+          same_topic = comment.topic_id.to_s == new_topic_id.to_s
+
+          next if same_creative && same_topic
 
           original_creative = comment.creative
-          comment.update!(creative: target_origin, topic_id: nil)
-          broadcast_move_removal(comment, original_creative)
+          original_topic_id = comment.topic_id
+
+          if same_creative
+            # Just update topic within same creative
+            comment.update!(topic_id: new_topic_id)
+          else
+            # Move to different creative
+            comment.update!(creative: target_origin, topic_id: new_topic_id)
+            broadcast_move_removal(comment, original_creative)
+          end
+          moved_count += 1
         end
       end
 
       Comment.broadcast_badges(@creative)
       Comment.broadcast_badges(target_origin) unless target_origin == @creative
 
-      render json: { success: true }
+      render json: { success: true, moved_count: moved_count }
     rescue ActiveRecord::RecordInvalid => e
       render json: { error: e.record.errors.full_messages.to_sentence.presence || I18n.t("collavre.comments.move_error") }, status: :unprocessable_entity
     end
@@ -422,6 +472,57 @@ module Collavre
       @creative = Creative.find(params[:creative_id]).effective_origin
     end
 
+    def command_menu_items
+      [
+        {
+          name: "calendar",
+          label: "/calendar",
+          aliases: [ "/cal" ],
+          description: I18n.t("collavre.comments.command_menu.calendar_description"),
+          args: I18n.t("collavre.comments.command_menu.calendar_args")
+        }
+      ] + mcp_command_items
+    end
+
+    def mcp_command_items
+      Collavre::McpService.available_tools(Current.user).filter_map do |tool|
+        tool_name = tool[:name] || tool["name"]
+        next unless tool_name
+
+        {
+          name: tool_name,
+          label: "/#{tool_name}",
+          description: tool[:description] || tool["description"],
+          args: format_command_args(tool[:params] || tool["params"])
+        }
+      end
+    end
+
+    def format_command_args(params)
+      return if params.blank?
+
+      # Handle array format (from MetaToolService)
+      if params.is_a?(Array)
+        return params.map do |param|
+          name = param[:name] || param["name"]
+          required = param[:required] || param["required"]
+          name.to_s + (required ? "*" : "")
+        end.join(", ")
+      end
+
+      # Handle JSON Schema format (Hash with :properties)
+      properties = params[:properties] || params["properties"]
+      return unless properties.is_a?(Hash)
+
+      required = params[:required] || params["required"] || []
+      required = Array(required).map(&:to_s)
+
+      properties.keys.map do |key|
+        key = key.to_s
+        required.include?(key) ? "#{key}*" : key
+      end.join(", ")
+    end
+
     def set_comment
       @comment = @creative.comments
                              .where(

data/app/controllers/collavre/creatives_controller.rb

@@ -236,6 +236,8 @@ module Collavre
         permitted = creative_params.to_h
         base = @creative.effective_origin(Set.new)
         success = true
+        previous_progress = base.progress
+        requested_progress = permitted["progress"] || permitted[:progress]
 
         # Handle parent_id change separately for Linked Creatives
         if @creative.origin_id.present? && permitted.key?("parent_id")
@@ -251,6 +253,12 @@ module Collavre
         permitted.delete(:origin_id)
 
         success &&= base.update(permitted)
+        if success && requested_progress.present? && requested_progress.to_f >= 1 && previous_progress.to_f < 1
+          if base.children.exists?
+            base.self_and_descendants.where(origin_id: nil)
+              .update_all(progress: 1.0, updated_at: Time.current)
+          end
+        end
 
         if success
           format.html { redirect_to @creative }

data/app/controllers/collavre/google_auth_controller.rb

@@ -21,7 +21,11 @@ module Collavre
       # for personal google service (like google calendar)
       user.google_uid = auth.uid
       user.google_access_token = auth.credentials.token
-      user.google_refresh_token = auth.credentials.refresh_token || user.google_refresh_token
+      # Only update refresh_token if Google provides a new one
+      # (Google doesn't always return refresh_token on re-authentication)
+      if auth.credentials.refresh_token.present?
+        user.google_refresh_token = auth.credentials.refresh_token
+      end
       user.google_token_expires_at = Time.at(auth.credentials.expires_at) if auth.credentials.expires_at
 
       user.save! if user.new_record? || user.changed?

data/app/controllers/collavre/plans_controller.rb

@@ -8,9 +8,9 @@ module Collavre
       end
       start_date = center - 30
       end_date = center + 30
-      @plans = Plan.includes(:creative)
-                   .where("target_date >= ? AND created_at <= ?", start_date, end_date)
-                   .order(:created_at)
+      @plans = Plan.joins(:creative)
+                   .where("target_date >= ? AND DATE(creatives.created_at) <= ?", start_date, end_date)
+                   .order(Arel.sql("DATE(creatives.created_at) ASC"))
                    .select { |plan| plan.readable_by?(Current.user) }
       calendar_scope = CalendarEvent.includes(:creative)
                                     .where("DATE(start_time) <= ? AND DATE(end_time) >= ?", end_date, start_date)
@@ -68,25 +68,79 @@ module Collavre
       end
     end
 
+    def update
+      @plan = Plan.find(params[:id])
+      return render_forbidden unless plan_editable_by_current_user?
+
+      if @plan.update(plan_update_params)
+        respond_to do |format|
+          format.html do
+            redirect_back fallback_location: main_app.root_path,
+                          notice: t("collavre.plans.updated", default: "Plan updated.")
+          end
+          format.json do
+            render json: plan_json(@plan, creative_id: params[:creative_id] || @plan.creative_id), status: :ok
+          end
+        end
+      else
+        respond_to do |format|
+          format.html do
+            flash[:alert] = @plan.errors.full_messages.join(", ")
+            redirect_back fallback_location: main_app.root_path
+          end
+          format.json do
+            render json: { errors: @plan.errors.full_messages }, status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
     private
 
     def plan_params
-      params.require(:plan).permit(:target_date, :creative_id)
+      params.require(:plan).permit(:target_date, :start_date, :creative_id)
+    end
+
+    def plan_update_params
+      params.require(:plan).permit(:target_date, :start_date)
+    end
+
+    def plan_editable_by_current_user?
+      return true if @plan.owner_id == Current.user&.id
+      return true if @plan.creative&.has_permission?(Current.user, :write)
+
+      tagged_creative = Creative.find_by(id: params[:creative_id])
+      return false unless tagged_creative
+      return false unless @plan.tags.exists?(creative_id: tagged_creative.id)
+
+      tagged_creative.has_permission?(Current.user, :write)
+    end
+
+    def render_forbidden
+      respond_to do |format|
+        format.html do
+          redirect_back fallback_location: main_app.root_path,
+                        alert: t("collavre.plans.update_forbidden", default: "You do not have permission to update this plan.")
+        end
+        format.json do
+          render json: { error: "forbidden" }, status: :forbidden
+        end
+      end
     end
 
-    def plan_json(plan)
+    def plan_json(plan, creative_id: nil)
       {
         id: plan.id,
         name: (plan.creative&.effective_description(nil, false) || plan.name.presence || I18n.l(plan.target_date)),
         created_at: plan.created_at.to_date,
+        start_date: plan.start_date,
         target_date: plan.target_date,
         progress: plan.progress,
-        path: plan_creatives_path(plan),
+        path: plan_creatives_path(plan, creative_id: creative_id),
         deletable: plan.owner_id == Current.user&.id
       }
     end
 
-
     def calendar_json(event)
       {
         id: "calendar_event_#{event.id}",
@@ -99,8 +153,10 @@ module Collavre
       }
     end
 
-    def plan_creatives_path(plan)
-      if params[:id].present?
+    def plan_creatives_path(plan, creative_id: nil)
+      if creative_id.present?
+        creative_path(creative_id, tags: [ plan.id ])
+      elsif params[:id].present?
         creative_path(params[:id], tags: [ plan.id ])
       else
         creatives_path(tags: [ plan.id ])

data/app/controllers/collavre/topics_controller.rb

@@ -29,6 +29,24 @@ module Collavre
       end
     end
 
+    def update
+      unless @creative.has_permission?(Current.user, :admin) || @creative.user == Current.user
+        render json: { error: I18n.t("collavre.topics.no_permission") }, status: :forbidden and return
+      end
+
+      topic = @creative.topics.find(params[:id])
+
+      if topic.update(topic_params)
+        TopicsChannel.broadcast_to(
+          @creative,
+          { action: "updated", topic: topic.slice(:id, :name) }
+        )
+        render json: topic
+      else
+        render json: { errors: topic.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
     def destroy
       unless @creative.has_permission?(Current.user, :admin) || @creative.user == Current.user
         render json: { error: I18n.t("collavre.topics.no_permission") }, status: :forbidden and return
@@ -45,6 +63,30 @@ module Collavre
       head :no_content
     end
 
+    def reorder
+      unless @creative.has_permission?(Current.user, :admin) || @creative.user == Current.user
+        render json: { error: I18n.t("collavre.topics.no_permission") }, status: :forbidden and return
+      end
+
+      topic_ids = params[:topic_ids]
+      unless topic_ids.is_a?(Array) && topic_ids.present?
+        render json: { error: "Invalid topic_ids" }, status: :unprocessable_entity and return
+      end
+
+      Topic.transaction do
+        topic_ids.each_with_index do |id, index|
+          @creative.topics.where(id: id).update_all(position: index)
+        end
+      end
+
+      TopicsChannel.broadcast_to(
+        @creative,
+        { action: "reordered", topic_ids: topic_ids }
+      )
+
+      render json: { success: true }
+    end
+
     private
 
     def set_creative

data/app/controllers/collavre/users_controller.rb

@@ -65,9 +65,10 @@ module Collavre
         email: email,
         password: SecureRandom.hex(36),
         system_prompt: params[:system_prompt],
-        llm_vendor: "google",
+        llm_vendor: params[:llm_vendor].presence || "google",
         llm_model: params[:llm_model],
         llm_api_key: params[:llm_api_key],
+        gateway_url: params[:gateway_url],
         tools: params[:tools] || [],
         searchable: searchable,
         email_verified_at: Time.current,
@@ -111,7 +112,7 @@ module Collavre
         return
       end
 
-      ai_params = params.require(:user).permit(:name, :system_prompt, :llm_model, :llm_api_key, :searchable, :routing_expression, tools: [])
+      ai_params = params.require(:user).permit(:name, :system_prompt, :llm_vendor, :llm_model, :llm_api_key, :gateway_url, :searchable, :routing_expression, tools: [])
 
       if @user.update(ai_params)
         redirect_to edit_ai_user_path(@user), notice: I18n.t("collavre.users.update_ai.success")
@@ -267,24 +268,13 @@ module Collavre
     private
 
     def load_available_tools
-      return [] unless defined?(RailsMcpEngine)
-
-      RailsMcpEngine::Engine.build_tools!
-      tools = ::Tools::MetaToolService.new.call(action: "list", tool_name: nil, query: nil, arguments: nil)
-
-      tool_list = Array(tools[:tools])
-      filtered_tools = Collavre::McpService.filter_tools(tool_list, Current.user)
-
-      filtered_tools.map do |tool|
+      Collavre::McpService.available_tools(Current.user).map do |tool|
         {
           name: tool[:name],
           description: tool[:description],
           parameters: tool[:params]
         }
       end
-    rescue StandardError => e
-      Rails.logger.error("Failed to load MCP tools: #{e.message}")
-      []
     end
 
     def prepare_contacts

data/app/errors/collavre/approval_pending_error.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Collavre
+  class ApprovalPendingError < StandardError
+    attr_reader :tool_call, :task
+
+    def initialize(message = "Tool execution requires approval", tool_call: nil, task: nil)
+      @tool_call = tool_call
+      @task = task
+      super(message)
+    end
+
+    def tool_name
+      return nil unless tool_call
+
+      if tool_call.respond_to?(:name)
+        tool_call.name
+      elsif tool_call.is_a?(Hash)
+        tool_call["name"] || tool_call[:name]
+      end
+    end
+
+    def tool_arguments
+      return {} unless tool_call
+
+      if tool_call.respond_to?(:arguments)
+        tool_call.arguments
+      elsif tool_call.is_a?(Hash)
+        tool_call["arguments"] || tool_call[:arguments] || {}
+      else
+        {}
+      end
+    end
+
+    def tool_call_id
+      return nil unless tool_call
+
+      if tool_call.respond_to?(:id)
+        tool_call.id
+      elsif tool_call.is_a?(Hash)
+        tool_call["id"] || tool_call[:id]
+      end
+    end
+
+    def to_h
+      {
+        tool_name: tool_name,
+        tool_call_id: tool_call_id,
+        arguments: tool_arguments,
+        task_id: task&.id
+      }
+    end
+  end
+end

data/app/errors/collavre/cancelled_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Collavre
+  class CancelledError < StandardError
+    def initialize(message = "Task was cancelled")
+      super(message)
+    end
+  end
+end

data/app/helpers/collavre/navigation_helper.rb

@@ -40,6 +40,8 @@ module Collavre
         render_nav_divider(item)
       when :raw
         render_nav_raw(item)
+      when :popup
+        render_nav_dropdown(item, mobile: mobile)
       else
         raise ArgumentError, "Unknown navigation item type: #{item[:type]}"
       end
@@ -123,7 +125,7 @@ module Collavre
     def render_dropdown_child(item, mobile: false)
       content = render_navigation_item(item, mobile: mobile)
       return if content.blank?
-      content_tag(:div, content)
+      content_tag(:div, content, class: "popup-menu-item")
     end
 
     def resolve_nav_label(label)

data/app/javascript/collavre.js

@@ -6,6 +6,7 @@ import "./modules/creatives"
 import "./modules/plans_timeline"
 import "./modules/creative_row_swipe"
 import "./modules/mention_menu"
+import "./modules/command_menu"
 import "./modules/export_to_markdown"
 import "./modules/plans_menu"
 import "./modules/inbox_panel"

data/app/javascript/controllers/comments/__tests__/popup_controller.test.js

@@ -14,9 +14,10 @@ describe('CommentsPopupController', () => {
     beforeEach(() => {
         container = document.createElement('div')
         container.innerHTML = `
-      <div id="comments-popup" data-controller="comments--popup" style="width: 300px; height: 400px; position: absolute;">
+      <div id="comments-popup" data-controller="comments--popup" data-fullscreen-url-template="/creatives/__CREATIVE_ID__/comments/fullscreen" style="width: 300px; height: 400px; position: absolute;">
         <h3 data-comments--popup-target="title">Title</h3>
         <div data-comments--popup-target="list">List</div>
+        <a data-comments--popup-target="fullscreenLink" href="#"></a>
         <button data-comments--popup-target="closeButton">Close</button>
         <div data-comments--popup-target="leftHandle"></div>
         <div data-comments--popup-target="rightHandle"></div>

data/app/javascript/controllers/comments/form_controller.js

@@ -79,7 +79,8 @@ export default class extends Controller {
 
   isMentionMenuVisible() {
     const menu = document.getElementById('mention-menu')
-    return menu?.style.display === 'block'
+    const commandMenu = document.getElementById('command-menu')
+    return menu?.style.display === 'block' || commandMenu?.style.display === 'block'
   }
 
   disconnect() {