[

  import_deps: [:ecto, :ecto_sql, :phoenix],

  subdirectories: ["priv/*/migrations"],

  plugins: [Phoenix.LiveView.HTMLFormatter],

  inputs: ["*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}", "priv/*/seeds.exs"]

]

# The directory Mix will write compiled artifacts to.

/_build/

# If you run "mix test --cover", coverage assets end up here.

/cover/

# The directory Mix downloads your dependencies sources to.

/deps/

# Where 3rd-party dependencies like ExDoc output generated docs.

/doc/

# Ignore .fetch files in case you like to edit your project deps locally.

/.fetch

# If the VM crashes, it generates a dump, let's ignore it too.

erl_crash.dump

# Also ignore archive artifacts (built via "mix archive.build").

*.ez

# Temporary files, for example, from tests.

/tmp/

# Ignore package tarball (built via "mix hex.build").

openagents-*.tar

# Ignore assets that are produced by build tools.

/priv/static/assets/

# Ignore digested assets cache.

/priv/static/cache_manifest.json

# In case you use Node.js/npm, you want to ignore these.

npm-debug.log

/assets/node_modules/

/* See the Tailwind configuration guide for advanced usage

   https://tailwindcss.com/docs/configuration */

@import "tailwindcss" source(none);

@import "phoenix-colocated/openagents/colocated.css";

@source "../css";

@source "../js";

@source "../../lib/openagents_web";

/* Required for Tailwind to automatically pick up changes in colocated CSS files in dev */

@source "../../_build/dev/phoenix-colocated/openagents/*/";

/* A Tailwind plugin that makes "hero-#{ICON}" classes available.

   The heroicons installation itself is managed by your mix.exs */

@plugin "../vendor/heroicons";

/* daisyUI Tailwind Plugin. */

@plugin "daisyui/packages/bundle/daisyui" {

  themes: false;

}

/* daisyUI theme plugin.

  We ship with two themes, a light one inspired on Phoenix colors and a dark one inspired

  on Elixir colors. Build your own at: https://daisyui.com/theme-generator/ */

@plugin "daisyui/packages/bundle/daisyui-theme" {

  name: "dark";

  default: false;

  prefersdark: true;

  color-scheme: "dark";

  --color-base-100: oklch(30.33% 0.016 252.42);

  --color-base-200: oklch(25.26% 0.014 253.1);

  --color-base-300: oklch(20.15% 0.012 254.09);

  --color-base-content: oklch(97.807% 0.029 256.847);

  --color-primary: oklch(58% 0.233 277.117);

  --color-primary-content: oklch(96% 0.018 272.314);

  --color-secondary: oklch(58% 0.233 277.117);

  --color-secondary-content: oklch(96% 0.018 272.314);

  --color-accent: oklch(60% 0.25 292.717);

  --color-accent-content: oklch(96% 0.016 293.756);

  --color-neutral: oklch(37% 0.044 257.287);

  --color-neutral-content: oklch(98% 0.003 247.858);

  --color-info: oklch(58% 0.158 241.966);

  --color-info-content: oklch(97% 0.013 236.62);

  --color-success: oklch(60% 0.118 184.704);

  --color-success-content: oklch(98% 0.014 180.72);

  --color-warning: oklch(66% 0.179 58.318);

  --color-warning-content: oklch(98% 0.022 95.277);

  --color-error: oklch(58% 0.253 17.585);

  --color-error-content: oklch(96% 0.015 12.422);

  --radius-selector: 0.25rem;

  --radius-field: 0.25rem;

  --radius-box: 0.5rem;

  --size-selector: 0.21875rem;

  --size-field: 0.21875rem;

  --border: 1.5px;

  --depth: 1;

  --noise: 0;

}

