Merge branch 'feature/script-live' into feature/script-live-ask-first

cmake/qet_compilation_vars.cmake

@@ -930,6 +930,8 @@ list(APPEND QET_SRC_FILES
   ${QET_DIR}/sources/scripting/scriptmanagerdialog.h
   ${QET_DIR}/sources/scripting/liveserver.cpp
   ${QET_DIR}/sources/scripting/liveserver.h
+  ${QET_DIR}/sources/scripting/assistantinfo.cpp
+  ${QET_DIR}/sources/scripting/assistantinfo.h
 )
 
 if(QET_SPACEMOUSE_ENABLED)

sources/qetdiagrameditor.cpp

@@ -21,6 +21,7 @@
 #include "scripting/scriptlibrary.h"
 #include "scripting/scriptmanagerdialog.h"
 #include "scripting/liveserver.h"
+#include "scripting/assistantinfo.h"
 #endif
 #include <QCoreApplication>
 #include <QToolButton>
@@ -1391,6 +1392,7 @@ void QETDiagramEditor::setUpMenu()
 	rebuildScriptActions();
 	connect(&ScriptLibrary::instance(), &ScriptLibrary::changed,
 		this, &QETDiagramEditor::rebuildScriptActions);
+	AssistantInfo::watch();
 #endif
 #ifdef QET_EXPORT_PROJECT_DB
 	menu_project -> addSeparator();

sources/scripting/assistantinfo.cpp

@@ -0,0 +1,144 @@
+/*
+	Copyright 2006-2026 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "assistantinfo.h"
+
+#include "qetscriptapi.h"
+#include "scriptlibrary.h"
+#include "../qetapp.h"
+#include "../qetversion.h"
+#include "../utils/qetsettings.h"
+
+#include <QCoreApplication>
+#include <QDateTime>
+#include <QDir>
+#include <QFile>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QSaveFile>
+#include <QStandardPaths>
+
+namespace {
+	QJsonObject s_live;	///< empty while live mode is closed
+	bool s_running = true;
+}
+
+namespace AssistantInfo {
+
+QString path()
+{
+	return QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)
+			+ QStringLiteral("/qet-assistant.json");
+}
+
+/**
+	@brief watch
+	Write the file now, again whenever the stored scripts change, and mark
+	it stopped when QElectroTech quits. Called by every editor window as it
+	opens; acts once.
+*/
+void watch()
+{
+	static bool watching = false;
+	if (watching) return;
+	watching = true;
+	QObject::connect(&ScriptLibrary::instance(), &ScriptLibrary::changed, &write);
+	QObject::connect(qApp, &QCoreApplication::aboutToQuit, &markStopped);
+	write();
+}
+
+void write()
+{
+	QJsonArray scripts, refused;
+	for (const ScriptLibrary::Script &s : ScriptLibrary::instance().scripts()) {
+		const ScriptHeader &h = s.header;
+		scripts.append(QJsonObject{
+			{QStringLiteral("id"), h.id},
+			{QStringLiteral("name"), h.name},
+			{QStringLiteral("file"), s.path},
+			{QStringLiteral("icon"), h.icon},
+			{QStringLiteral("tooltip"), h.tooltip},
+			{QStringLiteral("shortcut"), h.shortcut},
+			{QStringLiteral("context"), h.context},
+			{QStringLiteral("action_id"), ScriptLibrary::actionId(h.id)}});
+	}
+	for (const QString &e : ScriptLibrary::instance().errors()) refused.append(e);
+
+	const QJsonObject info{
+		{QStringLiteral("format"), 1},
+		{QStringLiteral("qelectrotech_version"), QetVersion::displayedVersion()},
+		{QStringLiteral("program"), QCoreApplication::applicationFilePath()},
+		{QStringLiteral("pid"), QCoreApplication::applicationPid()},
+		{QStringLiteral("running"), s_running},
+		{QStringLiteral("written"), QDateTime::currentDateTimeUtc().toString(Qt::ISODate)},
+		{QStringLiteral("folders"), QJsonObject{
+			{QStringLiteral("data"), QETApp::dataDir()},
+			{QStringLiteral("config"), QETApp::configDir()},
+			{QStringLiteral("scripts"), ScriptLibrary::folder()},
+			{QStringLiteral("elements_common"), QETApp::commonElementsDir()},
+			{QStringLiteral("elements_company"), QETApp::companyElementsDir()},
+			{QStringLiteral("elements_custom"), QETApp::customElementsDir()},
+			{QStringLiteral("titleblocks_common"), QETApp::commonTitleBlockTemplatesDir()},
+			{QStringLiteral("titleblocks_company"), QETApp::companyTitleBlockTemplatesDir()},
+			{QStringLiteral("titleblocks_custom"), QETApp::customTitleBlockTemplatesDir()}}},
+		{QStringLiteral("features"), QJsonObject{
+#ifdef QET_HAS_SCRIPTING
+			{QStringLiteral("scripting_available"), true},
+#else
+			{QStringLiteral("scripting_available"), false},
+#endif
+			{QStringLiteral("scripting_enabled"), QetSettings::scriptingEnabled()},
+			{QStringLiteral("live_mode_setting"), QetSettings::liveAssistantEnabled()},
+			{QStringLiteral("live_mode_open"), !s_live.isEmpty()}}},
+		{QStringLiteral("script_api"), QJsonArray::fromStringList(QetScriptApi::signatures())},
+		{QStringLiteral("stored_scripts"), scripts},
+		{QStringLiteral("refused_scripts"), refused},
+		{QStringLiteral("live"), s_live.isEmpty() ? QJsonValue() : QJsonValue(s_live)}};
+
+	const QString file_path = path();
+	QDir().mkpath(QFileInfo(file_path).path());
+	QSaveFile file(file_path);
+	if (!file.open(QIODevice::WriteOnly)) return;
+	file.write(QJsonDocument(info).toJson(QJsonDocument::Indented));
+	if (file.commit())
+		QFile::setPermissions(file_path, QFile::ReadOwner | QFile::WriteOwner);
+}
+
+/**
+	@brief setLive
+	The live channel's details while it is open (socket, token), or an
+	empty object once it closes.
+*/
+void setLive(const QJsonObject &live)
+{
+	s_live = live;
+	write();
+}
+
+/**
+	@brief markStopped
+	QElectroTech is quitting: the file stays, as a record of where things
+	are, but says nothing is listening any more.
+*/
+void markStopped()
+{
+	s_running = false;
+	s_live = QJsonObject();
+	write();
+}
+
+}

