FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// src/mcp/tools/WorkspaceTools_SymbolsActions.cpp
//
// Symbol-link-group tools (list / metadata / reset / get|set group + slot
// symbol / clear / get_active_symbol), action-registry tools (list / invoke
// / find), and the command-bar text dispatcher.
//
// Part of the topic-based split of WorkspaceTools.cpp.
#include "app/DockScreenRouter.h"
#include "app/TerminalShell.h"
#include "app/WindowFrame.h"
#include "core/actions/ActionDef.h"
#include "core/actions/ActionRegistry.h"
#include "core/identity/Uuid.h"
#include "core/layout/LayoutCatalog.h"
#include "core/layout/LayoutTemplates.h"
#include "core/layout/LayoutTypes.h"
#include "core/layout/WorkspaceShell.h"
#include "core/logging/Logger.h"
#include "core/panel/PanelHandle.h"
#include "core/panel/PanelRegistry.h"
#include "core/symbol/SymbolContext.h"
#include "core/symbol/SymbolGroup.h"
#include "core/symbol/SymbolGroupRegistry.h"
#include "core/symbol/SymbolRef.h"
#include "core/window/WindowRegistry.h"
#include "mcp/AsyncDispatch.h"
#include "mcp/ToolSchemaBuilder.h"
#include "mcp/tools/WorkspaceTools.h"
#include "mcp/tools/WorkspaceTools_internal.h"
#include "storage/workspace/CrashRecovery.h"
#include "storage/workspace/WorkspaceSnapshotRing.h"
#include <QApplication>
#include <QGuiApplication>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QRect>
#include <QRegularExpression>
#include <QScreen>
#include <QSize>
#include <algorithm>
namespace fincept::mcp::tools {
using namespace fincept::mcp::tools::workspace_internal;
void workspace_internal::register_symbol_action_tools(std::vector<ToolDef>& tools) {
// ═══════════════════════════════════════════════════════════════════
// SYMBOL LINK GROUPS (9)
// ═══════════════════════════════════════════════════════════════════
{
ToolDef t;
t.name = "list_symbol_groups";
t.description = "List all symbol link groups (A..J) with name, color, enabled flag, and current symbol.";
t.category = "workspace";
t.default_timeout_ms = kDefaultTimeoutMs;
t.async_handler = [](const QJsonObject&, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [](auto resolve) {
QJsonArray arr;
for (auto g : all_symbol_groups())
arr.append(group_to_json(g));
resolve(ToolResult::ok_data(arr));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "set_symbol_group_metadata";
t.description = "Update one or more of name / color / enabled for a symbol link group.";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("group", "Group letter A..J")
.required()
.length(1, 1)
.string("name", "New display name (empty to keep)")
.default_str("")
.length(0, 64)
.string("color", "New hex color #RRGGBB or #AARRGGBB (empty to keep)")
.default_str("")
.length(0, 16)
.boolean("enabled", "Whether the slot appears in cycle/menus")
.default_bool(true)
.boolean("apply_enabled", "Whether to apply the enabled value")
.default_bool(false)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
auto& reg = SymbolGroupRegistry::instance();
const QString name = args["name"].toString();
const QString color = args["color"].toString();
if (!name.isEmpty())
reg.set_name(g, name);
if (!color.isEmpty()) {
// QColor(<garbage>) is an invalid colour; installing it blanked the group's
// swatch while the tool reported success.
if (!QColor::isValidColorName(color)) {
resolve(ToolResult::fail("Invalid 'color' '" + color + "' — use #RRGGBB or #AARRGGBB"));
return;
}
reg.set_color(g, QColor(color));
}
if (args["apply_enabled"].toBool(false))
reg.set_enabled(g, args["enabled"].toBool());
resolve(ToolResult::ok("Group metadata updated", group_to_json(g)));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "reset_symbol_group";
t.description = "Reset a symbol link group to factory defaults (name, color, enabled).";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder().string("group", "Group letter A..J").required().length(1, 1).build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
SymbolGroupRegistry::instance().reset_to_default(g);
resolve(ToolResult::ok("Group reset", group_to_json(g)));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "get_group_symbol";
t.description = "Get the current symbol assigned to a link group's primary slot.";
t.category = "workspace";
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder().string("group", "Group letter A..J").required().length(1, 1).build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
const SymbolRef ref = SymbolContext::instance().group_symbol(g);
resolve(ToolResult::ok_data(QJsonObject{
{"group", QString(symbol_group_letter(g))},
{"symbol", ref.symbol},
{"exchange", ref.exchange},
{"asset_class", ref.asset_class},
{"display", ref.display()},
{"has_value", SymbolContext::instance().has_group_symbol(g)},
}));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "set_group_symbol";
t.description = "Push a symbol into a link group's primary slot. All linked panels update in lockstep.";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema =
ToolSchemaBuilder()
.string("group", "Group letter A..J")
.required()
.length(1, 1)
.string("symbol", "Ticker symbol")
.required()
.length(1, 32)
.string("exchange", "Exchange code")
.default_str("")
.length(0, 16)
.string("asset_class", "Asset class (equity, fx, crypto, future, bond, index, commodity, option)")
.default_str("")
.length(0, 16)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
SymbolRef ref;
ref.symbol = args["symbol"].toString().trimmed();
ref.exchange = args["exchange"].toString().trimmed();
ref.asset_class = args["asset_class"].toString().trimmed();
if (!ref.is_valid()) {
resolve(ToolResult::fail("'symbol' must not be blank"));
return;
}
SymbolContext::instance().set_group_symbol(g, ref, nullptr);
resolve(ToolResult::ok("Group symbol set", QJsonObject{{"group", QString(symbol_group_letter(g))},
{"symbol", ref.symbol}}));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "clear_symbol_group";
t.description = "Clear the symbol assigned to a link group's primary slot.";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder().string("group", "Group letter A..J").required().length(1, 1).build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
SymbolContext::instance().set_group_symbol(g, SymbolRef{}, nullptr);
resolve(ToolResult::ok("Group cleared", QJsonObject{{"group", QString(symbol_group_letter(g))}}));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "get_group_slot_symbol";
t.description =
"Get the symbol assigned to a (group, slot) pair. Slots include 'primary', 'comparison', 'currency'.";
t.category = "workspace";
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("group", "Group letter A..J")
.required()
.length(1, 1)
.string("slot", "Slot name")
.required()
.length(1, 32)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
const QString slot = args["slot"].toString();
const SymbolRef ref = SymbolContext::instance().group_slot_symbol(g, slot);
resolve(ToolResult::ok_data(QJsonObject{
{"group", QString(symbol_group_letter(g))},
{"slot", slot},
{"symbol", ref.symbol},
{"exchange", ref.exchange},
{"asset_class", ref.asset_class},
{"has_value", SymbolContext::instance().has_group_slot_symbol(g, slot)},
}));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "set_group_slot_symbol";
t.description = "Push a symbol into a (group, slot) pair.";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("group", "Group letter A..J")
.required()
.length(1, 1)
.string("slot", "Slot name")
.required()
.length(1, 32)
.string("symbol", "Ticker symbol")
.required()
.length(1, 32)
.string("exchange", "Exchange code")
.default_str("")
.length(0, 16)
.string("asset_class", "Asset class")
.default_str("")
.length(0, 16)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const SymbolGroup g = parse_group(args);
if (g == SymbolGroup::None) {
resolve(ToolResult::fail("Invalid group letter"));
return;
}
SymbolRef ref;
ref.symbol = args["symbol"].toString().trimmed();
ref.exchange = args["exchange"].toString().trimmed();
ref.asset_class = args["asset_class"].toString().trimmed();
if (!ref.is_valid()) {
resolve(ToolResult::fail("'symbol' must not be blank"));
return;
}
SymbolContext::instance().set_group_slot_symbol(g, args["slot"].toString(), ref, nullptr);
resolve(ToolResult::ok("Slot symbol set", QJsonObject{{"group", QString(symbol_group_letter(g))},
{"slot", args["slot"].toString()},
{"symbol", ref.symbol}}));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "get_active_symbol";
t.description = "Get the most recently touched symbol anywhere in the app (group or not).";
t.category = "workspace";
t.default_timeout_ms = kDefaultTimeoutMs;
t.async_handler = [](const QJsonObject&, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [](auto resolve) {
const SymbolRef ref = SymbolContext::instance().active();
resolve(ToolResult::ok_data(QJsonObject{
{"symbol", ref.symbol},
{"exchange", ref.exchange},
{"asset_class", ref.asset_class},
{"display", ref.display()},
}));
});
};
tools.push_back(std::move(t));
}
// ═══════════════════════════════════════════════════════════════════
// ACTION REGISTRY (3)
// ═══════════════════════════════════════════════════════════════════
{
ToolDef t;
t.name = "list_actions";
t.description = "List registered shell actions (id, display, category, hotkey, parameter slots). The "
"registry is large — use find_actions to search, or pass `category` / `limit` here.";
t.category = "workspace";
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("category", "Only actions in this category (case-insensitive; empty = all)")
.default_str("")
.length(0, 64)
.integer("limit", "Max actions to return")
.default_int(100)
.between(1, 500)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const QString want_cat = args["category"].toString().trimmed();
const int limit = std::clamp(args["limit"].toInt(100), 1, 500);
QJsonArray arr;
int matched = 0;
for (const auto& id : ActionRegistry::instance().all_ids()) {
auto* a = ActionRegistry::instance().find(id);
if (!a)
continue;
if (!want_cat.isEmpty() && a->category.compare(want_cat, Qt::CaseInsensitive) != 0)
continue;
++matched;
if (arr.size() < limit)
arr.append(action_to_json(*a));
}
if (matched > arr.size()) {
resolve(ToolResult::ok(QString("Showing %1 of %2 actions — pass `category`, raise `limit` (max "
"500), or use find_actions to search.")
.arg(arr.size())
.arg(matched),
arr));
return;
}
resolve(ToolResult::ok_data(arr));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "invoke_action";
t.description =
"Invoke a registered shell action by id with optional args (matches command-bar / palette behaviour).";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("id", "Action id (e.g. 'frame.toggle_focus_mode', 'layout.save')")
.required()
.length(1, 128)
.object("args", "Per-action argument map keyed by parameter_slot.name")
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
CommandContext c;
c.shell = &TerminalShell::instance();
c.focused_frame = qobject_cast<WindowFrame*>(qApp->activeWindow());
const QJsonObject extra = args["args"].toObject();
for (auto it = extra.constBegin(); it != extra.constEnd(); ++it)
c.args.insert(it.key(), it.value().toVariant());
auto r = ActionRegistry::instance().invoke(args["id"].toString(), c);
if (r.is_err()) {
resolve(ToolResult::fail(QString::fromStdString(r.error())));
return;
}
resolve(ToolResult::ok("Action invoked", QJsonObject{{"id", args["id"].toString()}}));
});
};
tools.push_back(std::move(t));
}
{
ToolDef t;
t.name = "find_actions";
t.description = "Prefix-match registered actions (palette-style autocomplete).";
t.category = "workspace";
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("prefix", "Search prefix (matched against id, display, aliases)")
.required()
.length(1, 64)
.integer("max_results", "Max results")
.default_int(25)
.between(1, 200)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
const auto matches =
ActionRegistry::instance().match(args["prefix"].toString(), args["max_results"].toInt(25));
QJsonArray arr;
for (auto* a : matches)
if (a)
arr.append(action_to_json(*a));
resolve(ToolResult::ok_data(arr));
});
};
tools.push_back(std::move(t));
}
// ═══════════════════════════════════════════════════════════════════
// COMMAND-BAR (1)
// ═══════════════════════════════════════════════════════════════════
{
ToolDef t;
t.name = "run_command_bar_text";
t.description = "Run a raw command-bar string using EXACT screen ids ('dashboard add news', 'markets replace "
"settings', 'news remove', or a bare id to navigate) against the focused window. Unknown "
"ids are rejected — list_available_screen_ids shows the valid ones.";
t.category = "workspace";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("text", "Command-bar text (e.g. 'dashboard add news')")
.required()
.length(1, 256)
.integer("window_id", "Target window (-1 = focused)")
.default_int(-1)
.min(-1)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
run_on_ui(std::move(ctx), promise, [args](auto resolve) {
auto* w = resolve_window(args);
if (!w || !w->dock_router()) {
resolve(ToolResult::fail("Window not found"));
return;
}
// Inline parser — mirrors CommandBar_Suggestions::try_parse_dock_command.
const QString text = args["text"].toString().trimmed();
static const QRegularExpression re_add(R"(^(.+?)\s+add\s+(.+)$)",
QRegularExpression::CaseInsensitiveOption);
static const QRegularExpression re_replace(R"(^(.+?)\s+replace\s+(.+)$)",
QRegularExpression::CaseInsensitiveOption);
static const QRegularExpression re_remove(R"(^(.+?)\s+remove$)",
QRegularExpression::CaseInsensitiveOption);
auto m_add = re_add.match(text);
auto m_rep = re_replace.match(text);
auto m_rem = re_remove.match(text);
// The router calls below are void and just log for a screen id that does not
// exist, so every typo came back as "Added alongside" / "Navigated". Check the
// ids against the live registry first and report the bad one.
const QStringList known_ids = w->dock_router()->all_screen_ids();
auto unknown_id = [&known_ids](const QString& id) { return !known_ids.contains(id); };
QString bad;
if (m_add.hasMatch()) {
bad = unknown_id(m_add.captured(1).trimmed()) ? m_add.captured(1).trimmed()
: (unknown_id(m_add.captured(2).trimmed())
? m_add.captured(2).trimmed()
: QString());
} else if (m_rep.hasMatch()) {
bad = unknown_id(m_rep.captured(1).trimmed()) ? m_rep.captured(1).trimmed()
: (unknown_id(m_rep.captured(2).trimmed())
? m_rep.captured(2).trimmed()
: QString());
} else if (m_rem.hasMatch()) {
bad = unknown_id(m_rem.captured(1).trimmed()) ? m_rem.captured(1).trimmed() : QString();
} else {
bad = unknown_id(text) ? text : QString();
}
if (!bad.isEmpty()) {
resolve(ToolResult::fail("Unknown screen id '" + bad +
"' — use list_available_screen_ids for the valid ids"));
return;
}
if (m_add.hasMatch()) {
w->dock_router()->add_alongside(m_add.captured(1).trimmed(), m_add.captured(2).trimmed());
resolve(ToolResult::ok("Added alongside", QJsonObject{{"action", "add"},
{"primary", m_add.captured(1).trimmed()},
{"secondary", m_add.captured(2).trimmed()}}));
return;
}
if (m_rep.hasMatch()) {
w->dock_router()->replace_screen(m_rep.captured(1).trimmed(), m_rep.captured(2).trimmed());
resolve(ToolResult::ok("Replaced", QJsonObject{{"action", "replace"},
{"primary", m_rep.captured(1).trimmed()},
{"secondary", m_rep.captured(2).trimmed()}}));
return;
}
if (m_rem.hasMatch()) {
// remove_screen() closes every other panel before looking the kept one up; for
// a screen with no dock widget yet that would close them all and open nothing.
if (w->dock_router()->find_dock_widget(m_rem.captured(1).trimmed()))
w->dock_router()->remove_screen(m_rem.captured(1).trimmed());
else
w->dock_router()->navigate(m_rem.captured(1).trimmed(), /*exclusive=*/true);
resolve(ToolResult::ok(
"Removed", QJsonObject{{"action", "remove"}, {"primary", m_rem.captured(1).trimmed()}}));
return;
}
// Bare screen id → just navigate.
w->dock_router()->navigate(text);
resolve(ToolResult::ok("Navigated", QJsonObject{{"action", "navigate"}, {"screen_id", text}}));
});
};
tools.push_back(std::move(t));
}
}
} // namespace fincept::mcp::tools