@plugin "daisyui/packages/bundle/daisyui-theme" {

  name: "light";

  default: true;

  prefersdark: false;

  color-scheme: "light";

  --color-base-100: oklch(98% 0 0);

  --color-base-200: oklch(96% 0.001 286.375);

  --color-base-300: oklch(92% 0.004 286.32);

  --color-base-content: oklch(21% 0.006 285.885);

  --color-primary: oklch(70% 0.213 47.604);

  --color-primary-content: oklch(98% 0.016 73.684);

  --color-secondary: oklch(55% 0.027 264.364);

  --color-secondary-content: oklch(98% 0.002 247.839);

  --color-accent: oklch(0% 0 0);

  --color-accent-content: oklch(100% 0 0);

  --color-neutral: oklch(44% 0.017 285.786);

  --color-neutral-content: oklch(98% 0 0);

  --color-info: oklch(62% 0.214 259.815);

  --color-info-content: oklch(97% 0.014 254.604);

  --color-success: oklch(70% 0.14 182.503);

  --color-success-content: oklch(98% 0.014 180.72);

  --color-warning: oklch(66% 0.179 58.318);

  --color-warning-content: oklch(98% 0.022 95.277);

  --color-error: oklch(58% 0.253 17.585);

  --color-error-content: oklch(96% 0.015 12.422);

  --radius-selector: 0.25rem;

  --radius-field: 0.25rem;

  --radius-box: 0.5rem;

  --size-selector: 0.21875rem;

  --size-field: 0.21875rem;

  --border: 1.5px;

  --depth: 1;

  --noise: 0;

}

/* Add variants based on LiveView classes */

@custom-variant phx-click-loading (.phx-click-loading&, .phx-click-loading &);

@custom-variant phx-submit-loading (.phx-submit-loading&, .phx-submit-loading &);

@custom-variant phx-change-loading (.phx-change-loading&, .phx-change-loading &);

/* Use the data attribute for dark mode  */

@custom-variant dark (&:where([data-theme=dark], [data-theme=dark] *));

/* Make LiveView wrapper divs transparent for layout */

[data-phx-session], [data-phx-teleported-src] { display: contents }

/* This file is for your main application CSS */

// If you want to use Phoenix channels, run `mix help phx.gen.channel`

// to get started and then uncomment the line below.

// import "./user_socket.js"

// You can include dependencies in two ways.

//

// The simplest option is to put them in assets/vendor and

// import them using relative paths:

//

//     import "../vendor/some-package.js"

//

// Alternatively, you can `npm install some-package --prefix assets` and import

// them using a path starting with the package name:

//

//     import "some-package"

//

// If you have dependencies that try to import CSS, esbuild will generate a separate `app.css` file.

// To load it, simply add a second `<link>` to your `root.html.heex` file.

// Include phoenix_html to handle method=PUT/DELETE in forms and buttons.

import "phoenix_html"

// Establish Phoenix Socket and LiveView configuration.

import {Socket} from "phoenix"

import {LiveSocket} from "phoenix_live_view"

import {hooks as colocatedHooks} from "phoenix-colocated/openagents"

import topbar from "../vendor/topbar"

const csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content")

const liveSocket = new LiveSocket("/live", Socket, {

  longPollFallbackMs: 2500,

  params: {_csrf_token: csrfToken},

  hooks: {...colocatedHooks},

})

// Show progress bar on live navigation and form submits

topbar.config({barColors: {0: "#29d"}, shadowColor: "rgba(0, 0, 0, .3)"})

window.addEventListener("phx:page-loading-start", _info => topbar.show(300))

window.addEventListener("phx:page-loading-stop", _info => topbar.hide())

// connect if there are any LiveViews on the page

liveSocket.connect()

// expose liveSocket on window for web console debug logs and latency simulation:

// >> liveSocket.enableDebug()

// >> liveSocket.enableLatencySim(1000)  // enabled for duration of browser session

// >> liveSocket.disableLatencySim()

window.liveSocket = liveSocket

// The lines below enable quality of life phoenix_live_reload

// development features:

//

//     1. stream server logs to the browser console

//     2. click on elements to jump to their definitions in your code editor

//

