foliko 1.1.92 → 2.0.0

package/src/{core → framework}/command-registry.js

@@ -3,7 +3,7 @@
  * 允许插件注册 CLI 命令，支持 Commander.js 参数解析
  */
 
-const { logger } = require('../utils/logger');
+const { logger } = require('../common/logger');
 const { Command } = require('commander');
 
 class CommandRegistry {

package/src/framework/framework.js

@@ -0,0 +1,300 @@
+'use strict';
+
+/**
+ * Framework 核心容器
+ * 管理所有子系统，提供统一入口
+ * 目标 ~250 行
+ */
+
+const path = require('path');
+const os = require('os');
+const { AsyncLocalStorage } = require('async_hooks');
+const { EventEmitter } = require('../common/events');
+const { PluginManager } = require('../plugin/manager');
+const { ToolRegistry } = require('../tool/registry');
+const { ContextManager } = require('../context/manager');
+const { createFrameworkLogger } = require('../common/logger');
+const { AGENT_DIR, HOME_AGENT_DIR_NAME } = require('../common/constants');
+const { SessionTTL } = require('../session/ttl');
+
+// Add framework node_modules to search path
+const frameworkNodeModules = path.join(__dirname, '..', '..', 'node_modules');
+if (!module.paths.includes(frameworkNodeModules)) {
+  module.paths.unshift(frameworkNodeModules);
+}
+
+// AsyncLocalStorage instances (backward compat)
+const asyncLocalStorage = new AsyncLocalStorage();
+const requestStorage = new AsyncLocalStorage();
+const sessionStorage = new AsyncLocalStorage();
+
+class Framework extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this._silent = config.silent || false;
+    this._debug = config.debug || false;
+    this._ready = false;
+    this._readyPromise = null;
+    this._resolveReady = null;
+
+    // Subsystems
+    this.toolRegistry = new ToolRegistry();
+    this.pluginManager = new PluginManager(this);
+
+    // Agent management
+    this._agents = [];
+    this._mainAgent = null;
+    this._toolRegistryListeners = [];
+    this._subAgentConfigManager = null;
+    this._executionContext = null;
+
+    // Context system
+    this._contextManager = new ContextManager(this);
+    this._sessionContexts = new Map();
+    this._sessionStorageConfig = { baseDir: '.foliko/sessions' };
+
+    // Working directory
+    this._cwd = config.cwd || process.cwd();
+    this._agentDir = config.agentDir || AGENT_DIR;
+    this._homeAgentDir = config.homeAgentDir || process.env.FOLIKO_HOME || path.join(os.homedir(), HOME_AGENT_DIR_NAME);
+    this._changingCwd = false;
+
+    // Logger
+    this.logger = createFrameworkLogger(this);
+
+    // Coordinator
+    this._coordinatorManager = null;
+
+    // Session TTL
+    this._sessionTTL = new SessionTTL({
+      getSessionContexts: () => this._sessionContexts,
+      destroySession: (sid) => this.destroySessionContext(sid),
+    });
+
+    // Event forwarding
+    this._setupToolEventForwarding();
+    this._setupAgentEventForwarding();
+    this._registerBuiltinTools();
+  }
+
+  _setupToolEventForwarding() {
+    const handlers = [
+      ['tool:registered', (tool) => this.emit('tool:registered', tool)],
+      ['tool:call', (data) => { this.emit('tool:call', data); this.emit('tool-call', data); }],
+      ['tool:result', (data) => { this.emit('tool:result', data); }],
+      ['tool:error', (data) => { this.emit('tool:error', data); }],
+    ];
+    for (const [event, handler] of handlers) {
+      this.toolRegistry.on(event, handler);
+      this._toolRegistryListeners.push({ event, handler });
+    }
+  }
+
+  _setupAgentEventForwarding() {
+    this._agentForwardingListeners = new Map();
+    this.on('agent:created', (agent) => {
+      const handlers = {};
+      handlers.toolCall = (data) => this.emit('tool:call', data);
+      handlers.toolResult = (data) => this.emit('tool:result', data);
+      handlers.toolError = (data) => this.emit('tool:error', data);
+      handlers.message = (msg) => this.emit('agent:message', msg);
+      agent.on('tool-call', handlers.toolCall);
+      agent.on('tool-result', handlers.toolResult);
+      agent.on('tool-error', handlers.toolError);
+      agent.on('message', handlers.message);
+      this._agentForwardingListeners.set(agent, handlers);
+    });
+  }
+
+  registerPlugin(plugin) { this.pluginManager.register(plugin); return this; }
+  registerProvider(name, config) { const { registerProvider } = require('../llm/provider'); registerProvider(name, config); return this; }
+  getProviderRegistry() { const { getProviderRegistry } = require('../llm/provider'); return getProviderRegistry(); }
+  registerCommand(name, handler, description, getArgumentCompletions) {
+    const { getCommandRegistry } = require('./command-registry');
+    getCommandRegistry().registerCommand(name, handler, description, getArgumentCompletions);
+    return this;
+  }
+  getCommandRegistry() { const { getCommandRegistry } = require('./command-registry'); return getCommandRegistry(); }
+  createUIContext(pluginName, chatUI) {
+    const { ExtensionUIContext } = require('./ui-extension');
+    if (!this._uiExtensions) this._uiExtensions = new Map();
+    const ctx = new ExtensionUIContext(chatUI, pluginName);
+    this._uiExtensions.set(pluginName, ctx);
+    return ctx;
+  }
+  getUIContext(pluginName) { return this._uiExtensions?.get(pluginName) || null; }
+
+  async loadPlugin(plugin) { await this.pluginManager.load(plugin); return this; }
+  async unloadPlugin(name) { await this.pluginManager.unload(name); return this; }
+  async reloadPlugin(name) { await this.pluginManager.reload(name); return this; }
+  async reloadAllPlugins() { await this.pluginManager.reloadAll(); return this; }
+  async enablePlugin(name) { await this.pluginManager.enable(name); return this; }
+  async disablePlugin(name) { await this.pluginManager.disable(name); return this; }
+  updatePluginConfig(name, config) { return this.pluginManager.updatePluginConfig(name, config); }
+
+  registerTool(tool) { this.toolRegistry.register(tool); return this; }
+  tool(toolDef) {
+    const tool = { ...toolDef };
+    if (tool.input && !tool.inputSchema) tool.inputSchema = tool.input;
+    delete tool.input;
+    this.toolRegistry.register(tool);
+    return this;
+  }
+  getTools() { return this.toolRegistry.getAll(); }
+
+  getMainAgent() { return this._mainAgent; }
+  getSystemPrompt() { return this._mainAgent?._buildSystemPrompt?.() || ''; }
+  getPluginInstance(name) { return this.pluginManager.get(name) || null; }
+  getAgents() { return [...this._agents]; }
+  listSessionContexts() { return Array.from(this._sessionContexts.keys()); }
+
+  getCwd() { return this._cwd; }
+
+  registerEventDescription(eventType, description, schema = null) { this.pluginManager.registerEventDescription(eventType, description, schema); return this; }
+  getEventDescriptions() { return this.pluginManager.getEventDescriptions(); }
+  getEventDescription(eventType) { return this.pluginManager.getEventDescription(eventType); }
+
+  async executeTool(name, args) { return this.toolRegistry.execute(name, args, this); }
+
+  runWithContext(context, fn) { return asyncLocalStorage.run(context, fn); }
+  getExecutionContext() { return asyncLocalStorage.getStore() || null; }
+  setExecutionContext() {}
+  clearExecutionContext() {}
+
+  // Session context
+  getOrCreateSessionContext(sessionId, options = {}) {
+    if (!sessionId) return null;
+    let manager = this._sessionContexts.get(sessionId);
+    if (manager) return manager;
+    const cwd = options.cwd || this._cwd;
+    const sessionDir = path.join(cwd, '.foliko', 'sessions');
+    const sessionFile = options.sessionFile || path.join(sessionDir, `${sessionId}.jsonl`);
+    try {
+      if (require('fs').existsSync(sessionFile)) {
+        const { SessionManager } = require('../session/session');
+        manager = SessionManager.open(sessionFile, sessionDir, cwd);
+      }
+    } catch { /* ignore */ }
+    if (!manager) {
+      const { SessionManager } = require('../session/session');
+      manager = new SessionManager(cwd, sessionDir, sessionFile, true);
+    }
+    this._sessionContexts.set(sessionId, manager);
+    this.touchSession(sessionId);
+    this.emit('session:context-created', { sessionId, manager });
+    return manager;
+  }
+
+  async loadSessionContext(sessionId, options = {}) {
+    if (!sessionId) return null;
+    let manager = this._sessionContexts.get(sessionId);
+    if (manager) return manager;
+    const cwd = options.cwd || this._cwd;
+    const sessionDir = path.join(cwd, '.foliko', 'sessions');
+    const sessionFile = path.join(sessionDir, `${sessionId}.jsonl`);
+    try {
+      if (require('fs').existsSync(sessionFile)) {
+        const { SessionManager } = require('../session/session');
+        manager = SessionManager.open(sessionFile, sessionDir, cwd);
+        this._sessionContexts.set(sessionId, manager);
+        this.emit('session:context-created', { sessionId, manager });
+      }
+    } catch { /* ignore */ }
+    return manager || null;
+  }
+
+  configureSessionStorage(config) { this._sessionStorageConfig = config; }
+  getSessionStorage() { return this._sessionStorageConfig; }
+  getSessionContext(sessionId) {
+    const ctx = this._sessionContexts.get(sessionId) || null;
+    if (ctx) this.touchSession(sessionId);
+    return ctx;
+  }
+  getCurrentSessionContext() {
+    const store = sessionStorage.getStore();
+    if (!store) return null;
+    return store.sessionId ? this._sessionContexts.get(store.sessionId) || null : null;
+  }
+  getCurrentSessionId() { return sessionStorage.getStore()?.sessionId || null; }
+
+  runInSession(sessionId, options, fn) {
+    if (!sessionId) return fn();
+    const manager = this.getOrCreateSessionContext(sessionId, options);
+    return sessionStorage.run({ sessionContext: manager, sessionId }, fn);
+  }
+
+  destroySessionContext(sessionId) {
+    if (this._sessionContexts.has(sessionId)) {
+      this._sessionContexts.delete(sessionId);
+      this.emit('session:context-destroyed', { sessionId });
+    }
+  }
+
+  setSessionTTL(ttlMs) { this._sessionTTL.setTTL(ttlMs); return this; }
+  startSessionCleanup() { this._sessionTTL.start(); return this; }
+  stopSessionCleanup() { this._sessionTTL.stop(); return this; }
+  touchSession(sessionId) { this._sessionTTL.touch(sessionId); return this; }
+
+  // Request context
+  getRequestContext() { return requestStorage.getStore() || null; }
+  runWithRequestContext(context, fn) { return requestStorage.run(context, fn); }
+
+  async runInContext(requestOptions, sessionId, fn) {
+    const { SessionManager } = require('../session/session');
+    const sessionCtx = sessionId ? this.getOrCreateSessionContext(sessionId) : null;
+    return requestStorage.run(requestOptions, () => {
+      if (sessionCtx) return sessionStorage.run({ sessionContext: sessionCtx, sessionId }, fn);
+      return fn();
+    });
+  }
+
+  // Agent creation
+  createAgent(config) {
+    const { createAgent } = require('../agent');
+    return createAgent(this, config);
+  }
+
+  createSessionAgent(sessionId, config = {}) {
+    const { createSessionAgent } = require('../agent');
+    return createSessionAgent(this, sessionId, config);
+  }
+
+  createSubAgent(config) {
+    const { createSubAgent } = require('../agent');
+    return createSubAgent(this, config);
+  }
+
+  syncPromptPartsToSubagents() {
+    const { _syncPromptParts } = require('../agent');
+    for (const agent of this._agents) {
+      if (agent === this._mainAgent || !agent._isSubagent) continue;
+      _syncPromptParts(this, agent);
+    }
+  }
+
+  getAIPlugin() { return this.pluginManager.get('ai'); }
+
+  // Coordinator
+  initCoordinatorManager(coordinatorAgent) {
+    const { CoordinatorManager } = require('../agent/coordinator');
+    if (!this._coordinatorManager) this._coordinatorManager = new CoordinatorManager(this);
+    this._coordinatorManager.setCoordinatorAgent(coordinatorAgent);
+    return this._coordinatorManager;
+  }
+  getCoordinatorManager() { return this._coordinatorManager; }
+  async createWorker(config) {
+    if (!this._coordinatorManager) throw new Error('CoordinatorManager not initialized');
+    return this._coordinatorManager.createWorker(config);
+  }
+
+  _registerBuiltinTools() {}
+
+  _setReady() {
+    this._ready = true;
+    if (this._resolveReady) this._resolveReady(this);
+    this.emit('framework:ready');
+  }
+}
+
+module.exports = { Framework, asyncLocalStorage, requestStorage, sessionStorage };

