gaggle 0.2.2

data/app/controllers/gaggle/application_controller.rb

@@ -0,0 +1,23 @@
+module Gaggle
+  class ApplicationController < ActionController::Base
+    include ActionView::RecordIdentifier
+    before_action :set_channels
+    before_action :set_geese
+    before_action :set_current_attributes
+    skip_before_action :verify_authenticity_token, if: :mcp_invocation?
+
+    private
+
+    def set_channels
+      @channels = Gaggle::Channel.all
+    end
+
+    def set_geese
+      @geese = Gaggle::Goose.all
+    end
+
+    def set_current_attributes
+      Current.goose_user = Goose.find_by(id: params[:goose_user_id])
+    end
+  end
+end

data/app/controllers/gaggle/channels/messages_controller.rb

@@ -0,0 +1,27 @@
+module Gaggle
+  class Channels::MessagesController < Gaggle::ChannelsController
+    skip_before_action :verify_authenticity_token
+
+    permitted_params_for :create do
+      param :message, required: true do
+        param :content, type: :string, example: "Message Content", required: true
+      end
+    end
+
+    tool_description_for :create, "Send a message to the channel"
+    def create
+      @message = @channel.messages.new(resource_params)
+      if @message.save
+        respond_to do |format|
+          format.html { redirect_to @channel, notice: "Message sent." }
+          format.json { render json: @message, status: :created, location: @message }
+        end
+      else
+        respond_to do |format|
+          format.html { render :new, notice: "Message was not sent." }
+          format.json { render json: @message.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  end
+end

data/app/controllers/gaggle/channels_controller.rb

@@ -0,0 +1,84 @@
+module Gaggle
+  class ChannelsController < ApplicationController
+    before_action :set_channel, except: :index
+
+    permitted_params_for :create do
+      param :channel, required: true do
+        param :name, type: :string, example: "Channel Name", required: true
+        param :goose_ids, type: :array, item_type: :string, example: [ "1", "2" ]
+      end
+    end
+
+    permitted_params_for :update do
+      param :channel, required: true do
+        param :name, type: :string, example: "Channel Name"
+        param :goose_ids, type: :array, item_type: :string, example: [ "1", "2" ]
+      end
+    end
+
+
+    tool_description_for :index, "View all channels and their ids"
+    def index; end
+
+    tool_description_for :show, "View all messages in a channel"
+    def show
+      @notification = Current.goose_user&.notifications&.unread&.for_messageable(@channel)&.first
+    end
+
+    def new; end
+
+    def create
+      @channel.assign_attributes(resource_params)
+
+      if @channel.save
+        respond_to do |format|
+          format.html { redirect_to @channel, notice: "Channel was successfully created." }
+          format.json { render json: @channel, status: :created, location: @channel }
+        end
+      else
+        respond_to do |format|
+          format.html { render :new }
+          format.json { render json: @channel.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @channel.update(resource_params)
+        respond_to do |format|
+          format.html { redirect_to @channel, notice: "Channel was successfully updated." }
+          format.json { render json: { name: @channel.name, goose_ids: @channel.goose_ids }, status: :ok }
+        end
+
+        Turbo::StreamsChannel.broadcast_update_to "application",
+          targets: ".#{dom_id(@channel, :title)}",
+          content: @channel.name
+      else
+        respond_to do |format|
+          format.html { render :edit }
+          format.json { render json: @channel.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def destroy
+      @channel.destroy
+      respond_to do |format|
+        format.html { redirect_to root_url, notice: "Channel was successfully destroyed." }
+        format.json { render json: "#{@channel.name} was successfully destroyed.", status: :ok }
+      end
+    end
+
+    private
+
+    def set_channels
+      @channels = Gaggle::Channel.includes(:gooses)
+    end
+
+    def set_channel
+      @channel = Gaggle::Channel.includes(messages: :goose).find_by(id: params[:channel_id] || params[:id]) || Gaggle::Channel.new
+    end
+  end
+end

data/app/controllers/gaggle/gooses/sessions_controller.rb

@@ -0,0 +1,23 @@
+module Gaggle
+  class Gooses::SessionsController < SessionsController
+    before_action :set_goose
+
+    def index
+      @sessions = @goose.sessions
+    end
+
+    def create
+      session = @goose.sessions.create!
+      session.start_executable
+      sleep 1.second
+      session.write_to_executable(@goose.interaction_prompt + @goose.prompt + @goose.begin_prompt)
+      redirect_to session
+    end
+
+    private
+
+    def set_goose
+      @goose = Gaggle::Goose.find(params[:goose_id])
+    end
+  end
+end

data/app/controllers/gaggle/gooses_controller.rb

@@ -0,0 +1,47 @@
+module Gaggle
+  class GoosesController < ApplicationController
+    before_action :set_goose
+
+    def index
+      @gooses = Goose.where.not(id: Current.goose_user&.id)
+    end
+
+    def show; end
+
+    def new; end
+
+    def create
+      @goose.assign_attributes(goose_params)
+      if @goose.save
+        redirect_to @goose, notice: "Goose was successfully created."
+      else
+        render :new
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @goose.update(goose_params)
+        redirect_to @goose, notice: "Goose was successfully updated."
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @goose.destroy
+      redirect_to root_url, notice: "Goose was successfully destroyed."
+    end
+
+    private
+
+    def set_goose
+      @goose = Goose.find_by(id: params[:id]) || Goose.new
+    end
+
+    def goose_params
+      params.require(:goose).permit(:name, :prompt)
+    end
+  end
+end

data/app/controllers/gaggle/messages_controller.rb

@@ -0,0 +1,7 @@
+module Gaggle
+  class MessagesController < ApplicationController
+    def destroy
+      render plain: "Message destroyed: #{params[:id]}"
+    end
+  end
+end

data/app/controllers/gaggle/overviews_controller.rb

@@ -0,0 +1,5 @@
+module Gaggle
+  class OverviewsController < ApplicationController
+    def show; end
+  end
+end

data/app/controllers/gaggle/sessions_controller.rb

@@ -0,0 +1,27 @@
+module Gaggle
+  class SessionsController < ApplicationController
+    before_action :set_session, only: [ :show, :update, :destroy ]
+
+    def show; end
+
+    def update
+      @session.write_to_executable(session_params[:content])
+      redirect_to @session
+    end
+
+    def destroy
+      @session.stop_executable
+      redirect_to @session
+    end
+
+    private
+
+    def set_session
+      @session = Gaggle::Session.find(params[:id])
+    end
+
+    def session_params
+      params.require(:session).permit(:content)
+    end
+  end
+end

data/app/helpers/gaggle/application_helper.rb

@@ -0,0 +1,4 @@
+module Gaggle
+  module ApplicationHelper
+  end
+end

data/app/javascript/controllers/gaggle/application.js

@@ -0,0 +1,9 @@
+import { Application } from "@hotwired/stimulus"
+
+const gaggleApplication = Application.start()
+
+// Configure Stimulus development experience
+gaggleApplication.debug = false
+window.Stimulus   = gaggleApplication
+
+export { gaggleApplication }

data/app/javascript/controllers/gaggle/chat_field_form_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  submitForm() {
+    this.element.closest('form').requestSubmit()
+  }
+}

data/app/javascript/controllers/gaggle/index.js

@@ -0,0 +1,4 @@
+// Import and register all your controllers from the importmap via controllers/**/*_controller
+import { gaggleApplication } from "controllers/gaggle/application"
+import { lazyLoadControllersFrom } from "@hotwired/stimulus-loading"
+lazyLoadControllersFrom("controllers/gaggle", gaggleApplication)

data/app/javascript/controllers/gaggle/local_timestamp_controller.js

@@ -0,0 +1,21 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["display"]
+  static values = { utc: String }
+
+  connect() {
+    this.updateTime()
+  }
+
+  updateTime() {
+    const date = new Date(this.utcValue)
+    const options = {
+      hour: 'numeric',
+      minute: '2-digit',
+      hour12: true
+    }
+    const formattedTime = date.toLocaleTimeString([], options)
+    this.displayTarget.textContent = formattedTime
+  }
+}

data/app/javascript/controllers/gaggle/text_area_auto_expand_controller.js

@@ -0,0 +1,27 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = {
+    maxRows: Number
+  }
+
+  connect() {
+    this.adjustRows()
+    this.element.addEventListener('input', this.adjustRows.bind(this))
+  }
+
+  disconnect() {
+    this.element.removeEventListener('input', this.adjustRows.bind(this))
+  }
+
+  adjustRows() {
+    const textarea = this.element
+    const lines = textarea.value.split('\n').length
+
+    if (this.maxRowsValue) {
+      textarea.rows = Math.max(1, Math.min(this.maxRowsValue, lines))
+    } else {
+      textarea.rows = lines
+    }
+  }
+}