if (process.env.NODE_ENV === "development") {

  window.addEventListener("phx:live_reload:attached", ({detail: reloader}) => {

    // Enable server log streaming to client.

    // Disable with reloader.disableServerLogs()

    reloader.enableServerLogs()

    // Open configured PLUG_EDITOR at file:line of the clicked element's HEEx component

    //

    //   * click with "c" key pressed to open at caller location

    //   * click with "d" key pressed to open at function component definition location

    let keyDown

    window.addEventListener("keydown", e => keyDown = e.key)

    window.addEventListener("keyup", _e => keyDown = null)

    window.addEventListener("click", e => {

      if(keyDown === "c"){

        e.preventDefault()

        e.stopImmediatePropagation()

        reloader.openEditorAtCaller(e.target)

      } else if(keyDown === "d"){

        e.preventDefault()

        e.stopImmediatePropagation()

        reloader.openEditorAtDef(e.target)

      }

    }, true)

    window.liveReloader = reloader

  })

}

// This file is needed on most editors to enable the intelligent autocompletion

// of LiveView's JavaScript API methods. You can safely delete it if you don't need it.

//

// Note: This file assumes a basic esbuild setup without node_modules.

// We include a generic paths alias to deps to mimic how esbuild resolves

// the Phoenix and LiveView JavaScript assets.

// If you have a package.json in your project, you should remove the

// paths configuration and instead add the phoenix dependencies to the

// dependencies section of your package.json:

//

// {

//   ...

//   "dependencies": {

//     ...,

//     "phoenix": "../deps/phoenix",

//     "phoenix_html": "../deps/phoenix_html",

//     "phoenix_live_view": "../deps/phoenix_live_view"

//   }

// }

//

// Feel free to adjust this configuration however you need.

{

  "compilerOptions": {

    "baseUrl": ".",

    "paths": {

      "*": ["../deps/*"]

    },

    "allowJs": true,

    "noEmit": true

  },

  "include": ["js/**/*"]

}

const plugin = require("tailwindcss/plugin")

const fs = require("fs")

const path = require("path")

module.exports = plugin(function({matchComponents, theme}) {

  let iconsDir = path.join(__dirname, "../../deps/heroicons/optimized")

  let values = {}

  let icons = [

    ["", "/24/outline"],

    ["-solid", "/24/solid"],

    ["-mini", "/20/solid"],

    ["-micro", "/16/solid"]

  ]

  icons.forEach(([suffix, dir]) => {

    fs.readdirSync(path.join(iconsDir, dir)).forEach(file => {

      let name = path.basename(file, ".svg") + suffix

      values[name] = {name, fullPath: path.join(iconsDir, dir, file)}

    })

  })

  matchComponents({

    "hero": ({name, fullPath}) => {

      let content = fs.readFileSync(fullPath).toString().replace(/\r?\n|\r/g, "")

      content = encodeURIComponent(content)

      let size = theme("spacing.6")

      if (name.endsWith("-mini")) {

        size = theme("spacing.5")

      } else if (name.endsWith("-micro")) {

        size = theme("spacing.4")

      }

      return {

        [`--hero-${name}`]: `url('data:image/svg+xml;utf8,${content}')`,

        "-webkit-mask": `var(--hero-${name})`,

        "mask": `var(--hero-${name})`,

        "mask-repeat": "no-repeat",

        "background-color": "currentColor",

        "vertical-align": "middle",

        "display": "inline-block",

        "width": size,

        "height": size

      }

    }

  }, {values})

})

/**

 * @license MIT

 * topbar 3.0.0

 * http://buunguyen.github.io/topbar

 * Copyright (c) 2024 Buu Nguyen

 */