package/src/framework/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const { Framework } = require('./framework');
+const { bootstrap, ready, destroy, setCwd, rescanProject } = require('./lifecycle');
+const { FrameworkRegistry } = require('./registry');
+const { loadAgentConfig, loadDefaultPlugins } = require('./loader');
+
+module.exports = {
+  Framework,
+  FrameworkRegistry,
+  bootstrap,
+  ready,
+  destroy,
+  setCwd,
+  rescanProject,
+  loadAgentConfig,
+  loadDefaultPlugins,
+};

package/src/framework/lifecycle.js

@@ -0,0 +1,203 @@
+'use strict';
+
+/**
+ * Framework Lifecycle - 生命周期管理
+ * bootstrap / ready / destroy / setCwd / rescanProject
+ * 目标 ~150 行
+ */
+
+const path = require('path');
+
+/**
+ * Bootstrap - 使用默认配置启动框架
+ * @param {Framework} framework
+ * @param {Object} config
+ * @returns {Promise<Framework>}
+ */
+async function bootstrap(framework, config = {}) {
+  const { bootstrapDefaults, DefaultPlugins, loadAgentConfig } = require('../../plugins/core/default');
+  const defaultsPlugin = new DefaultPlugins({ agentDir: config.agentDir || '.foliko' });
+  await framework.loadPlugin(defaultsPlugin);
+  const agentConfig = defaultsPlugin.getConfig();
+  if (config.aiConfig) {
+    agentConfig.ai = { ...agentConfig.ai, ...config.aiConfig };
+  }
+  // 合并 _config.ai（新门面 API 的格式）
+  if (config._config?.ai) {
+    agentConfig.ai = { ...agentConfig.ai, ...config._config.ai };
+  }
+  await bootstrapDefaults(framework, { _config: agentConfig, _skipConfigLoad: true });
+  framework._setReady();
+  framework.startSessionCleanup();
+  return framework;
+}
+
+/**
+ * Wait for framework ready
+ * @param {Framework} framework
+ * @returns {Promise<Framework>}
+ */
+async function ready(framework) {
+  if (framework._ready) return framework;
+  if (!framework._readyPromise) {
+    framework._readyPromise = new Promise(resolve => { framework._resolveReady = resolve; });
+  }
+  await framework._readyPromise;
+  return framework;
+}
+
+/**
+ * Destroy framework
+ * @param {Framework} framework
+ */
+async function destroy(framework) {
+  // Destroy coordinator
+  if (framework._coordinatorManager) {
+    framework._coordinatorManager.destroy();
+    framework._coordinatorManager = null;
+  }
+
+  // Destroy all agents
+  for (const agent of framework._agents) {
+    const listeners = framework._agentForwardingListeners?.get(agent);
+    if (listeners) {
+      agent.off('tool-call', listeners.toolCall);
+      agent.off('tool-result', listeners.toolResult);
+      agent.off('tool-error', listeners.toolError);
+      agent.off('message', listeners.message);
+      framework._agentForwardingListeners.delete(agent);
+    }
+    if (typeof agent.destroy === 'function') agent.destroy();
+  }
+  framework._agents = [];
+
+  // Remove toolRegistry listeners
+  if (framework._toolRegistryListeners) {
+    for (const { event, handler } of framework._toolRegistryListeners) {
+      framework.toolRegistry.off(event, handler);
+    }
+    framework._toolRegistryListeners = [];
+  }
+
+  framework.stopSessionCleanup();
+  framework._sessionContexts.clear();
+
+  // Unload all plugins
+  const plugins = framework.pluginManager.getAll();
+  for (const { name } of plugins) {
+    try { await framework.pluginManager.unload(name); }
+    catch (err) { framework.logger.warn(`Failed to unload '${name}': ${err.message}`); }
+  }
+
+  framework.toolRegistry.clear();
+  framework.removeAllListeners();
+  framework.emit('framework:destroyed');
+}
+
+/**
+ * Set working directory
+ * @param {Framework} framework
+ * @param {string} newCwd
+ * @param {Object} options
+ */
+async function setCwd(framework, newCwd, options = {}) {
+  if (framework._changingCwd) throw new Error('setCwd re-entered');
+  const oldCwd = framework._cwd;
+  const resolved = path.resolve(newCwd);
+  if (resolved === oldCwd) return framework;
+
+  framework._changingCwd = true;
+  try {
+    framework._cwd = resolved;
+    if (options.agentDir) framework._agentDir = options.agentDir;
+    if (options.homeAgentDir) framework._homeAgentDir = options.homeAgentDir;
+
+    framework.pluginManager._setStateFile(resolved);
+
+    const count = framework._sessionContexts.size;
+    for (const sid of Array.from(framework._sessionContexts.keys())) {
+      framework.destroySessionContext(sid);
+    }
+    framework.emit('session:contexts-invalidated', { oldCwd, newCwd: resolved, count });
+
+    if (options.reload !== false) {
+      for (const entry of framework.pluginManager.getAll()) {
+        const inst = entry.instance;
+        try {
+          if (typeof inst?.onCwdChanged === 'function') await inst.onCwdChanged(oldCwd, resolved, framework);
+          await framework.pluginManager.reload(entry.name);
+        } catch (err) {
+          framework.logger.warn(`Plugin ${entry.name} failed during cwd change: ${err.message}`);
+        }
+      }
+    }
+    framework.emit('cwd:changed', { oldCwd, newCwd: resolved, framework });
+  } finally {
+    framework._changingCwd = false;
+  }
+  return framework;
+}
+
+/**
+ * Rescan project - reload plugins and skills
+ * @param {Framework} framework
+ * @param {Object} options
+ */
+async function rescanProject(framework, options = {}) {
+  const { bootstrapDefaults, DefaultPlugins, loadAgentConfig } = require('../../plugins/core/default');
+  const { SYSTEM_PLUGINS } = require('../common/constants');
+  const keepSet = new Set(options.keepLoaded || Array.from(SYSTEM_PLUGINS));
+  const loadList = [];
+
+  // Unload non-kept plugins using PluginManager.unloadExcept
+  const unloadList = await framework.pluginManager.unloadExcept(keepSet);
+
+  // Reload defaults
+  let defaultsPlugin = framework.pluginManager.get('defaults');
+  if (!defaultsPlugin) {
+    const dp = new DefaultPlugins({ agentDir: framework._agentDir });
+    try { await framework.loadPlugin(dp); defaultsPlugin = dp; }
+    catch (err) { framework.logger.warn(`rescanProject: load defaults failed: ${err.message}`); }
+  } else {
+    try { await defaultsPlugin.reload(framework); }
+    catch (err) { framework.logger.warn(`rescanProject: reload defaults failed: ${err.message}`); }
+  }
+
+  const agentConfig = defaultsPlugin
+    ? (defaultsPlugin.getConfig() || loadAgentConfig(framework, framework._agentDir))
+    : loadAgentConfig(framework, framework._agentDir);
+
+  // Bootstrap defaults
+  const beforeNames = new Set(framework.pluginManager.getAll().map(p => p.name));
+  try { await bootstrapDefaults(framework, { _config: agentConfig, _skipConfigLoad: true }); }
+  catch (err) { framework.logger.warn(`rescanProject: bootstrapDefaults failed: ${err.message}`); }
+  for (const name of framework.pluginManager.getAll().map(p => p.name)) {
+    if (!beforeNames.has(name)) loadList.push(name);
+  }
+
+  // Sync skills using setSearchDirs
+  if (options.reloadSkillManager !== false) {
+    const skillManager = framework.pluginManager.get('skill-manager');
+    if (skillManager) {
+      if (Array.isArray(agentConfig.skillsDirs)) skillManager.setSearchDirs(agentConfig.skillsDirs);
+      try { await skillManager.reload(framework); }
+      catch (err) { framework.logger.warn(`rescanProject: skill-manager reload failed: ${err.message}`); }
+    }
+  }
+
+  // Reload kept plugins (fix: use keepSet, not undefined keepList)
+  if (options.reloadKept) {
+    for (const name of keepSet) {
+      if (!framework.pluginManager.has(name)) continue;
+      try { await framework.pluginManager.reload(name); }
+      catch (err) { framework.logger.warn(`rescanProject: reload kept ${name} failed: ${err.message}`); }
+    }
+  }
+
+  const result = { unloaded: unloadList, loaded: loadList, keepLoaded: [...keepSet] };
+  framework.emit('rescan:complete', result);
+  framework.logger.info(`rescanProject: unloaded=${unloadList.length} loaded=${loadList.length} kept=${keepSet.size}`);
+  return result;
+}
+
+module.exports = { bootstrap, ready, destroy, setCwd, rescanProject };

