feat: Add agents and agents settings

sources/agents/AgentFactory.cpp

@@ -0,0 +1,223 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "AgentFactory.hpp"
+
+#include <QLoggingCategory>
+#include <QThread>
+
+#include <coreplugin/icore.h>
+
+#include "Agent.hpp"
+#include "AgentLoader.hpp"
+#include "Provider.hpp"
+#include "ProviderFactory.hpp"
+#include "Logger.hpp"
+#include "ProviderSecretsStore.hpp"
+#include "ProviderInstance.hpp"
+#include "ProviderInstanceFactory.hpp"
+
+static inline void initAgentsResource() { Q_INIT_RESOURCE(agents); }
+
+namespace {
+Q_LOGGING_CATEGORY(agentFactoryLog, "qodeassist.agentfactory")
+
+QString agentQrcPrefix() { return QStringLiteral(":/agents"); }
+} // namespace
+
+namespace QodeAssist {
+
+AgentFactory::AgentFactory(
+    Providers::ProviderInstanceFactory *instanceFactory,
+    Providers::ProviderSecretsStore *secrets,
+    QObject *parent)
+    : QObject(parent)
+    , m_instanceFactory(instanceFactory)
+    , m_secrets(secrets)
+{
+    ::initAgentsResource();
+    reload();
+}
+
+AgentFactory::~AgentFactory() = default;
+
+QString AgentFactory::userAgentsDir()
+{
+    return Core::ICore::userResourcePath(QStringLiteral("qodeassist/config/agents"))
+        .toFSPathString();
+}
+
+void AgentFactory::reload()
+{
+    Q_ASSERT(thread() == QThread::currentThread());
+    clear();
+
+    auto result = Agents::AgentLoader::load(agentQrcPrefix(), userAgentsDir());
+    for (const QString &err : result.errors)
+        LOG_MESSAGE(QString("[Agents] error: %1").arg(err));
+    for (const QString &warn : result.warnings)
+        LOG_MESSAGE(QString("[Agents] warning: %1").arg(warn));
+    LOG_MESSAGE(QString("[Agents] Loaded %1 profiles (qrc=%2, user=%3)")
+                    .arg(result.configs.size())
+                    .arg(agentQrcPrefix(), userAgentsDir()));
+
+    for (auto &cfg : result.configs) {
+        LOG_MESSAGE(QString("[Agents] Loaded: %1").arg(cfg.name));
+        registerConfig(std::move(cfg));
+    }
+    m_errors = std::move(result.errors);
+    m_warnings = std::move(result.warnings);
+}
+
+void AgentFactory::registerConfig(AgentConfig config)
+{
+    Q_ASSERT(thread() == QThread::currentThread());
+
+    const QString error = AgentConfig::validate(config);
+    if (!error.isEmpty()) {
+        qCWarning(agentFactoryLog).noquote() << "Rejected agent config:" << error;
+        return;
+    }
+    const auto it = m_indexByName.constFind(config.name);
+    if (it != m_indexByName.constEnd()) {
+        m_configs[it.value()] = std::move(config);
+        return;
+    }
+    m_indexByName.insert(config.name, static_cast<qsizetype>(m_configs.size()));
+    m_configs.push_back(std::move(config));
+}
+
+const AgentConfig *AgentFactory::configByName(const QString &name) const
+{
+    const auto it = m_indexByName.constFind(name);
+    if (it == m_indexByName.constEnd())
+        return nullptr;
+    return &m_configs[it.value()];
+}
+
+QStringList AgentFactory::configNames() const
+{
+    QStringList out;
+    out.reserve(static_cast<qsizetype>(m_configs.size()));
+    for (const auto &c : m_configs) {
+        if (c.hidden) continue;
+        out.append(c.name);
+    }
+    return out;
+}
+
+namespace {
+
+Providers::Provider *buildProviderForAgent(
+    const AgentConfig &cfg,
+    Providers::ProviderInstanceFactory *instanceFactory,
+    Providers::ProviderSecretsStore *secrets,
+    QString *errorOut)
+{
+    if (!instanceFactory) {
+        if (errorOut) {
+            *errorOut = QStringLiteral(
+                            "Agent '%1' cannot be built — no ProviderInstanceFactory was wired "
+                            "into AgentFactory")
+                            .arg(cfg.name);
+        }
+        return nullptr;
+    }
+    const Providers::ProviderInstance *inst
+        = instanceFactory->instanceByName(cfg.providerInstance);
+    if (!inst) {
+        if (errorOut) {
+            *errorOut = QStringLiteral(
+                            "Agent '%1' references unknown provider instance '%2'")
+                            .arg(cfg.name, cfg.providerInstance);
+        }
+        return nullptr;
+    }
+    const QString validation = Providers::ProviderInstance::validate(
+        *inst, Providers::ProviderFactory::knownNames());
+    if (!validation.isEmpty()) {
+        if (errorOut)
+            *errorOut = validation;
+        return nullptr;
+    }
+    Providers::Provider *provider = Providers::ProviderFactory::create(inst->clientApi, nullptr);
+    if (!provider) {
+        if (errorOut) {
+            *errorOut = QStringLiteral("Client API '%1' is not registered (instance '%2')")
+                            .arg(inst->clientApi, inst->name);
+        }
+        return nullptr;
+    }
+    provider->setUrl(inst->url);
+    if (secrets && !inst->apiKeyRef.isEmpty())
+        provider->setApiKey(secrets->readKeySync(inst->apiKeyRef));
+    return provider;
+}
+
+} // namespace
+
+Agent *AgentFactory::create(const QString &name, QObject *parent, QString *errorOut) const
+{
+    const AgentConfig *cfg = configByName(name);
+    if (!cfg) {
+        if (errorOut)
+            *errorOut = QStringLiteral("Agent '%1' is not registered").arg(name);
+        return nullptr;
+    }
+    Providers::Provider *provider = buildProviderForAgent(
+        *cfg, m_instanceFactory.data(), m_secrets.data(), errorOut);
+    if (!provider)
+        return nullptr;
+    auto agent = std::make_unique<Agent>(*cfg, provider, /*parent=*/nullptr);
+    if (!agent->isValid()) {
+        if (errorOut)
+            *errorOut = agent->invalidReason();
+        return nullptr;
+    }
+    agent->setParent(parent);
+    return agent.release();
+}
+
+Agent *AgentFactory::createFromFile(
+    const QString &tomlPath, QObject *parent, QString *errorOut) const
+{
+    QString parseErr;
+    QStringList warnings;
+    auto cfgOpt = Agents::AgentLoader::parseFile(tomlPath, &parseErr, &warnings);
+    if (!cfgOpt) {
+        if (errorOut) *errorOut = parseErr;
+        return nullptr;
+    }
+    Providers::Provider *provider = buildProviderForAgent(
+        *cfgOpt, m_instanceFactory.data(), m_secrets.data(), errorOut);
+    if (!provider)
+        return nullptr;
+    auto agent = std::make_unique<Agent>(std::move(*cfgOpt), provider, /*parent=*/nullptr);
+    if (!agent->isValid()) {
+        if (errorOut) *errorOut = agent->invalidReason();
+        return nullptr;
+    }
+    agent->setParent(parent);
+    return agent.release();
+}
+
+void AgentFactory::clear()
+{
+    Q_ASSERT(thread() == QThread::currentThread());
+    m_configs.clear();
+    m_indexByName.clear();
+    m_errors.clear();
+    m_warnings.clear();
+}
+
+Providers::ProviderInstanceFactory *AgentFactory::instanceFactory() const noexcept
+{
+    return m_instanceFactory.data();
+}
+
+Providers::ProviderSecretsStore *AgentFactory::secretsStore() const noexcept
+{
+    return m_secrets.data();
+}
+
+} // namespace QodeAssist