(function (window, document) {

  "use strict";

  var canvas,

    currentProgress,

    showing,

    progressTimerId = null,

    fadeTimerId = null,

    delayTimerId = null,

    addEvent = function (elem, type, handler) {

      if (elem.addEventListener) elem.addEventListener(type, handler, false);

      else if (elem.attachEvent) elem.attachEvent("on" + type, handler);

      else elem["on" + type] = handler;

    },

    options = {

      autoRun: true,

      barThickness: 3,

      barColors: {

        0: "rgba(26,  188, 156, .9)",

        ".25": "rgba(52,  152, 219, .9)",

        ".50": "rgba(241, 196, 15,  .9)",

        ".75": "rgba(230, 126, 34,  .9)",

        "1.0": "rgba(211, 84,  0,   .9)",

      },

      shadowBlur: 10,

      shadowColor: "rgba(0,   0,   0,   .6)",

      className: null,

    },

    repaint = function () {

      canvas.width = window.innerWidth;

      canvas.height = options.barThickness * 5; // need space for shadow

      var ctx = canvas.getContext("2d");

      ctx.shadowBlur = options.shadowBlur;

      ctx.shadowColor = options.shadowColor;

      var lineGradient = ctx.createLinearGradient(0, 0, canvas.width, 0);

      for (var stop in options.barColors)

        lineGradient.addColorStop(stop, options.barColors[stop]);

      ctx.lineWidth = options.barThickness;

      ctx.beginPath();

      ctx.moveTo(0, options.barThickness / 2);

      ctx.lineTo(

        Math.ceil(currentProgress * canvas.width),

        options.barThickness / 2

      );

      ctx.strokeStyle = lineGradient;

      ctx.stroke();

    },

    createCanvas = function () {

      canvas = document.createElement("canvas");

      var style = canvas.style;

      style.position = "fixed";

      style.top = style.left = style.right = style.margin = style.padding = 0;

      style.zIndex = 100001;

      style.display = "none";

      if (options.className) canvas.classList.add(options.className);

      addEvent(window, "resize", repaint);

    },

    topbar = {

      config: function (opts) {

        for (var key in opts)

          if (options.hasOwnProperty(key)) options[key] = opts[key];

      },

      show: function (delay) {

        if (showing) return;

        if (delay) {

          if (delayTimerId) return;

          delayTimerId = setTimeout(() => topbar.show(), delay);

        } else {

          showing = true;

          if (fadeTimerId !== null) window.cancelAnimationFrame(fadeTimerId);

          if (!canvas) createCanvas();

          if (!canvas.parentElement) document.body.appendChild(canvas);

          canvas.style.opacity = 1;

          canvas.style.display = "block";

          topbar.progress(0);

          if (options.autoRun) {

            (function loop() {

              progressTimerId = window.requestAnimationFrame(loop);

              topbar.progress(

                "+" + 0.05 * Math.pow(1 - Math.sqrt(currentProgress), 2)

              );

            })();

          }

        }

      },

      progress: function (to) {

        if (typeof to === "undefined") return currentProgress;

        if (typeof to === "string") {

          to =

            (to.indexOf("+") >= 0 || to.indexOf("-") >= 0

              ? currentProgress

              : 0) + parseFloat(to);

        }

        currentProgress = to > 1 ? 1 : to;

        repaint();

        return currentProgress;

      },

      hide: function () {

        clearTimeout(delayTimerId);

        delayTimerId = null;

        if (!showing) return;

        showing = false;

        if (progressTimerId != null) {

          window.cancelAnimationFrame(progressTimerId);

          progressTimerId = null;

        }

        (function loop() {

          if (topbar.progress("+.1") >= 1) {

            canvas.style.opacity -= 0.05;

            if (canvas.style.opacity <= 0.05) {

              canvas.style.display = "none";

              fadeTimerId = null;

              return;

            }

          }

          fadeTimerId = window.requestAnimationFrame(loop);

        })();

      },

    };

  if (typeof module === "object" && typeof module.exports === "object") {

    module.exports = topbar;

  } else if (typeof define === "function" && define.amd) {

    define(function () {

      return topbar;

    });

  } else {

    this.topbar = topbar;

  }

}.call(this, window, document));

# This file is responsible for configuring your application

# and its dependencies with the aid of the Config module.

#

# This configuration file is loaded before any dependency and

# is restricted to this project.

# General application configuration

import Config

config :openagents,

  namespace: OpenAgents,

  ecto_repos: [OpenAgents.Repo],

  generators: [timestamp_type: :utc_datetime]

# Configure the endpoint

