@within-7/minto 0.4.2 → 0.4.3

package/dist/utils/pluginLoader.js

@@ -1,819 +0,0 @@
-import {
-  existsSync,
-  readFileSync,
-  readdirSync,
-  statSync,
-  writeFileSync
-} from "fs";
-import { debug as debugLogger } from "./debugLogger.js";
-import { join, resolve, basename } from "path";
-import { homedir } from "os";
-import matter from "gray-matter";
-import { validatePluginDirectory } from "../services/plugins/pluginValidation.js";
-import {
-  PluginManifestSchema,
-  PluginError,
-  PluginErrorCode
-} from "../types/plugin.js";
-import { getCwd } from "./state.js";
-let extraPluginDirs = [];
-function addExtraPluginDir(dir) {
-  const resolved = resolve(dir);
-  if (!extraPluginDirs.includes(resolved)) {
-    extraPluginDirs.push(resolved);
-  }
-}
-function getManagedPluginsDir() {
-  if (process.platform === "darwin") {
-    return "/Library/Application Support/Minto/managed-plugins";
-  }
-  return "/etc/minto/managed-plugins";
-}
-function getPluginDirectories() {
-  const cwd = getCwd();
-  const home = homedir();
-  return [
-    getManagedPluginsDir(),
-    // Managed (enterprise, read-only, lowest)
-    join(home, ".claude", "plugins"),
-    // User global (legacy)
-    join(home, ".minto", "plugins"),
-    // User global
-    join(cwd, ".claude", "plugins"),
-    // Project (legacy)
-    join(cwd, ".minto", "plugins"),
-    // Project
-    join(cwd, ".minto", "plugins.local"),
-    // Project local (gitignored)
-    ...extraPluginDirs
-    // CLI --plugin-dir (highest priority)
-  ];
-}
-function discoverPluginPaths() {
-  const pluginPaths = /* @__PURE__ */ new Map();
-  const directories = getPluginDirectories();
-  for (const dir of directories) {
-    if (!existsSync(dir)) continue;
-    try {
-      const entries = readdirSync(dir);
-      for (const entry of entries) {
-        const pluginPath = join(dir, entry);
-        if (!statSync(pluginPath).isDirectory()) continue;
-        const mintoManifestPath = join(
-          pluginPath,
-          ".minto-plugin",
-          "plugin.json"
-        );
-        const claudeManifestPath = join(
-          pluginPath,
-          ".claude-plugin",
-          "plugin.json"
-        );
-        const rootManifestPath = join(pluginPath, "plugin.json");
-        if (!existsSync(mintoManifestPath) && !existsSync(claudeManifestPath) && !existsSync(rootManifestPath))
-          continue;
-        pluginPaths.set(entry, pluginPath);
-      }
-    } catch (error) {
-    }
-  }
-  return pluginPaths;
-}
-function loadManifest(pluginPath) {
-  const candidates = [
-    join(pluginPath, ".minto-plugin", "plugin.json"),
-    join(pluginPath, ".claude-plugin", "plugin.json"),
-    join(pluginPath, "plugin.json")
-  ];
-  const existing = candidates.filter((p) => existsSync(p));
-  if (existing.length === 0) {
-    throw new PluginError(
-      `Plugin manifest not found. Tried:
-${candidates.map((p) => `  - ${p}`).join("\n")}`,
-      PluginErrorCode.MANIFEST_NOT_FOUND
-    );
-  }
-  let lastError = null;
-  for (const manifestPath of existing) {
-    try {
-      const manifestContent = readFileSync(manifestPath, "utf-8");
-      const manifestData = JSON.parse(manifestContent);
-      return PluginManifestSchema.parse(manifestData);
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  throw new PluginError(
-    `Invalid plugin manifest at ${existing[0]}: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
-    PluginErrorCode.MANIFEST_INVALID,
-    void 0,
-    lastError
-  );
-}
-function loadAgents(pluginPath, manifest) {
-  const agents = [];
-  const agentsDir = join(pluginPath, "agents");
-  for (const agentPath of manifest.agents || []) {
-    const fullPath = join(pluginPath, agentPath);
-    if (!existsSync(fullPath)) {
-      debugLogger.warn("PLUGIN_LOADER", `Agent file not found: ${fullPath}`);
-      continue;
-    }
-    try {
-      const content = readFileSync(fullPath, "utf-8");
-      const { data, content: promptContent } = matter(content);
-      agents.push({
-        name: data.name || basename(agentPath, ".md"),
-        filePath: fullPath,
-        config: {
-          name: data.name || basename(agentPath, ".md"),
-          description: data.description || "",
-          tools: data.tools,
-          model: data.model,
-          content: promptContent.trim()
-        },
-        pluginName: manifest.name
-      });
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading agent ${agentPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  if (existsSync(agentsDir) && statSync(agentsDir).isDirectory()) {
-    const agentFiles = readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
-    for (const file of agentFiles) {
-      const fullPath = join(agentsDir, file);
-      if (agents.some((a) => a.filePath === fullPath)) continue;
-      try {
-        const content = readFileSync(fullPath, "utf-8");
-        const { data, content: promptContent } = matter(content);
-        agents.push({
-          name: data.name || basename(file, ".md"),
-          filePath: fullPath,
-          config: {
-            name: data.name || basename(file, ".md"),
-            description: data.description || "",
-            tools: data.tools,
-            model: data.model,
-            content: promptContent.trim()
-          },
-          pluginName: manifest.name
-        });
-      } catch (error) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `Error loading agent ${file}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-  return agents;
-}
-function loadCommands(pluginPath, manifest) {
-  const commands = [];
-  const commandsDir = join(pluginPath, "commands");
-  for (const commandPath of manifest.commands || []) {
-    const fullPath = join(pluginPath, commandPath);
-    if (!existsSync(fullPath)) {
-      debugLogger.warn("PLUGIN_LOADER", `Command file not found: ${fullPath}`);
-      continue;
-    }
-    try {
-      const content = readFileSync(fullPath, "utf-8");
-      const { data, content: commandContent } = matter(content);
-      commands.push({
-        name: data.name || basename(commandPath, ".md"),
-        filePath: fullPath,
-        config: {
-          name: data.name || basename(commandPath, ".md"),
-          description: data.description,
-          aliases: data.aliases,
-          enabled: data.enabled !== false,
-          hidden: data.hidden === true,
-          progressMessage: data.progressMessage,
-          argNames: data.argNames,
-          "allowed-tools": data["allowed-tools"],
-          content: commandContent.trim()
-        },
-        pluginName: manifest.name
-      });
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading command ${commandPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  if (existsSync(commandsDir) && statSync(commandsDir).isDirectory()) {
-    const commandFiles = readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
-    for (const file of commandFiles) {
-      const fullPath = join(commandsDir, file);
-      if (commands.some((c) => c.filePath === fullPath)) continue;
-      try {
-        const content = readFileSync(fullPath, "utf-8");
-        const { data, content: commandContent } = matter(content);
-        commands.push({
-          name: data.name || basename(file, ".md"),
-          filePath: fullPath,
-          config: {
-            name: data.name || basename(file, ".md"),
-            description: data.description,
-            aliases: data.aliases,
-            enabled: data.enabled !== false,
-            hidden: data.hidden === true,
-            progressMessage: data.progressMessage,
-            argNames: data.argNames,
-            "allowed-tools": data["allowed-tools"],
-            content: commandContent.trim()
-          },
-          pluginName: manifest.name
-        });
-      } catch (error) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `Error loading command ${file}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-  return commands;
-}
-function loadSkills(pluginPath, manifest) {
-  const skills = [];
-  const skillsDir = join(pluginPath, "skills");
-  for (const skillPath of manifest.skills || []) {
-    const fullPath = join(pluginPath, skillPath);
-    if (!existsSync(fullPath)) {
-      debugLogger.warn("PLUGIN_LOADER", `Skill file not found: ${fullPath}`);
-      continue;
-    }
-    try {
-      const content = readFileSync(fullPath, "utf-8");
-      const { data, content: skillContent } = matter(content);
-      skills.push({
-        name: data.name || basename(skillPath, ".md"),
-        filePath: fullPath,
-        config: {
-          name: data.name || basename(skillPath, ".md"),
-          description: data.description || "",
-          content: skillContent.trim()
-        },
-        pluginName: manifest.name,
-        source: "plugin"
-      });
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading skill ${skillPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  if (existsSync(skillsDir) && statSync(skillsDir).isDirectory()) {
-    const entries = readdirSync(skillsDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
-        if (existsSync(skillMdPath)) {
-          if (skills.some((s) => s.filePath === skillMdPath)) continue;
-          try {
-            const content = readFileSync(skillMdPath, "utf-8");
-            const { data, content: skillContent } = matter(content);
-            skills.push({
-              name: data.name || entry.name,
-              filePath: skillMdPath,
-              config: {
-                name: data.name || entry.name,
-                description: data.description || "",
-                content: skillContent.trim()
-              },
-              pluginName: manifest.name,
-              source: "plugin"
-            });
-          } catch (error) {
-            debugLogger.warn(
-              "PLUGIN_LOADER",
-              `Error loading skill from ${skillMdPath}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const fullPath = join(skillsDir, entry.name);
-        if (skills.some((s) => s.filePath === fullPath)) continue;
-        try {
-          const content = readFileSync(fullPath, "utf-8");
-          const { data, content: skillContent } = matter(content);
-          skills.push({
-            name: data.name || basename(entry.name, ".md"),
-            filePath: fullPath,
-            config: {
-              name: data.name || basename(entry.name, ".md"),
-              description: data.description || "",
-              content: skillContent.trim()
-            },
-            pluginName: manifest.name,
-            source: "plugin"
-          });
-        } catch (error) {
-          debugLogger.warn(
-            "PLUGIN_LOADER",
-            `Error loading skill ${entry.name}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    }
-  }
-  return skills;
-}
-function loadHooks(pluginPath, manifest) {
-  const hooks = [];
-  const hooksDir = join(pluginPath, "hooks");
-  const hooksJsonPath = join(hooksDir, "hooks.json");
-  if (!existsSync(hooksJsonPath)) {
-    return hooks;
-  }
-  try {
-    const content = readFileSync(hooksJsonPath, "utf-8");
-    const hooksConfig = JSON.parse(content);
-    if (!hooksConfig.hooks || typeof hooksConfig.hooks !== "object") {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Invalid hooks.json in ${pluginPath}: missing "hooks" field`
-      );
-      return hooks;
-    }
-    for (const [eventName, matchers] of Object.entries(
-      hooksConfig.hooks
-    )) {
-      if (!Array.isArray(matchers)) continue;
-      for (const matcher of matchers) {
-        if (!matcher.hooks || !Array.isArray(matcher.hooks)) continue;
-        for (const hookDef of matcher.hooks) {
-          hooks.push({
-            name: `${manifest.name}:${eventName}:${hooks.length}`,
-            filePath: hooksJsonPath,
-            config: {
-              event: eventName,
-              matcher: matcher.matcher,
-              type: hookDef.type || "command",
-              command: hookDef.command,
-              prompt: hookDef.prompt,
-              blocking: hookDef.type === "prompt",
-              timeout: hookDef.timeout || 60
-            },
-            pluginName: manifest.name,
-            event: eventName,
-            matcher: matcher.matcher
-          });
-        }
-      }
-    }
-  } catch (error) {
-    debugLogger.warn(
-      "PLUGIN_LOADER",
-      `Error loading hooks from ${hooksJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  return hooks;
-}
-function expandEnvVars(value, pluginPath) {
-  let expanded = value.replace(/\$\{MINTO_PLUGIN_ROOT\}/g, pluginPath);
-  expanded = expanded.replace(/\$MINTO_PLUGIN_ROOT(?![A-Za-z_])/g, pluginPath);
-  expanded = expanded.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginPath);
-  expanded = expanded.replace(/\$CLAUDE_PLUGIN_ROOT(?![A-Za-z_])/g, pluginPath);
-  expanded = expanded.replace(
-    /\$\{([^}:]+)(?::-([^}]*))?\}/g,
-    (match, varName, defaultValue) => {
-      if (varName === "MINTO_PLUGIN_ROOT" || varName === "CLAUDE_PLUGIN_ROOT") {
-        return match;
-      }
-      return process.env[varName] || defaultValue || "";
-    }
-  );
-  return expanded;
-}
-function expandServerConfig(config, pluginPath) {
-  const expanded = { ...config };
-  if (expanded.command) {
-    expanded.command = expandEnvVars(expanded.command, pluginPath);
-  }
-  if (expanded.url) {
-    expanded.url = expandEnvVars(expanded.url, pluginPath);
-  }
-  if (expanded.args && Array.isArray(expanded.args)) {
-    expanded.args = expanded.args.map(
-      (arg) => expandEnvVars(arg, pluginPath)
-    );
-  }
-  if (expanded.env && typeof expanded.env === "object") {
-    expanded.env = Object.fromEntries(
-      Object.entries(expanded.env).map(([k, v]) => [
-        k,
-        expandEnvVars(String(v), pluginPath)
-      ])
-    );
-  }
-  if (expanded.headers && typeof expanded.headers === "object") {
-    expanded.headers = Object.fromEntries(
-      Object.entries(expanded.headers).map(([k, v]) => [
-        k,
-        expandEnvVars(String(v), pluginPath)
-      ])
-    );
-  }
-  return expanded;
-}
-function loadMCPServers(pluginPath, manifest) {
-  const mcpServers = [];
-  const mcpJsonPath = join(pluginPath, ".mcp.json");
-  let mcpJsonServers = {};
-  if (existsSync(mcpJsonPath)) {
-    try {
-      const content = readFileSync(mcpJsonPath, "utf-8");
-      const parsed = JSON.parse(content);
-      if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
-        mcpJsonServers = parsed.mcpServers;
-      }
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading .mcp.json from ${pluginPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  let inlineServers = {};
-  if (manifest.mcpServers && typeof manifest.mcpServers === "object" && !Array.isArray(manifest.mcpServers)) {
-    inlineServers = manifest.mcpServers;
-  }
-  const allServers = { ...mcpJsonServers, ...inlineServers };
-  for (const [name, config] of Object.entries(allServers)) {
-    try {
-      const expandedConfig = expandServerConfig(config, pluginPath);
-      const serverType = expandedConfig.type || "stdio";
-      if (serverType === "stdio" && !expandedConfig.command) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `MCP server "${name}" in ${manifest.name} is missing required "command" field for stdio type`
-        );
-        continue;
-      }
-      if ((serverType === "http" || serverType === "sse") && !expandedConfig.url) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `MCP server "${name}" in ${manifest.name} is missing required "url" field for ${serverType} type`
-        );
-        continue;
-      }
-      mcpServers.push({
-        name,
-        filePath: existsSync(mcpJsonPath) ? mcpJsonPath : join(pluginPath, "plugin.json"),
-        config: {
-          command: expandedConfig.command || "",
-          args: expandedConfig.args || [],
-          env: expandedConfig.env || {},
-          timeout: expandedConfig.timeout
-        },
-        pluginName: manifest.name
-      });
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading MCP server "${name}" from ${manifest.name}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return mcpServers;
-}
-function loadLSPServers(pluginPath, manifest) {
-  const lspServers = [];
-  const lspJsonPath = join(pluginPath, ".lsp.json");
-  let lspJsonServers = {};
-  if (existsSync(lspJsonPath)) {
-    try {
-      const content = readFileSync(lspJsonPath, "utf-8");
-      const parsed = JSON.parse(content);
-      if (parsed.lspServers && typeof parsed.lspServers === "object") {
-        lspJsonServers = parsed.lspServers;
-      } else if (typeof parsed === "object" && !Array.isArray(parsed)) {
-        lspJsonServers = parsed;
-      }
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading .lsp.json from ${pluginPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  const manifestData = manifest;
-  let inlineServers = {};
-  if (manifestData.lspServers && typeof manifestData.lspServers === "object" && !Array.isArray(manifestData.lspServers)) {
-    inlineServers = manifestData.lspServers;
-  }
-  const allServers = { ...lspJsonServers, ...inlineServers };
-  for (const [name, config] of Object.entries(allServers)) {
-    try {
-      const expandedConfig = expandServerConfig(config, pluginPath);
-      if (!expandedConfig.command) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `LSP server "${name}" in ${manifest.name} is missing required "command" field`
-        );
-        continue;
-      }
-      lspServers.push({
-        name,
-        filePath: existsSync(lspJsonPath) ? lspJsonPath : join(pluginPath, "plugin.json"),
-        config: {
-          command: expandedConfig.command,
-          args: expandedConfig.args || [],
-          env: expandedConfig.env || {},
-          filePatterns: expandedConfig.filePatterns,
-          languages: expandedConfig.languages,
-          initializationOptions: expandedConfig.initializationOptions
-        },
-        pluginName: manifest.name
-      });
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Error loading LSP server "${name}" from ${manifest.name}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return lspServers;
-}
-function determinePluginSource(pluginPath) {
-  const home = homedir();
-  const cwd = getCwd();
-  const ccSyncPath = join(pluginPath, ".cc-sync.json");
-  if (existsSync(ccSyncPath)) {
-    try {
-      const ccMeta = JSON.parse(readFileSync(ccSyncPath, "utf-8"));
-      return {
-        type: "claude-code",
-        marketplace: ccMeta.marketplace || "",
-        name: ccMeta.name || basename(pluginPath)
-      };
-    } catch {
-    }
-  }
-  const marketplaceMetaPath = join(pluginPath, ".marketplace-meta.json");
-  if (existsSync(marketplaceMetaPath)) {
-    try {
-      const metaContent = readFileSync(marketplaceMetaPath, "utf-8");
-      const meta = JSON.parse(metaContent);
-      if (meta.marketplace && meta.plugin) {
-        return {
-          type: "marketplace",
-          marketplace: meta.marketplace,
-          name: meta.plugin
-        };
-      }
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Failed to read marketplace metadata from ${marketplaceMetaPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  const managedDir = getManagedPluginsDir();
-  if (pluginPath.startsWith(managedDir)) {
-    return { type: "local", path: "managed" };
-  } else if (pluginPath.startsWith(join(home, ".minto", "plugins"))) {
-    return { type: "local", path: "user-global" };
-  } else if (pluginPath.startsWith(join(cwd, ".minto", "plugins.local"))) {
-    return { type: "local", path: "local" };
-  } else if (pluginPath.startsWith(join(cwd, ".minto", "plugins"))) {
-    return { type: "local", path: "project" };
-  } else {
-    return { type: "local", path: pluginPath };
-  }
-}
-function loadPluginSettings(pluginPath) {
-  const settingsPaths = [
-    join(pluginPath, ".minto-plugin", "settings.json"),
-    join(pluginPath, ".claude-plugin", "settings.json"),
-    join(pluginPath, "settings.json")
-  ];
-  for (const settingsPath of settingsPaths) {
-    if (!existsSync(settingsPath)) continue;
-    try {
-      const content = readFileSync(settingsPath, "utf-8");
-      const parsed = JSON.parse(content);
-      if (parsed.agent && typeof parsed.agent === "object") {
-        return parsed.agent;
-      }
-      return parsed;
-    } catch (error) {
-      debugLogger.warn(
-        "PLUGIN_LOADER",
-        `Failed to parse plugin settings from ${settingsPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return null;
-}
-function loadPlugin(pluginPath) {
-  const manifest = loadManifest(pluginPath);
-  try {
-    const validation = validatePluginDirectory(pluginPath);
-    if (validation.warnings.length > 0) {
-      for (const warning of validation.warnings) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `Plugin "${manifest.name}": ${warning}`
-        );
-      }
-    }
-  } catch {
-  }
-  const source = determinePluginSource(pluginPath);
-  const pluginConfig = loadPluginConfig(pluginPath);
-  const agents = loadAgents(pluginPath, manifest);
-  const commands = loadCommands(pluginPath, manifest);
-  const skills = loadSkills(pluginPath, manifest);
-  const hooks = loadHooks(pluginPath, manifest);
-  const mcpServers = loadMCPServers(pluginPath, manifest);
-  const lspServers = loadLSPServers(pluginPath, manifest);
-  const settings = loadPluginSettings(pluginPath);
-  return {
-    manifest,
-    name: manifest.name,
-    location: pluginPath,
-    source,
-    agents,
-    commands,
-    skills,
-    hooks,
-    mcpServers,
-    lspServers,
-    enabled: pluginConfig.enabled,
-    config: pluginConfig.config,
-    settings
-  };
-}
-let _pluginCache = null;
-let _pluginCacheTime = 0;
-const PLUGIN_CACHE_TTL_MS = 3e4;
-function invalidatePluginCache() {
-  _pluginCache = null;
-  _pluginCacheTime = 0;
-}
-function loadAllPlugins() {
-  const now = Date.now();
-  if (_pluginCache && now - _pluginCacheTime < PLUGIN_CACHE_TTL_MS) {
-    return _pluginCache;
-  }
-  const pluginPaths = discoverPluginPaths();
-  const plugins = [];
-  for (const [name, path] of pluginPaths) {
-    try {
-      const plugin = loadPlugin(path);
-      plugins.push(plugin);
-    } catch (error) {
-      if (error instanceof PluginError) {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `Error loading plugin ${name}: ${error.message}`
-        );
-      } else {
-        debugLogger.warn(
-          "PLUGIN_LOADER",
-          `Unexpected error loading plugin ${name}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-  _pluginCache = plugins;
-  _pluginCacheTime = now;
-  return plugins;
-}
-function getPlugin(name) {
-  const pluginPaths = discoverPluginPaths();
-  const pluginPath = pluginPaths.get(name);
-  if (!pluginPath) return void 0;
-  try {
-    return loadPlugin(pluginPath);
-  } catch (error) {
-    debugLogger.warn(
-      "PLUGIN_LOADER",
-      `Error loading plugin ${name}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return void 0;
-  }
-}
-function listPlugins() {
-  const pluginPaths = discoverPluginPaths();
-  const plugins = [];
-  for (const [name, path] of pluginPaths) {
-    try {
-      const manifest = loadManifest(path);
-      plugins.push({ name, path, manifest });
-    } catch (error) {
-      plugins.push({ name, path });
-    }
-  }
-  return plugins;
-}
-function getPluginConfigPath(pluginPath) {
-  return join(pluginPath, ".plugin-config.json");
-}
-function loadPluginConfig(pluginPath) {
-  const configPath = getPluginConfigPath(pluginPath);
-  if (!existsSync(configPath)) {
-    return { enabled: true, config: {} };
-  }
-  try {
-    const content = readFileSync(configPath, "utf-8");
-    const data = JSON.parse(content);
-    return {
-      enabled: data.enabled !== false,
-      config: data.config || {}
-    };
-  } catch (error) {
-    debugLogger.warn(
-      "PLUGIN_LOADER",
-      `Error loading plugin config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return { enabled: true, config: {} };
-  }
-}
-function savePluginConfig(pluginPath, enabled, config) {
-  const configPath = getPluginConfigPath(pluginPath);
-  try {
-    const data = { enabled, config };
-    writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
-  } catch (error) {
-    throw new PluginError(
-      `Failed to save plugin config: ${error instanceof Error ? error.message : String(error)}`,
-      PluginErrorCode.PERMISSION_DENIED,
-      void 0,
-      error
-    );
-  }
-}
-function enablePlugin(pluginName) {
-  const plugin = getPlugin(pluginName);
-  if (!plugin) {
-    throw new PluginError(
-      `Plugin "${pluginName}" not found`,
-      PluginErrorCode.NOT_INSTALLED,
-      pluginName
-    );
-  }
-  savePluginConfig(plugin.location, true, plugin.config || {});
-  invalidatePluginCache();
-}
-function disablePlugin(pluginName) {
-  const plugin = getPlugin(pluginName);
-  if (!plugin) {
-    throw new PluginError(
-      `Plugin "${pluginName}" not found`,
-      PluginErrorCode.NOT_INSTALLED,
-      pluginName
-    );
-  }
-  savePluginConfig(plugin.location, false, plugin.config || {});
-  invalidatePluginCache();
-}
-function togglePluginEnabled(pluginName) {
-  const plugin = getPlugin(pluginName);
-  if (!plugin) {
-    throw new PluginError(
-      `Plugin "${pluginName}" not found`,
-      PluginErrorCode.NOT_INSTALLED,
-      pluginName
-    );
-  }
-  const newState = !plugin.enabled;
-  savePluginConfig(plugin.location, newState, plugin.config || {});
-  invalidatePluginCache();
-  return newState;
-}
-function updatePluginConfig(pluginName, config) {
-  const plugin = getPlugin(pluginName);
-  if (!plugin) {
-    throw new PluginError(
-      `Plugin "${pluginName}" not found`,
-      PluginErrorCode.NOT_INSTALLED,
-      pluginName
-    );
-  }
-  savePluginConfig(plugin.location, plugin.enabled, config);
-  invalidatePluginCache();
-}
-export {
-  addExtraPluginDir,
-  disablePlugin,
-  enablePlugin,
-  getPlugin,
-  invalidatePluginCache,
-  listPlugins,
-  loadAllPlugins,
-  loadPlugin,
-  loadPluginSettings,
-  togglePluginEnabled,
-  updatePluginConfig
-};
-//# sourceMappingURL=pluginLoader.js.map