data/app/javascript/controllers/gaggle/transition_controller.js

@@ -0,0 +1,102 @@
+import { Controller } from "@hotwired/stimulus"
+import {transition, enter, leave} from "gaggle/el-transition"
+
+export default class extends Controller {
+  static targets = ['listener']
+  static values = {
+    open: Boolean,
+    startAnimation: Boolean,
+    skipHidden: Boolean
+  }
+
+  initialize() {
+    this.startAnimationValue && this.update()
+  }
+
+  transitionClasses(element, animation, direction) {
+    const animationClass = animation ? `${animation}-${direction}` : direction
+    let transition = `transition${direction.charAt(0).toUpperCase() + direction.slice(1)}`
+    const end = element.dataset[`${transition}End`] ? element.dataset[`${transition}End`].split(" ") : [`${animationClass}-end`]
+    const final = element.dataset[`${transition}Final`] ? element.dataset[`${transition}Final`].split(" ") : [`${animationClass}-final`]
+    return [end, final].flat()
+  }
+
+  removeLastTransition(element, animation, direction) {
+    const classes = this.transitionClasses(element, animation, direction)
+    removeClasses(element, classes)
+  }
+
+  async enter(element, transitionName = null) {
+    let skipHidden = (this.skipHiddenValue || element.hasAttribute('data-transition-skip-hidden'))
+
+    if (skipHidden) {
+      this.removeLastTransition(element, transitionName, 'leave')
+    } else {
+      element.classList.remove('hidden')
+    }
+    this.element.dispatchEvent(new Event('toggler:enter-start'))
+
+    await transition('enter', element, transitionName, skipHidden)
+  }
+
+  async leave(element, transitionName = null) {
+    let skipHidden = (this.skipHiddenValue || element.hasAttribute('data-transition-skip-hidden'))
+
+    if (skipHidden) {
+      this.removeLastTransition(element, transitionName, 'enter')
+    }
+    this.element.dispatchEvent(new Event('toggler:leave-start'))
+    await transition('leave', element, transitionName, skipHidden)
+    !skipHidden && element.classList.add('hidden')
+  }
+
+  async toggle(element, transitionName = null) {
+    if (this.openValue) {
+      this.openValue = !this.openValue
+      await enter(element, transitionName)
+    } else {
+      this.openValue = !this.openValue
+      await leave(element, transitionName)
+    }
+  }
+
+  toggle() {
+    this.openValue = !this.openValue
+    this.update()
+  }
+
+  close() {
+    if (this.openValue) {
+      this.openValue = false
+      this.update()
+    }
+  }
+
+  closeImmediately() {
+    this.openValue = false
+    this.listenerTargets.forEach((listener) => {
+      this.removeLastTransition(listener, null, 'enter')
+      const classes = this.transitionClasses(listener, null, 'leave')
+      addClasses(listener, classes)
+    })
+  }
+
+  open() {
+    if (!this.openValue) {
+      this.openValue = true
+    }
+    this.update()
+  }
+
+  update() {
+    this.listenerTargets.forEach((listener) => {
+      if (this.openValue) {
+        this.enter(listener)
+          .then(() => this.element.dispatchEvent(new Event('toggler:entered')))
+      } else {
+        this.leave(listener)
+          .then(() => this.element.dispatchEvent(new Event('toggler:left')))
+      }
+    })
+  }
+}