config :openagents, OpenAgentsWeb.Endpoint,

  url: [host: "localhost"],

  adapter: Bandit.PhoenixAdapter,

  render_errors: [

    formats: [html: OpenAgentsWeb.ErrorHTML, json: OpenAgentsWeb.ErrorJSON],

    layout: false

  ],

  pubsub_server: OpenAgents.PubSub,

  live_view: [signing_salt: "VjtdwdCq"]

# Configure LiveView

config :phoenix_live_view,

  # the attribute set on all root tags. Used for Phoenix.LiveView.ColocatedCSS.

  root_tag_attribute: "phx-r"

# Configure the mailer

#

# By default it uses the "Local" adapter which stores the emails

# locally. You can see the emails in your browser, at "/dev/mailbox".

#

# For production it's recommended to configure a different adapter

# at the `config/runtime.exs`.

config :openagents, OpenAgents.Mailer, adapter: Swoosh.Adapters.Local

# Configure esbuild (the version is required)

config :esbuild,

  version: "0.25.4",

  openagents: [

    args:

      ~w(js/app.js --bundle --target=es2022 --outdir=../priv/static/assets/js --external:/fonts/* --external:/images/* --alias:@=.),

    cd: Path.expand("../assets", __DIR__),

    env: %{"NODE_PATH" => [Path.expand("../deps", __DIR__), Mix.Project.build_path()]}

  ]

# Configure tailwind (the version is required)

config :tailwind,

  version: "4.3.0",

  openagents: [

    args: ~w(

      --input=assets/css/app.css

      --output=priv/static/assets/css/app.css

    ),

    cd: Path.expand("..", __DIR__),

    env: %{"NODE_PATH" => [Path.expand("../deps", __DIR__), Mix.Project.build_path()]}

  ]

# Configure Elixir's Logger

config :logger, :default_formatter,

  format: "$time $metadata[$level] $message\n",

  metadata: [:request_id]

# Use Jason for JSON parsing in Phoenix

config :phoenix, :json_library, Jason

# Import environment specific config. This must remain at the bottom

# of this file so it overrides the configuration defined above.

import_config "#{config_env()}.exs"

import Config

# Configure your database

config :openagents, OpenAgents.Repo,

  username: "postgres",

  password: "postgres",

  hostname: "localhost",

  database: "openagents_dev",

  stacktrace: true,

  show_sensitive_data_on_connection_error: true,

  pool_size: 10

# For development, we disable any cache and enable

# debugging and code reloading.

#

# The watchers configuration can be used to run external

# watchers to your application. For example, we can use it

# to bundle .js and .css sources.

config :openagents, OpenAgentsWeb.Endpoint,

  # Binding to loopback ipv4 address prevents access from other machines.

  # Change to `ip: {0, 0, 0, 0}` to allow access from other machines.

  http: [ip: {127, 0, 0, 1}],

  check_origin: false,

  code_reloader: true,

  debug_errors: true,

  secret_key_base: "7g8XzqhjERSKPxluld+DgJttpl7vypiQg2/6wR+5AJmONkFmEzX5pQnUsdGnH/v2",

  watchers: [

    esbuild: {Esbuild, :install_and_run, [:openagents, ~w(--sourcemap=inline --watch)]},

    tailwind: {Tailwind, :install_and_run, [:openagents, ~w(--watch)]}

  ]

# ## SSL Support

#

# In order to use HTTPS in development, a self-signed

# certificate can be generated by running the following

# Mix task:

#

#     mix phx.gen.cert

#

# Run `mix help phx.gen.cert` for more information.

#

# The `http:` config above can be replaced with:

#

#     https: [

#       port: 4001,

#       cipher_suite: :strong,

#       keyfile: "priv/cert/selfsigned_key.pem",

#       certfile: "priv/cert/selfsigned.pem"

#     ],

#

# If desired, both `http:` and `https:` keys can be

# configured to run both http and https servers on

# different ports.

# Enable dev routes for dashboard and mailbox

config :openagents, dev_routes: true

# Do not include metadata nor timestamps in development logs

config :logger, :default_formatter, format: "[$level] $message\n"

# Set a higher stacktrace during development. Avoid configuring such

# in production as building large stacktraces may be expensive.

config :phoenix, :stacktrace_depth, 20

# Initialize plugs at runtime for faster development compilation

config :phoenix, :plug_init_mode, :runtime

config :phoenix_live_view,

  # Include debug annotations and locations in rendered markup.

  # Changing this configuration will require mix clean and a full recompile.

  debug_heex_annotations: true,

  debug_attributes: true,

  # Enable helpful, but potentially expensive runtime checks

  enable_expensive_runtime_checks: true

# Disable swoosh api client as it is only required for production adapters.

config :swoosh, :api_client, false

import Config

# Note we also include the path to a cache manifest

# containing the digested version of static files. This

# manifest is generated by the `mix assets.deploy` task,

# which you should run after static files are built and

# before starting your production server.

config :openagents, OpenAgentsWeb.Endpoint,

  cache_static_manifest: "priv/static/cache_manifest.json"

# Force using SSL in production. This also sets the "strict-security-transport" header,

# known as HSTS. If you have a health check endpoint, you may want to exclude it below.

# Note `:force_ssl` is required to be set at compile-time.

config :openagents, OpenAgentsWeb.Endpoint,

  force_ssl: [

    rewrite_on: [:x_forwarded_proto],

    exclude: [

      # paths: ["/health"],

      hosts: ["localhost", "127.0.0.1"]

    ]

  ]

# Configure Swoosh API Client

config :swoosh, api_client: Swoosh.ApiClient.Req

# Disable Swoosh Local Memory Storage

config :swoosh, local: false

# Do not print debug messages in production

config :logger, level: :info

# Runtime production configuration, including reading

# of environment variables, is done on config/runtime.exs.

import Config

# config/runtime.exs is executed for all environments, including

# during releases. It is executed after compilation and before the

# system starts, so it is typically used to load production configuration

# and secrets from environment variables or elsewhere. Do not define

# any compile-time configuration in here, as it won't be applied.

# The block below contains prod specific runtime configuration.

# ## Using releases

#

# If you use `mix release`, you need to explicitly enable the server

# by passing the PHX_SERVER=true when you start it:

#

#     PHX_SERVER=true bin/openagents start

#

# Alternatively, you can use `mix phx.gen.release` to generate a `bin/server`

# script that automatically sets the env var above.

if System.get_env("PHX_SERVER") do

  config :openagents, OpenAgentsWeb.Endpoint, server: true

end

config :openagents, OpenAgentsWeb.Endpoint,

  http: [port: String.to_integer(System.get_env("PORT", "4000"))]

if config_env() == :dev do

  # Reload browser tabs when matching files change.

  config :openagents, OpenAgentsWeb.Endpoint,

    live_reload: [

      web_console_logger: true,

      patterns: [

        # Static assets, except user uploads

        ~r"priv/static/(?!uploads/).*\.(js|css|png|jpeg|jpg|gif|svg)$"E,

        # Gettext translations

        ~r"priv/gettext/.*\.po$"E,

        # Router, Controllers, LiveViews and LiveComponents

        ~r"lib/openagents_web/router\.ex$"E,

        ~r"lib/openagents_web/(controllers|live|components)/.*\.(ex|heex)$"E

      ]

    ]

end

if config_env() == :prod do

  database_url =

    System.get_env("DATABASE_URL") ||

      raise """

      environment variable DATABASE_URL is missing.

      For example: ecto://USER:PASS@HOST/DATABASE

      """

  maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: []

  config :openagents, OpenAgents.Repo,

    # ssl: true,

    url: database_url,

    pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10"),

    # For machines with several cores, consider starting multiple pools of `pool_size`

    # pool_count: 4,

    socket_options: maybe_ipv6

  # The secret key base is used to sign/encrypt cookies and other secrets.

  # A default value is used in config/dev.exs and config/test.exs but you

  # want to use a different value for prod and you most likely don't want

  # to check this value into version control, so we use an environment

  # variable instead.

  secret_key_base =

    System.get_env("SECRET_KEY_BASE") ||

      raise """

      environment variable SECRET_KEY_BASE is missing.

      You can generate one by calling: mix phx.gen.secret

      """

  host = System.get_env("PHX_HOST") || "example.com"

  config :openagents, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY")

  config :openagents, OpenAgentsWeb.Endpoint,

    url: [host: host, port: 443, scheme: "https"],

    http: [

      # Enable IPv6 and bind on all interfaces.

      # Set it to  {0, 0, 0, 0, 0, 0, 0, 1} for local network only access.

      # See the documentation on https://bandit.hexdocs.pm/Bandit.html#t:options/0

      # for details about using IPv6 vs IPv4 and loopback vs public addresses.

      ip: {0, 0, 0, 0, 0, 0, 0, 0}

    ],

    secret_key_base: secret_key_base

  # ## SSL Support

  #

  # To get SSL working, you will need to add the `https` key

  # to your endpoint configuration:

  #

  #     config :openagents, OpenAgentsWeb.Endpoint,

  #       https: [

  #         ...,

  #         port: 443,

  #         cipher_suite: :strong,

  #         keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),

  #         certfile: System.get_env("SOME_APP_SSL_CERT_PATH")

  #       ]

  #

  # The `cipher_suite` is set to `:strong` to support only the

  # latest and more secure SSL ciphers. This means old browsers

  # and clients may not be supported. You can set it to

  # `:compatible` for wider support.

  #

  # `:keyfile` and `:certfile` expect an absolute path to the key

  # and cert in disk or a relative path inside priv, for example

  # "priv/ssl/server.key". For all supported SSL configuration

  # options, see https://plug.hexdocs.pm/Plug.SSL.html#configure/1

  #

  # We also recommend setting `force_ssl` in your config/prod.exs,

  # ensuring no data is ever sent via http, always redirecting to https:

  #

  #     config :openagents, OpenAgentsWeb.Endpoint,

  #       force_ssl: [hsts: true]

  #

  # Check `Plug.SSL` for all available options in `force_ssl`.

  # ## Configuring the mailer

  #

  # In production you need to configure the mailer to use a different adapter.

  # Here is an example configuration for Mailgun:

  #

  #     config :openagents, OpenAgents.Mailer,

  #       adapter: Swoosh.Adapters.Mailgun,

  #       api_key: System.get_env("MAILGUN_API_KEY"),

  #       domain: System.get_env("MAILGUN_DOMAIN")

  #

  # Most non-SMTP adapters require an API client. Swoosh supports Req, Hackney,

  # and Finch out-of-the-box. This configuration is typically done at

  # compile-time in your config/prod.exs:

  #

  #     config :swoosh, :api_client, Swoosh.ApiClient.Req

  #

  # See https://swoosh.hexdocs.pm/Swoosh.html#module-installation for details.

end

import Config

# Configure your database

#

# The MIX_TEST_PARTITION environment variable can be used

# to provide built-in test partitioning in CI environment.

# Run `mix help test` for more information.

config :openagents, OpenAgents.Repo,

  username: "postgres",

  password: "postgres",

  hostname: "localhost",

  database: "openagents_test#{System.get_env("MIX_TEST_PARTITION")}",

  pool: Ecto.Adapters.SQL.Sandbox,

  pool_size: System.schedulers_online() * 2

# We don't run a server during test. If one is required,

# you can enable the server option below.

config :openagents, OpenAgentsWeb.Endpoint,

  http: [ip: {127, 0, 0, 1}, port: 4002],

  secret_key_base: "Qg1oZEw1M0GnySDRZ1qJJRZltEFZUQGzBDGsfaLxgKA1EowbYm9EDSYYznEsY8KE",

  server: false

# In test we don't send emails

config :openagents, OpenAgents.Mailer, adapter: Swoosh.Adapters.Test

# Disable swoosh api client as it is only required for production adapters

config :swoosh, :api_client, false

# Print only warnings and errors during test

config :logger, level: :warning

# Initialize plugs at runtime for faster test compilation

config :phoenix, :plug_init_mode, :runtime

# Enable helpful, but potentially expensive runtime checks

config :phoenix_live_view,

  enable_expensive_runtime_checks: true

# Sort query params output of verified routes for robust url comparisons

config :phoenix,

  sort_verified_routes_query_params: true

defmodule OpenAgents do

  @moduledoc """

  OpenAgents keeps the contexts that define your domain

  and business logic.

  Contexts are also responsible for managing your data, regardless

  if it comes from the database, an external API or others.

  """

end

defmodule OpenAgents.Application do

  # See https://elixir.hexdocs.pm/Application.html

  # for more information on OTP Applications

  @moduledoc false

  use Application

  @impl true

  def start(_type, _args) do

    children = [

      OpenAgentsWeb.Telemetry,

      OpenAgents.Repo,

      {DNSCluster, query: Application.get_env(:openagents, :dns_cluster_query) || :ignore},

      {Phoenix.PubSub, name: OpenAgents.PubSub},

      # Start a worker by calling: OpenAgents.Worker.start_link(arg)

      # {OpenAgents.Worker, arg},

      # Start to serve requests, typically the last entry

      OpenAgentsWeb.Endpoint

    ]

    # See https://elixir.hexdocs.pm/Supervisor.html

    # for other strategies and supported options

    opts = [strategy: :one_for_one, name: OpenAgents.Supervisor]

    Supervisor.start_link(children, opts)

  end

  # Tell Phoenix to update the endpoint configuration

  # whenever the application is updated.

  @impl true

  def config_change(changed, _new, removed) do

    OpenAgentsWeb.Endpoint.config_change(changed, removed)

    :ok

  end

end

defmodule OpenAgents.Mailer do

  use Swoosh.Mailer, otp_app: :openagents

end

defmodule OpenAgents.Repo do

  use Ecto.Repo,

    otp_app: :openagents,

    adapter: Ecto.Adapters.Postgres

end

defmodule OpenAgentsWeb do

  @moduledoc """

  The entrypoint for defining your web interface, such

  as controllers, components, channels, and so on.

  This can be used in your application as:

      use OpenAgentsWeb, :controller

      use OpenAgentsWeb, :html

  The definitions below will be executed for every controller,

  component, etc, so keep them short and clean, focused

  on imports, uses and aliases.

  Do NOT define functions inside the quoted expressions

  below. Instead, define additional modules and import

  those modules here.

  """

  def static_paths, do: ~w(assets fonts images favicon.ico robots.txt)

  def router do

    quote do

      use Phoenix.Router, helpers: false

      # Import common connection and controller functions to use in pipelines

      import Plug.Conn

      import Phoenix.Controller

      import Phoenix.LiveView.Router

    end

  end

  def channel do

    quote do

      use Phoenix.Channel

    end

  end

  def controller do

    quote do

      use Phoenix.Controller, formats: [:html, :json]

      use Gettext, backend: OpenAgentsWeb.Gettext

      import Plug.Conn

      unquote(verified_routes())

    end

  end

  def live_view do

    quote do

      use Phoenix.LiveView

      unquote(html_helpers())

    end

  end

  def live_component do

    quote do

      use Phoenix.LiveComponent

      unquote(html_helpers())

    end

  end

  def html do

    quote do

      use Phoenix.Component

      # Import convenience functions from controllers

      import Phoenix.Controller,

        only: [get_csrf_token: 0, view_module: 1, view_template: 1]

      # Include general helpers for rendering HTML

      unquote(html_helpers())

    end

  end

  defp html_helpers do

    quote do

      # Translation

      use Gettext, backend: OpenAgentsWeb.Gettext

      # HTML escaping functionality

      import Phoenix.HTML

      # Core UI components

      import OpenAgentsWeb.CoreComponents

      # Common modules used in templates

      alias Phoenix.LiveView.JS

      alias OpenAgentsWeb.Layouts

      # Routes generation with the ~p sigil

      unquote(verified_routes())

    end

  end