sources/scripting/assistantinfo.h

@@ -0,0 +1,50 @@
+/*
+	Copyright 2006-2026 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef ASSISTANTINFO_H
+#define ASSISTANTINFO_H
+
+#include <QJsonObject>
+#include <QString>
+
+/**
+	@brief qet-assistant.json: what an AI assistant (through the qet MCP
+	server) needs to know about this QElectroTech, in one file.
+
+	Where its folders are -- data, settings, scripts, the element and title
+	block collections --, which features are switched on, every call a
+	script can make, the stored scripts, and, while live mode is open, how
+	to reach it. QElectroTech rewrites it when it starts and whenever one of
+	those changes, so the MCP server reads facts instead of guessing them
+	per platform -- wrong as soon as QElectroTech is started with
+	--data-dir or --config-dir.
+
+	It always lives in the standard data folder for the platform, even
+	when --data-dir moves the data elsewhere: that is the one place the
+	server can look without being told. Readable by the user only: while
+	live mode is open it holds the channel's token.
+*/
+namespace AssistantInfo
+{
+	QString path();
+	void watch();
+	void write();
+	void setLive(const QJsonObject &live);
+	void markStopped();
+}
+
+#endif // ASSISTANTINFO_H

sources/scripting/liveserver.cpp

@@ -17,6 +17,7 @@
 */
 #include "liveserver.h"
 
+#include "assistantinfo.h"
 #include "qetscripting.h"
 #include "scriptlibrary.h"
 #include "../diagram.h"