data/app/javascript/gaggle/application.js

@@ -0,0 +1,3 @@
+// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
+import "@hotwired/turbo-rails"
+import "controllers/gaggle"

data/app/javascript/gaggle/el-transition.js

@@ -0,0 +1,64 @@
+export async function enter(element, transitionName = null) {
+  element.classList.remove('hidden')
+  await transition('enter', element, transitionName)
+}
+
+export async function leave(element, transitionName = null) {
+  await transition('leave', element, transitionName)
+  element.classList.add('hidden')
+}
+
+export async function toggle(element, transitionName = null) {
+  if (element.classList.contains('hidden')) {
+      await enter(element, transitionName)
+  } else {
+      await leave(element, transitionName)
+  }
+}
+
+export async function transition(direction, element, animation, keepEnd = false) {
+  const dataset = element.dataset
+  const animationClass = animation ? `${animation}-${direction}` : direction
+  let transition = `transition${direction.charAt(0).toUpperCase() + direction.slice(1)}`
+  const genesis = dataset[transition] ? dataset[transition].split(" ") : [animationClass]
+  const start = dataset[`${transition}Start`] ? dataset[`${transition}Start`].split(" ") : [`${animationClass}-start`]
+  const end = dataset[`${transition}End`] ? dataset[`${transition}End`].split(" ") : [`${animationClass}-end`]
+  const final = dataset[`${transition}Final`] ? dataset[`${transition}Final`].split(" ") : [`${animationClass}-final`]
+
+  addClasses(element, genesis)
+  addClasses(element, start)
+  await nextFrame()
+  removeClasses(element, start)
+  addClasses(element, end);
+  await afterTransition(element)
+  !keepEnd && removeClasses(element, end)
+  removeClasses(element, genesis)
+  addClasses(element, final);
+}
+
+export function addClasses(element, classes) {
+  element.classList.add(...classes)
+}
+
+export function removeClasses(element, classes) {
+  element.classList.remove(...classes)
+}
+
+function nextFrame() {
+  return new Promise(resolve => {
+      requestAnimationFrame(() => {
+          requestAnimationFrame(resolve)
+      });
+  });
+}
+
+function afterTransition(element) {
+  return new Promise(resolve => {
+      // safari return string with comma separate values
+      const computedDuration = getComputedStyle(element).transitionDuration.split(",")[0]
+      const duration = Number(computedDuration.replace('s', '')) * 1000;
+      setTimeout(() => {
+          resolve()
+      }, duration)
+  });
+}

