mioku 0.8.0

package/dist/index.cjs

@@ -0,0 +1,616 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const fs_promises = require_chunk.__toESM(require("fs/promises"));
+const path = require_chunk.__toESM(require("path"));
+const fs = require_chunk.__toESM(require("fs"));
+
+//#region src/core/logger.ts
+const fallbackLogger = {
+	error: (...args) => console.error(...args),
+	warn: (...args) => console.warn(...args),
+	info: (...args) => console.info(...args),
+	debug: (...args) => console.debug(...args),
+	trace: (...args) => console.debug(...args)
+};
+let activeLogger = fallbackLogger;
+function setMiokuLogger(logger$1) {
+	activeLogger = logger$1 || fallbackLogger;
+}
+const logger = {
+	error: (...args) => activeLogger.error(...args),
+	warn: (...args) => activeLogger.warn(...args),
+	info: (...args) => activeLogger.info(...args),
+	debug: (...args) => activeLogger.debug(...args),
+	trace: (...args) => activeLogger.trace?.(...args)
+};
+
+//#endregion
+//#region src/core/plugin-linker.ts
+const DEFAULT_RUNTIME_PLUGINS_DIR = ".mioku/plugins";
+async function pathExists$3(filePath) {
+	try {
+		await fs_promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function removeIfBrokenSymlink(entryPath) {
+	let stat;
+	try {
+		stat = await fs_promises.lstat(entryPath);
+	} catch {
+		return "removed";
+	}
+	if (!stat.isSymbolicLink()) return "blocked";
+	try {
+		await fs_promises.realpath(entryPath);
+		return "ok";
+	} catch {
+		await fs_promises.rm(entryPath, { force: true });
+		logger.warn(`[plugin-linker] Removed broken plugin link: ${entryPath}`);
+		return "removed";
+	}
+}
+function relativeSymlinkTarget(linkPath, targetPath) {
+	const relativePath = path.relative(path.dirname(linkPath), targetPath);
+	return relativePath || ".";
+}
+async function ensurePluginLink(runtimePluginsDir, metadata) {
+	const linkPath = path.join(runtimePluginsDir, metadata.name);
+	const targetPath = metadata.path;
+	let stat;
+	try {
+		stat = await fs_promises.lstat(linkPath);
+	} catch {
+		stat = null;
+	}
+	if (stat?.isSymbolicLink()) try {
+		const currentTarget = await fs_promises.realpath(linkPath);
+		const expectedTarget = await fs_promises.realpath(targetPath);
+		if (currentTarget === expectedTarget) return true;
+		await fs_promises.rm(linkPath, { force: true });
+		logger.info(`[plugin-linker] Rebuilding plugin link: ${metadata.name}`);
+	} catch {
+		await fs_promises.rm(linkPath, { force: true });
+		logger.warn(`[plugin-linker] Removed broken plugin link: ${linkPath}`);
+	}
+	else if (stat) {
+		logger.warn(`[plugin-linker] ${linkPath} exists and is not a symlink, skip linking ${metadata.name}`);
+		return false;
+	}
+	if (!await pathExists$3(targetPath)) {
+		logger.warn(`[plugin-linker] Plugin target missing, skip linking ${metadata.name}: ${targetPath}`);
+		return false;
+	}
+	await fs_promises.symlink(relativeSymlinkTarget(linkPath, targetPath), linkPath, "dir");
+	return true;
+}
+async function prepareRuntimePluginLinks(plugins, runtimePluginsDir = path.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR)) {
+	await fs_promises.mkdir(runtimePluginsDir, { recursive: true });
+	const discoveredNames = new Set(plugins.map((plugin) => plugin.name));
+	const entries = await fs_promises.readdir(runtimePluginsDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const entryPath = path.join(runtimePluginsDir, entry.name);
+		const symlinkState = await removeIfBrokenSymlink(entryPath);
+		if (symlinkState !== "ok") continue;
+		if (entry.isSymbolicLink() && !discoveredNames.has(entry.name)) {
+			await fs_promises.rm(entryPath, { force: true });
+			logger.info(`[plugin-linker] Removed stale plugin link: ${entry.name}`);
+		}
+	}
+	const linkedNames = [];
+	for (const metadata of plugins) if (await ensurePluginLink(runtimePluginsDir, metadata)) linkedNames.push(metadata.name);
+	return linkedNames;
+}
+
+//#endregion
+//#region src/core/plugin-manager.ts
+const PLUGIN_MANAGER_SYMBOL = Symbol.for("mioku.plugin-manager");
+async function pathExists$2(filePath) {
+	try {
+		await fs_promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 插件管理器
+*
+* Discover and manage plugins from both local directories and node_modules.
+*/
+var PluginManager = class PluginManager {
+	pluginMetadata = new Map();
+	static getInstance() {
+		const g = global;
+		if (!g[PLUGIN_MANAGER_SYMBOL]) g[PLUGIN_MANAGER_SYMBOL] = new PluginManager();
+		return g[PLUGIN_MANAGER_SYMBOL];
+	}
+	async discoverPlugins(miokuConfig = {}) {
+		const configuredPluginsDir = miokuConfig.plugins_dir;
+		const pluginsDir = configuredPluginsDir && configuredPluginsDir !== DEFAULT_RUNTIME_PLUGINS_DIR ? path.resolve(process.cwd(), configuredPluginsDir) : path.resolve(process.cwd(), "plugins");
+		this.pluginMetadata.clear();
+		if (!await pathExists$2(pluginsDir)) (0, fs.mkdirSync)(pluginsDir, { recursive: true });
+		const discovered = [];
+		if (await pathExists$2(pluginsDir)) {
+			const localPlugins = await this.discoverFromDir(pluginsDir);
+			discovered.push(...localPlugins);
+		}
+		const nodeModulesPlugins = await this.discoverFromNodeModules();
+		discovered.push(...nodeModulesPlugins);
+		logger.info(`O.o 发现了 ${this.pluginMetadata.size} 个插件`);
+		return Array.from(this.pluginMetadata.values());
+	}
+	async discoverFromDir(pluginsDir) {
+		const discovered = [];
+		try {
+			const entries = await fs_promises.readdir(pluginsDir, { withFileTypes: true });
+			for (const entry of entries) {
+				const pluginPath = path.join(pluginsDir, entry.name);
+				const metadataPath = await this.resolveDirectoryPath(pluginPath);
+				if (!metadataPath) continue;
+				const metadata = await this.loadPluginMetadata(entry.name, pluginPath);
+				if (metadata) {
+					discovered.push(metadata);
+					this.pluginMetadata.set(metadata.name, metadata);
+				}
+			}
+		} catch (error) {
+			logger.error(`扫描插件目录失败: ${error}`);
+		}
+		return discovered;
+	}
+	async discoverFromNodeModules() {
+		const discovered = [];
+		const nodeModulesPath = path.resolve(process.cwd(), "node_modules");
+		if (!await pathExists$2(nodeModulesPath)) return discovered;
+		try {
+			const entries = await fs_promises.readdir(nodeModulesPath, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.name.startsWith("mioku-plugin-")) continue;
+				const pluginName = entry.name.replace(/^mioku-plugin-/, "");
+				const pluginPath = path.join(nodeModulesPath, entry.name);
+				const metadata = await this.loadPluginMetadata(pluginName, pluginPath);
+				if (metadata) {
+					discovered.push(metadata);
+					this.pluginMetadata.set(metadata.name, metadata);
+				}
+			}
+		} catch (error) {
+			logger.debug(`扫描 node_modules 插件失败: ${error}`);
+		}
+		return discovered;
+	}
+	async resolveDirectoryPath(entryPath) {
+		try {
+			const stat = await fs_promises.stat(entryPath);
+			return stat.isDirectory() ? entryPath : null;
+		} catch {
+			return null;
+		}
+	}
+	async loadPluginMetadata(name, pluginPath) {
+		let resolvedPath = pluginPath;
+		try {
+			resolvedPath = await fs_promises.realpath(pluginPath);
+		} catch {}
+		const packageJsonPath = path.join(resolvedPath, "package.json");
+		let packageJson = null;
+		try {
+			const content = await fs_promises.readFile(packageJsonPath, "utf-8");
+			packageJson = JSON.parse(content);
+		} catch {}
+		const metadata = {
+			name,
+			version: packageJson?.version || "0.0.0",
+			description: packageJson?.description,
+			path: resolvedPath,
+			packageJson,
+			config: packageJson?.mioku || {}
+		};
+		return metadata;
+	}
+	collectRequiredServices() {
+		const services = new Set();
+		for (const metadata of this.pluginMetadata.values()) if (metadata.config.services) metadata.config.services.forEach((s) => services.add(s));
+		return services;
+	}
+	getPluginMetadata(name) {
+		return this.pluginMetadata.get(name);
+	}
+	getAllMetadata() {
+		return Array.from(this.pluginMetadata.values());
+	}
+	reset() {
+		this.pluginMetadata.clear();
+	}
+};
+var plugin_manager_default = PluginManager.getInstance();
+
+//#endregion
+//#region src/core/service-manager.ts
+const SERVICE_MANAGER_SYMBOL = Symbol.for("mioku.service-manager");
+async function pathExists$1(filePath) {
+	try {
+		await fs_promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 服务管理器
+*/
+var ServiceManager = class ServiceManager {
+	services = new Map();
+	serviceMetadata = new Map();
+	servicesDir = "services";
+	static getInstance() {
+		const g = global;
+		if (!g[SERVICE_MANAGER_SYMBOL]) g[SERVICE_MANAGER_SYMBOL] = new ServiceManager();
+		return g[SERVICE_MANAGER_SYMBOL];
+	}
+	async discoverServices(miokuConfig = {}) {
+		if (miokuConfig.services_dir) this.servicesDir = path.resolve(process.cwd(), miokuConfig.services_dir);
+		else this.servicesDir = path.resolve(process.cwd(), "services");
+		const discovered = [];
+		this.serviceMetadata.clear();
+		if ((0, fs.existsSync)(this.servicesDir)) {
+			const localServices = await this.discoverFromDir(this.servicesDir);
+			discovered.push(...localServices);
+		} else (0, fs.mkdirSync)(this.servicesDir, { recursive: true });
+		await this.loadBuiltinServices();
+		logger.info(`o.O 发现了 ${this.serviceMetadata.size} 个服务`);
+		return Array.from(this.serviceMetadata.values());
+	}
+	async discoverFromDir(servicesDir) {
+		const discovered = [];
+		try {
+			const entries = await fs_promises.readdir(servicesDir, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				const servicePath = path.join(servicesDir, entry.name);
+				const metadata = await this.loadServiceMetadata(entry.name, servicePath);
+				if (metadata) {
+					discovered.push(metadata);
+					this.serviceMetadata.set(entry.name, metadata);
+				}
+			}
+		} catch (error) {
+			logger.error(`扫描服务目录失败: ${error}`);
+		}
+		return discovered;
+	}
+	async loadServiceMetadata(name, servicePath) {
+		let resolvedPath = servicePath;
+		try {
+			resolvedPath = await fs_promises.realpath(servicePath);
+		} catch {}
+		const packageJsonPath = path.join(resolvedPath, "package.json");
+		if (!await pathExists$1(packageJsonPath)) return null;
+		try {
+			const packageJson = JSON.parse(await fs_promises.readFile(packageJsonPath, "utf-8"));
+			const metadata = {
+				name,
+				version: packageJson.version || "0.0.0",
+				description: packageJson.description,
+				path: resolvedPath,
+				packageJson
+			};
+			return metadata;
+		} catch (error) {
+			logger.error(`解析服务 ${name} 失败: ${error.message}`);
+			return null;
+		}
+	}
+	/**
+	* Load built-in services from the package
+	*/
+	async loadBuiltinServices() {
+		await this.discoverFromNodeModules();
+	}
+	async discoverFromNodeModules() {
+		const nodeModulesPath = path.resolve(process.cwd(), "node_modules");
+		if (!await pathExists$1(nodeModulesPath)) return;
+		try {
+			const entries = await fs_promises.readdir(nodeModulesPath, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.name.startsWith("mioku-service-")) continue;
+				const serviceName = entry.name.replace(/^mioku-service-/, "");
+				const servicePath = path.join(nodeModulesPath, entry.name);
+				const metadata = await this.loadServiceMetadata(serviceName, servicePath);
+				if (metadata) this.serviceMetadata.set(serviceName, metadata);
+			}
+		} catch (error) {
+			logger.debug(`扫描 node_modules 服务失败: ${error}`);
+		}
+	}
+	async checkMissingServices(requiredServices) {
+		const missing = [];
+		for (const serviceName of requiredServices) if (!this.serviceMetadata.has(serviceName)) missing.push(serviceName);
+		return missing;
+	}
+	async loadAllServices(ctx) {
+		const allMetadata = Array.from(this.serviceMetadata.values());
+		logger.info(`O.o 准备加载 ${allMetadata.length} 个服务...`);
+		for (const metadata of allMetadata) await this.loadService(metadata, ctx);
+	}
+	async loadService(metadata, ctx) {
+		try {
+			const indexPath = path.join(metadata.path, "index.ts");
+			const indexJsPath = path.join(metadata.path, "index.js");
+			const indexExists = await pathExists$1(indexPath);
+			const indexJsExists = await pathExists$1(indexJsPath);
+			const entryPoint = indexExists ? indexPath : indexJsPath;
+			if (!entryPoint || !indexExists && !indexJsExists) {
+				logger.error(`服务 ${metadata.name} 入口丢失`);
+				return false;
+			}
+			let importPath = entryPoint;
+			if (process.platform === "win32") importPath = "file:///" + entryPoint.replace(/\\/g, "/");
+			const serviceModule = await import(importPath);
+			const service = serviceModule.default || serviceModule;
+			if (!service || typeof service.init !== "function") return false;
+			await service.init();
+			if (service.api) {
+				if (!ctx.services) ctx.services = {};
+				ctx.services[metadata.name] = service.api;
+			}
+			this.services.set(metadata.name, service);
+			return true;
+		} catch (error) {
+			logger.error(`加载服务 ${metadata.name} 失败: ${error.message}`);
+			return false;
+		}
+	}
+	/**
+	* Register a builtin service directly
+	*/
+	registerBuiltinService(name, service) {
+		this.services.set(name, service);
+	}
+	/**
+	* Get a loaded service
+	*/
+	getService(name) {
+		return this.services.get(name);
+	}
+	async disposeAll() {
+		for (const [name, service] of this.services) if (service.dispose) await service.dispose();
+		this.services.clear();
+	}
+	reset() {
+		this.services.clear();
+		this.serviceMetadata.clear();
+	}
+};
+var service_manager_default = ServiceManager.getInstance();
+
+//#endregion
+//#region src/core/plugin-artifact-registry.ts
+async function pathExists(filePath) {
+	try {
+		await fs_promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function toImportPath(filePath) {
+	if (process.platform === "win32") return "file:///" + filePath.replace(/\\/g, "/");
+	return filePath;
+}
+function isAISkill(value) {
+	return value && typeof value === "object" && typeof value.name === "string" && Array.isArray(value.tools);
+}
+function extractSkills(moduleExports) {
+	const candidates = [
+		moduleExports?.default,
+		moduleExports?.skills,
+		moduleExports
+	];
+	for (const candidate of candidates) {
+		if (Array.isArray(candidate)) return candidate.filter(isAISkill);
+		if (isAISkill(candidate)) return [candidate];
+	}
+	return [];
+}
+async function resolveSkillsEntry(pluginPath) {
+	const tsPath = path.join(pluginPath, "skills.ts");
+	if (await pathExists(tsPath)) return tsPath;
+	const jsPath = path.join(pluginPath, "skills.js");
+	if (await pathExists(jsPath)) return jsPath;
+	return null;
+}
+/**
+* Auto-register plugin help manifests and AI skills
+*/
+async function registerPluginArtifacts(ctx) {
+	const enabledPlugins = new Set(Array.isArray(ctx.botConfig?.plugins) ? ctx.botConfig.plugins : []);
+	const pluginMetadata = plugin_manager_default.getAllMetadata().filter((metadata) => enabledPlugins.size > 0 ? enabledPlugins.has(metadata.name) : true);
+	const helpService = ctx.services?.help;
+	const aiService = ctx.services?.ai;
+	if (helpService) {
+		let helpCount = 0;
+		for (const metadata of pluginMetadata) {
+			if (!metadata.config.help) continue;
+			helpService.registerHelp(metadata.name, metadata.config.help);
+			helpCount += 1;
+		}
+		logger.info(`[plugin-artifacts] Registered ${helpCount} help manifest(s)`);
+	}
+	if (!aiService) return;
+	let skillCount = 0;
+	for (const metadata of pluginMetadata) {
+		const skillsEntry = await resolveSkillsEntry(metadata.path);
+		if (!skillsEntry) continue;
+		try {
+			const moduleExports = await import(toImportPath(skillsEntry));
+			const skills = extractSkills(moduleExports);
+			if (skills.length === 0) {
+				logger.warn(`[plugin-artifacts] Plugin ${metadata.name} has ${path.basename(skillsEntry)} but exported no valid skill`);
+				continue;
+			}
+			for (const skill of skills) {
+				aiService.registerSkill(skill);
+				skillCount += 1;
+			}
+		} catch (error) {
+			logger.error(`[plugin-artifacts] Failed to load skills for plugin ${metadata.name}: ${error?.message || error}`);
+		}
+	}
+	logger.info(`[plugin-artifacts] Registered ${skillCount} skill(s)`);
+}
+
+//#endregion
+//#region src/service-types.ts
+const TOOL_RESULT_FOLLOWUP_KEY = "__miokuFollowup";
+
+//#endregion
+//#region src/core/data-paths.ts
+/**
+* Get the data directory for a specific plugin
+* Returns: {cwd}/data/{pluginName}
+*/
+function getPluginDataDir(pluginName) {
+	const dataDir = path.join(process.cwd(), "data", pluginName);
+	return dataDir;
+}
+/**
+* Get the data directory for a service
+* Returns: {cwd}/data/{serviceName}
+*/
+function getServiceDataDir(serviceName) {
+	const dataDir = path.join(process.cwd(), "data", serviceName);
+	return dataDir;
+}
+/**
+* Get the main data directory
+* Returns: {cwd}/data
+*/
+function getDataDir() {
+	return path.join(process.cwd(), "data");
+}
+/**
+* Get the config directory for a plugin
+* Returns: {cwd}/config/{pluginName}
+*/
+function getPluginConfigDir(pluginName) {
+	const configDir = path.join(process.cwd(), "config", pluginName);
+	return configDir;
+}
+/**
+* Get the config directory for a service
+* Returns: {cwd}/config/{serviceName}
+*/
+function getServiceConfigDir(serviceName) {
+	const configDir = path.join(process.cwd(), "config", serviceName);
+	return configDir;
+}
+/**
+* Get the main config directory
+* Returns: {cwd}/config
+*/
+function getConfigDir() {
+	return path.join(process.cwd(), "config");
+}
+/**
+* Ensure a directory exists, creating it if necessary
+*/
+function ensureDataDir(pluginName) {
+	const dir = getPluginDataDir(pluginName);
+	const { existsSync: existsSync$2, mkdirSync: mkdirSync$3 } = require("fs");
+	if (!existsSync$2(dir)) mkdirSync$3(dir, { recursive: true });
+	return dir;
+}
+
+//#endregion
+//#region src/core/plugin-runtime-state.ts
+const runtimeState = {};
+/**
+* Get the runtime state for a plugin
+*/
+function getPluginRuntimeState(pluginName) {
+	if (!runtimeState[pluginName]) runtimeState[pluginName] = {};
+	return runtimeState[pluginName];
+}
+/**
+* Set/update the runtime state for a plugin
+*/
+function setPluginRuntimeState(pluginName, state) {
+	if (!runtimeState[pluginName]) runtimeState[pluginName] = {};
+	Object.assign(runtimeState[pluginName], state);
+	return runtimeState[pluginName];
+}
+/**
+* Reset the runtime state for a plugin
+*/
+function resetPluginRuntimeState(pluginName) {
+	delete runtimeState[pluginName];
+}
+
+//#endregion
+//#region src/index.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+/**
+* Start Mioku with plugin and service discovery
+*/
+async function start(options = {}) {
+	const { cwd = process.cwd() } = options;
+	if (cwd) process.chdir(cwd);
+	const { start: startMioki, logger: logger$1, botConfig } = await import("mioki");
+	setMiokuLogger(logger$1);
+	const packageJsonPath = path.join(process.cwd(), "package.json");
+	let miokuConfig = {};
+	if (fs.existsSync(packageJsonPath)) {
+		const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		miokuConfig = pkg.mioki || {};
+	}
+	logger$1.info("こんにちは..");
+	logger$1.info("---------------------------------------");
+	logger$1.info("----------  Mioku 正在启动 ------------");
+	logger$1.info("---------------------------------------");
+	const requiredDirs = [
+		"data",
+		"config",
+		"temp"
+	];
+	for (const dir of requiredDirs) if (!(0, fs.existsSync)(dir)) (0, fs.mkdirSync)(dir, { recursive: true });
+	logger$1.info("O.o Miku 正在翻找插件..");
+	const discoveredPlugins = await plugin_manager_default.discoverPlugins(miokuConfig);
+	logger$1.info(`O.o 共发现 ${discoveredPlugins.length} 个插件: ${discoveredPlugins.map((p) => p.name).join(", ")}`);
+	const runtimePluginsDir = path.resolve(process.cwd(), DEFAULT_RUNTIME_PLUGINS_DIR);
+	const linkedPluginNames = await prepareRuntimePluginLinks(discoveredPlugins, runtimePluginsDir);
+	botConfig.plugins_dir = DEFAULT_RUNTIME_PLUGINS_DIR;
+	logger$1.info("o.O Miku 正在翻找服务..");
+	await service_manager_default.discoverServices(miokuConfig);
+	const requiredServices = plugin_manager_default.collectRequiredServices();
+	const missingServices = await service_manager_default.checkMissingServices(requiredServices);
+	if (missingServices.length > 0) logger$1.warn(`发现缺失服务: ${missingServices.join(", ")}`);
+	const discoveredPluginNames = linkedPluginNames;
+	for (const name of discoveredPluginNames) if (!botConfig.plugins.includes(name)) botConfig.plugins.push(name);
+	await startMioki({ cwd });
+}
+const version = "1.0.0";
+
+//#endregion
+exports.TOOL_RESULT_FOLLOWUP_KEY = TOOL_RESULT_FOLLOWUP_KEY;
+exports.definePlugin = definePlugin;
+exports.ensureDataDir = ensureDataDir;
+exports.getConfigDir = getConfigDir;
+exports.getDataDir = getDataDir;
+exports.getPluginConfigDir = getPluginConfigDir;
+exports.getPluginDataDir = getPluginDataDir;
+exports.getPluginRuntimeState = getPluginRuntimeState;
+exports.getServiceConfigDir = getServiceConfigDir;
+exports.getServiceDataDir = getServiceDataDir;
+exports.pluginManager = plugin_manager_default;
+exports.registerPluginArtifacts = registerPluginArtifacts;
+exports.resetPluginRuntimeState = resetPluginRuntimeState;
+exports.serviceManager = service_manager_default;
+exports.setPluginRuntimeState = setPluginRuntimeState;
+exports.start = start;
+exports.version = version;
+//# sourceMappingURL=index.cjs.map