@@ -78,17 +79,6 @@ LiveServer::LiveServer()
 
 LiveServer::~LiveServer()
 {
-	QFile::remove(sessionFile());
-}
-
-/**
-	@brief LiveServer::sessionFile
-	Where the channel's name and token are written for the MCP server:
-	next to the stored scripts, in the user's data folder.
-*/
-QString LiveServer::sessionFile()
-{
-	return QETApp::dataDir() + QStringLiteral("/live-session.json");
 }
 
 /**
@@ -146,19 +136,12 @@ bool LiveServer::start()
 	}
 	m_token = randomHex(16);
 
-	const QJsonObject session{
-		{QStringLiteral("version"), 1},
+		//Where the MCP server finds the channel: the "live" part of
+		//qet-assistant.json, the one file it reads about this QElectroTech
+	AssistantInfo::setLive(QJsonObject{
 		{QStringLiteral("socket"), m_server->fullServerName()},
 		{QStringLiteral("token"), m_token},
-		{QStringLiteral("pid"), QCoreApplication::applicationPid()}};
-	QSaveFile file(sessionFile());
-	if (!file.open(QIODevice::WriteOnly)
-	    || file.write(QJsonDocument(session).toJson(QJsonDocument::Compact)) < 0
-	    || !file.commit()) {
-		stop();
-		return false;
-	}
-	QFile::setPermissions(sessionFile(), QFile::ReadOwner | QFile::WriteOwner);
+		{QStringLiteral("pid"), QCoreApplication::applicationPid()}});
 
 	connect(m_server, &QLocalServer::newConnection, this, &LiveServer::newConnection);
 	setState(Waiting);
@@ -180,7 +163,7 @@ void LiveServer::stop()
 		m_server->deleteLater();
 		m_server = nullptr;
 	}
-	QFile::remove(sessionFile());
+	if (!m_token.isEmpty()) AssistantInfo::setLive(QJsonObject());
 	m_token.clear();
 	m_buffer.clear();
 	setState(Off);

sources/scripting/liveserver.h

@@ -38,9 +38,9 @@ class QWidget;
 	class opens nothing and QElectroTech behaves as if it did not exist.
 
 	The channel is a QLocalServer only the user's own account can open,
-	with a random name and token written to live-session.json in the data
-	folder, which the MCP server reads; the file goes when the channel
-	closes. One JSON request per connection, one JSON answer back, then
+	with a random name and token written to the "live" part of
+	qet-assistant.json (AssistantInfo), which the MCP server reads, and
+	cleared when the channel closes. One JSON request per connection, one JSON answer back, then
 	the server closes the connection; every request carries the token.
 
 	Requests are never handled inside the socket's readyRead: each is
@@ -56,7 +56,6 @@ class LiveServer : public QObject
 		enum State { Off, Waiting, Connected };
 
 		static LiveServer &instance();
-		static QString sessionFile();
 
 		void askAndStart(QWidget *parent);
 		void stop();

sources/scripting/qetscriptapi.cpp

@@ -132,9 +132,19 @@ int QetScriptApi::folioCount() const
 	all of them.
 */
 QStringList QetScriptApi::apiSignatures() const
+{
+	return signatures();
+}
+
+/**
+	@brief QetScriptApi::signatures
+	apiSignatures() without a script running: what qet-assistant.json lists
+	for an assistant before it has run anything.
+*/
+QStringList QetScriptApi::signatures()
 {
 	QStringList list;
-	const QMetaObject *meta = metaObject();
+	const QMetaObject *meta = &staticMetaObject;
 	for (int i = meta->methodOffset(); i < meta->methodCount(); ++i) {
 		const QMetaMethod method = meta->method(i);
 		if (method.methodType() != QMetaMethod::Method

sources/scripting/qetscriptapi.h

@@ -581,6 +581,7 @@ class QetScriptApi : public QObject
 
 		// -- what a script can call, read from this class itself --
 		Q_INVOKABLE QStringList apiSignatures() const;
+		static QStringList signatures();
 
 		void setUndoGrouped(bool grouped);
 		void setLive(QStringList *log);

sources/ui/configpage/generalconfigurationpage.cpp

@@ -17,6 +17,7 @@
 */
 #include "generalconfigurationpage.h"
 #include "../../scripting/liveserver.h"
+#include "../../scripting/assistantinfo.h"
 
 #include "../../qetapp.h"
 #include "../../qeticons.h"
@@ -320,6 +321,8 @@ void GeneralConfigurationPage::applyConf()
 		if (!ui->m_live_assistant->isChecked()) LiveServer::instance().stop();
 #endif
 	}
+		//What an assistant reads about this QElectroTech follows the change
+	AssistantInfo::write();
 
 		//GENERIC PANEL
 	settings.setValue("genericpanel/folio",ui->m_use_folio_label->isChecked());