data/app/jobs/gaggle/application_job.rb

@@ -0,0 +1,4 @@
+module Gaggle
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/gaggle/application_mailer.rb

@@ -0,0 +1,6 @@
+module Gaggle
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/gaggle/application_record.rb

@@ -0,0 +1,8 @@
+module Gaggle
+  class ApplicationRecord < ActiveRecord::Base
+    include ActionView::RecordIdentifier
+    self.abstract_class =true
+    establish_connection :gaggle
+    connects_to database: { writing: :gaggle, reading: :gaggle }
+  end
+end

data/app/models/gaggle/channel.rb

@@ -0,0 +1,45 @@
+module Gaggle
+  class Channel < ApplicationRecord
+    self.table_name = "gaggle_channels"
+
+    has_many :messages, class_name: "Gaggle::Message", as: :messageable, dependent: :destroy
+    has_and_belongs_to_many :gooses
+    has_many :notifications, class_name: "Gaggle::Notification", dependent: :destroy, as: :messageable
+
+    validates :name, presence: true
+
+    before_validation :assign_goose_user, if: -> { Current.goose_user }
+    after_create_commit :broadcast_create
+    after_update_commit :broadcast_update
+    after_destroy_commit :broadcast_destroy
+
+    def broadcast_create
+      broadcast_before_to "gaggle",
+      targets: ".new-channel",
+      content: ApplicationController.render(
+        partial: "gaggle/channels/channel",
+        locals: { channel: self }
+      )
+    end
+
+    def broadcast_update
+      broadcast_replace_to "gaggle",
+        targets: ".#{dom_id(self, :sidebar)}",
+        partial: "gaggle/channels/channel",
+        content: ApplicationController.render(
+          partial: "gaggle/channels/channel",
+          locals: { channel: self }
+        )
+    end
+
+    def broadcast_destroy
+      broadcast_remove_to "gaggle", targets: ".#{dom_id(self, :sidebar)}"
+    end
+
+    private
+
+    def assign_goose_user
+      gooses << Current.goose_user
+    end
+  end
+end