package/src/framework/loader.js

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * Framework Loader - 加载 .foliko/ 配置
+ * 目标 ~150 行
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Load agent config from .foliko/ directory
+ * @param {Framework} framework
+ * @param {string} agentDir
+ * @returns {Object}
+ */
+function loadAgentConfig(framework, agentDir = '.foliko') {
+  const cwd = framework.getCwd ? framework.getCwd() : process.cwd();
+  const folikoDir = path.resolve(cwd, agentDir);
+  const config = {
+    plugins: [],
+    skills: [],
+    ai: {},
+  };
+
+  // Load plugins.json
+  const pluginsPath = path.join(folikoDir, 'plugins.json');
+  if (fs.existsSync(pluginsPath)) {
+    try {
+      const pluginsConfig = JSON.parse(fs.readFileSync(pluginsPath, 'utf-8'));
+      if (Array.isArray(pluginsConfig)) {
+        config.plugins = pluginsConfig;
+      } else if (pluginsConfig.plugins) {
+        config.plugins = pluginsConfig.plugins;
+      }
+      if (pluginsConfig.ai) config.ai = { ...config.ai, ...pluginsConfig.ai };
+      if (pluginsConfig.skillsDirs) config.skillsDirs = pluginsConfig.skillsDirs;
+    } catch (err) {
+      framework.logger?.warn?.('Failed to load plugins.json:', err.message);
+    }
+  }
+
+  // Load agent configs from agents/ directory
+  const agentsDir = path.join(folikoDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    try {
+      const files = fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'));
+      config.agentFiles = files.map(f => path.join(agentsDir, f));
+    } catch { /* ignore */ }
+  }
+
+  // Load skills config
+  const skillsDir = path.join(folikoDir, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    try {
+      config.skillsDirs = config.skillsDirs || [];
+      config.skillsDirs.push(skillsDir);
+    } catch { /* ignore */ }
+  }
+
+  return config;
+}
+
+/**
+ * Load default plugins based on config
+ * @param {Framework} framework
+ * @param {Object} config
+ * @returns {Promise<string[]>} loaded plugin names
+ */
+async function loadDefaultPlugins(framework, config = {}) {
+  const { bootstrapDefaults, DefaultPlugins } = require('../../plugins/core/default');
+  const defaultsPlugin = new DefaultPlugins({ agentDir: config.agentDir || '.foliko' });
+  await framework.loadPlugin(defaultsPlugin);
+  await bootstrapDefaults(framework, { _config: config, _skipConfigLoad: true });
+  return framework.pluginManager.getAll().map(p => p.name);
+}
+
+module.exports = { loadAgentConfig, loadDefaultPlugins };

package/src/framework/registry.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Framework Registry - 统一注册表
+ * 聚合 plugin/tool/command 注册表
+ * 目标 ~200 行
+ */
+
+class FrameworkRegistry {
+  constructor(framework) {
+    this.framework = framework;
+    this._plugins = [];
+    this._tools = [];
+    this._commands = new Map();
+  }
+
+  // === Plugins ===
+  registerPlugin(plugin) {
+    this._plugins.push(plugin);
+    return this;
+  }
+
+  getPlugin(name) {
+    return this._plugins.find(p => p.name === name || p.constructor?.name === name) || null;
+  }
+
+  getAllPlugins() {
+    return [...this._plugins];
+  }
+
+  unregisterPlugin(name) {
+    const idx = this._plugins.findIndex(p => p.name === name);
+    if (idx !== -1) this._plugins.splice(idx, 1);
+    return this;
+  }
+
+  hasPlugin(name) {
+    return this._plugins.some(p => p.name === name);
+  }
+
+  // === Tools ===
+  registerTool(tool) {
+    this._tools.push(tool);
+    return this;
+  }
+
+  getTool(name) {
+    return this._tools.find(t => t.name === name) || null;
+  }
+
+  getAllTools() {
+    return [...this._tools];
+  }
+
+  unregisterTool(name) {
+    const idx = this._tools.findIndex(t => t.name === name);
+    if (idx !== -1) this._tools.splice(idx, 1);
+    return this;
+  }
+
+  clearTools() {
+    this._tools = [];
+    return this;
+  }
+
+  // === Commands ===
+  registerCommand(name, handler, description) {
+    this._commands.set(name, { handler, description });
+    return this;
+  }
+
+  getCommand(name) {
+    return this._commands.get(name) || null;
+  }
+
+  getAllCommands() {
+    return Array.from(this._commands.entries()).map(([name, cmd]) => ({ name, ...cmd }));
+  }
+
+  unregisterCommand(name) {
+    this._commands.delete(name);
+    return this;
+  }
+}
+
+module.exports = { FrameworkRegistry };