data/app/models/gaggle/channel_goose.rb

@@ -0,0 +1,11 @@
+module Gaggle
+  class ChannelGoose < ApplicationRecord
+    self.table_name = "gaggle_channels_gooses"
+
+    belongs_to :channel, class_name: "Gaggle::Channel", dependent: :destroy
+    belongs_to :goose, class_name: "Gaggle::Goose", dependent: :destroy
+
+    validates :channel_id, uniqueness: { scope: :goose_id }, presence: true
+    validates :goose_id, uniqueness: { scope: :channel_id }, presence: true
+  end
+end

data/app/models/gaggle/current.rb

@@ -0,0 +1,5 @@
+module Gaggle
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :goose_user, :goose
+  end
+end

data/app/models/gaggle/goose/personality_defaults.rb

@@ -0,0 +1,87 @@
+module Gaggle
+  module Goose::PersonalityDefaults
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def personalities
+        [
+          {
+            name: "Project Manager",
+            prompt: project_manager_prompt
+          },
+          {
+            name: "Engineer",
+            prompt: engineer_prompt
+          }
+        ]
+      end
+
+      def project_manager_prompt
+        <<~TEXT
+        You are an experienced Project Manager AI assistant. Your role is to coordinate and oversee a team of specialized AI assistants working on a software development project. Your responsibilities include:
+
+        1. Understanding project requirements and objectives
+        2. Breaking down tasks and assigning them to appropriate AI team members
+        3. Facilitating communication between team members
+        4. Monitoring progress and ensuring deadlines are met
+        5. Identifying and addressing potential risks or roadblocks
+        6. Providing status updates and summaries
+
+        Remember:
+        - Do not write or generate any code yourself
+        - Focus on project management, coordination, and communication
+        - Engage in discussions about solutions, but defer technical implementation to the specialized AI team members
+
+        When interacting with the Human or other AI assistants:
+        1. Ask clarifying questions to fully understand tasks and requirements
+        2. Provide clear, concise instructions and expectations
+        3. Encourage collaboration and knowledge sharing among team members
+        4. Summarize discussions and decisions for documentation purposes
+        5. Prioritize tasks based on project goals and timelines
+        6. Identify potential bottlenecks or dependencies between tasks
+
+        Your communication style should be:
+        - Professional and authoritative, but approachable
+        - Clear and concise, avoiding technical jargon when possible
+        - Focused on keeping the project on track and team members aligned
+
+        Your main goals will be decided by "Human". You should ask the user questions in the channel "Game Plan". If the channel doesn't exist, create it.
+        TEXT
+      end
+
+      def engineer_prompt
+        <<~TEXT
+          You are an experienced AI Software Engineer assistant. Your primary role is to implement code and follow instructions from the Project Manager AI or the user. Your responsibilities include:
+
+          1. Writing high-quality, efficient code based on given specifications
+          2. Debugging and troubleshooting issues in the codebase
+          3. Collaborating with other AI team members on complex tasks
+          4. Providing technical insights and recommendations when asked
+          5. Implementing best practices in software development
+          6. Ensuring code maintainability and scalability
+
+          Key behaviors:
+          - Always ask clarifying questions before starting any task
+          - Seek additional information if requirements are unclear or incomplete
+          - Provide detailed explanations of your code and thought process
+          - Be proactive in identifying potential technical challenges or limitations
+          - Suggest alternative approaches when appropriate, explaining pros and cons
+
+          When interacting with the Project Manager AI or user:
+          1. Confirm your understanding of each task before beginning implementation
+          2. Provide regular updates on your progress
+          3. Clearly communicate any roadblocks or dependencies you encounter
+          4. Ask for feedback on your work and be open to constructive criticism
+          5. Offer time estimates for tasks when requested
+
+          Your communication style should be:
+          - Technical but clear, explaining complex concepts in an understandable manner
+          - Precise and detailed in your questions and responses
+          - Professional and collaborative, focusing on problem-solving
+
+          You will follow instructions by either the Human or Project Manager
+        TEXT
+      end
+    end
+  end
+end