@sylphx/flow 1.0.1 → 1.0.3

package/dist/shared/chunk-cjd3mk4c.js

@@ -1,1320 +0,0 @@
-import {
-  getAgentsDir,
-  getOutputStylesDir,
-  getRuleFile,
-  getSlashCommandsDir
-} from "./chunk-t16rfxh0.js";
-import {
-  envSecurity,
-  fileUtils,
-  generateHelpText,
-  pathSecurity,
-  securitySchemas,
-  yamlUtils
-} from "./chunk-hpkhykhq.js";
-import {
-  __require,
-  __toESM
-} from "./chunk-5j4w74t6.js";
-
-// src/targets/opencode.ts
-import fs4 from "node:fs";
-import path6 from "node:path";
-import chalk3 from "chalk";
-
-// src/config/rules.ts
-var CORE_RULES = {
-  core: "core.md"
-};
-function getRulesPath(ruleType = "core") {
-  return getRuleFile(CORE_RULES[ruleType]);
-}
-function ruleFileExists(ruleType) {
-  try {
-    getRulesPath(ruleType);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/config/servers.ts
-var MCP_SERVER_REGISTRY = {
-  "sylphx-flow": {
-    id: "sylphx-flow",
-    name: "sylphx-flow",
-    description: "Sylphx Flow MCP server for agent coordination and memory management",
-    config: {
-      type: "stdio",
-      command: "sylphx-flow",
-      args: ["mcp", "start"],
-      env: {
-        OPENAI_API_KEY: "",
-        OPENAI_BASE_URL: "https://api.openai.com/v1",
-        EMBEDDING_MODEL: "text-embedding-3-small"
-      }
-    },
-    envVars: {
-      OPENAI_API_KEY: {
-        description: "OpenAI API key for vector search embeddings",
-        required: false,
-        secret: true
-      },
-      OPENAI_BASE_URL: {
-        description: "Base URL for OpenAI-compatible embedding API",
-        required: false,
-        default: "https://api.openai.com/v1"
-      },
-      EMBEDDING_MODEL: {
-        description: "Embedding model to use for vector search",
-        required: false,
-        default: "text-embedding-3-small",
-        dependsOn: ["OPENAI_API_KEY", "OPENAI_BASE_URL"],
-        fetchChoices: async () => {
-          const validatedBaseUrl = envSecurity.getEnvVar("OPENAI_BASE_URL", "https://api.openai.com/v1");
-          const validatedApiKey = envSecurity.getEnvVar("OPENAI_API_KEY");
-          if (!validatedApiKey) {
-            throw new Error("OPENAI_API_KEY is required to fetch embedding models");
-          }
-          try {
-            securitySchemas.apiKey.parse(validatedApiKey);
-          } catch (_error) {
-            throw new Error("Invalid OPENAI_API_KEY format");
-          }
-          const response = await fetch(`${validatedBaseUrl}/models`, {
-            headers: { Authorization: `Bearer ${validatedApiKey}` },
-            timeout: 1e4
-          });
-          if (!response.ok) {
-            throw new Error(`Failed to fetch models: ${response.statusText}`);
-          }
-          const data = await response.json();
-          const embeddingModels = data.data.filter((m) => m.id.includes("embedding")).map((m) => m.id).sort();
-          if (embeddingModels.length === 0) {
-            throw new Error("No embedding models found");
-          }
-          return embeddingModels;
-        }
-      }
-    },
-    category: "core",
-    defaultInInit: true,
-    required: true
-  },
-  "gpt-image": {
-    id: "gpt-image",
-    name: "gpt-image-1-mcp",
-    description: "GPT Image generation MCP server",
-    config: {
-      type: "stdio",
-      command: "npx",
-      args: ["@napolab/gpt-image-1-mcp"],
-      env: { OPENAI_API_KEY: "" }
-    },
-    envVars: {
-      OPENAI_API_KEY: {
-        description: "OpenAI API key for image generation",
-        required: true,
-        secret: true
-      }
-    },
-    category: "ai",
-    defaultInInit: false
-  },
-  perplexity: {
-    id: "perplexity",
-    name: "perplexity-ask",
-    description: "Perplexity Ask MCP server for search and queries",
-    config: {
-      type: "stdio",
-      command: "npx",
-      args: ["-y", "server-perplexity-ask"],
-      env: { PERPLEXITY_API_KEY: "" }
-    },
-    envVars: {
-      PERPLEXITY_API_KEY: {
-        description: "Perplexity API key for search and queries",
-        required: true,
-        secret: true
-      }
-    },
-    category: "ai",
-    defaultInInit: false
-  },
-  context7: {
-    id: "context7",
-    name: "context7",
-    description: "Context7 HTTP MCP server for documentation retrieval",
-    config: {
-      type: "http",
-      url: "https://mcp.context7.com/mcp"
-    },
-    envVars: {
-      CONTEXT7_API_KEY: {
-        description: "Context7 API key for enhanced documentation access",
-        required: false,
-        secret: true
-      }
-    },
-    category: "external",
-    defaultInInit: true
-  },
-  "gemini-search": {
-    id: "gemini-search",
-    name: "gemini-google-search",
-    description: "Gemini Google Search MCP server",
-    config: {
-      type: "stdio",
-      command: "npx",
-      args: ["-y", "mcp-gemini-google-search"],
-      env: { GEMINI_API_KEY: "", GEMINI_MODEL: "gemini-2.5-flash" }
-    },
-    envVars: {
-      GEMINI_API_KEY: {
-        description: "Google Gemini API key for search functionality",
-        required: true,
-        secret: true
-      },
-      GEMINI_MODEL: {
-        description: "Gemini model to use for search",
-        required: false,
-        default: "gemini-2.5-flash"
-      }
-    },
-    category: "ai",
-    defaultInInit: false
-  },
-  grep: {
-    id: "grep",
-    name: "grep",
-    description: "GitHub grep MCP server for searching GitHub repositories",
-    config: {
-      type: "http",
-      url: "https://mcp.grep.app"
-    },
-    category: "external",
-    defaultInInit: true
-  }
-};
-
-// src/core/installers/file-installer.ts
-import fs2 from "node:fs";
-import path4 from "node:path";
-// src/shared/files/index.ts
-import path2 from "node:path";
-
-// src/utils/file-operations.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-async function readFileSafe(filePath, options = {}) {
-  const { encoding = "utf8", fallback } = options;
-  try {
-    const content = await fs.readFile(filePath, encoding);
-    return content;
-  } catch (error) {
-    if (error.code === "ENOENT" && fallback !== undefined) {
-      return fallback;
-    }
-    throw error;
-  }
-}
-async function fileExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getFileInfo(filePath) {
-  try {
-    const stats = await fs.stat(filePath);
-    return {
-      exists: true,
-      isFile: stats.isFile(),
-      isDirectory: stats.isDirectory(),
-      size: stats.size,
-      mtime: stats.mtime,
-      atime: stats.atime,
-      ctime: stats.ctime
-    };
-  } catch {
-    return {
-      exists: false,
-      isFile: false,
-      isDirectory: false
-    };
-  }
-}
-async function deletePathSafe(targetPath) {
-  pathSecurity.validatePath(targetPath);
-  if (!await fileExists(targetPath)) {
-    return;
-  }
-  const info = await getFileInfo(targetPath);
-  if (info.isDirectory) {
-    await fs.rm(targetPath, { recursive: true, force: true });
-  } else {
-    await fs.unlink(targetPath);
-  }
-}
-async function readDirectorySafe(dirPath, options = {}) {
-  const { recursive = false, includeFiles = true, includeDirectories = true } = options;
-  pathSecurity.validatePath(dirPath);
-  if (!await fileExists(dirPath)) {
-    throw new Error(`Directory does not exist: ${dirPath}`);
-  }
-  const info = await getFileInfo(dirPath);
-  if (!info.isDirectory) {
-    throw new Error(`Path is not a directory: ${dirPath}`);
-  }
-  if (recursive) {
-    const results = [];
-    const items2 = await fs.readdir(dirPath, { withFileTypes: true });
-    for (const item of items2) {
-      const fullPath = path.join(dirPath, item.name);
-      if (item.isDirectory() && includeDirectories) {
-        results.push(fullPath);
-        const subResults = await readDirectorySafe(fullPath, options);
-        results.push(...subResults);
-      } else if (item.isFile() && includeFiles) {
-        results.push(fullPath);
-      }
-    }
-    return results;
-  }
-  const items = await fs.readdir(dirPath, { withFileTypes: true });
-  return items.filter((item) => {
-    if (item.isFile() && includeFiles) {
-      return true;
-    }
-    if (item.isDirectory() && includeDirectories) {
-      return true;
-    }
-    return false;
-  }).map((item) => path.join(dirPath, item.name));
-}
-
-// src/shared/files/index.ts
-async function collectFiles(dir, extensions) {
-  try {
-    const allFiles = await readDirectorySafe(dir, {
-      recursive: true,
-      includeFiles: true,
-      includeDirectories: false
-    });
-    return allFiles.filter((filePath) => extensions.some((ext) => filePath.endsWith(ext))).map((filePath) => path2.relative(dir, filePath)).sort();
-  } catch {
-    return [];
-  }
-}
-async function getLocalFileInfo(filePath) {
-  const info = await getFileInfo(filePath);
-  if (!info.exists || !info.isFile) {
-    return null;
-  }
-  const content = await readFileSafe(filePath);
-  if (content === null) {
-    return null;
-  }
-  return {
-    content,
-    mtime: info.mtime
-  };
-}
-async function clearObsoleteFiles(targetDir, expectedFiles, extensions, results) {
-  try {
-    const items = await readDirectorySafe(targetDir, {
-      recursive: false,
-      includeFiles: true,
-      includeDirectories: false
-    });
-    for (const itemPath of items) {
-      const fileName = path2.basename(itemPath);
-      const hasValidExtension = extensions.some((ext) => fileName.endsWith(ext));
-      if (hasValidExtension && !expectedFiles.has(fileName)) {
-        await deletePathSafe(itemPath);
-        results.push({
-          file: fileName,
-          status: "skipped",
-          action: "Removed obsolete file"
-        });
-      }
-    }
-  } catch {}
-}
-// src/shared/processing/index.ts
-import path3 from "node:path";
-// src/core/installers/file-installer.ts
-async function collectSourceFiles(sourceDir, extension) {
-  if (!fs2.existsSync(sourceDir)) {
-    return [];
-  }
-  const allFiles = [];
-  const rootFiles = fs2.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(extension)).map((dirent) => dirent.name);
-  allFiles.push(...rootFiles);
-  const subdirs = fs2.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory() && dirent.name !== "archived").map((dirent) => dirent.name);
-  for (const subdir of subdirs) {
-    const subdirPath = path4.join(sourceDir, subdir);
-    const files = await collectFiles(subdirPath, [extension]);
-    allFiles.push(...files.map((file) => path4.join(subdir, file)));
-  }
-  return allFiles;
-}
-async function installToDirectory(sourceDir, targetDir, transform, options = {}) {
-  const results = [];
-  const files = await collectSourceFiles(sourceDir, options.extension || ".md");
-  if (files.length === 0) {
-    return results;
-  }
-  if (options.clear && fs2.existsSync(targetDir)) {
-    const expectedFiles = new Set(files.map((file) => {
-      if (options.flatten) {
-        const parsed = path4.parse(file);
-        const baseName = parsed.name;
-        const dir = parsed.dir;
-        const flatName = dir ? `${dir.replace(/[/\\]/g, "-")}-${baseName}` : baseName;
-        return `${flatName}${options.extension || ".md"}`;
-      }
-      return file;
-    }));
-    clearObsoleteFiles(targetDir, expectedFiles, [options.extension || ".md"], results);
-  }
-  fs2.mkdirSync(targetDir, { recursive: true });
-  if (options.showProgress && !options.quiet) {
-    console.log(`Installing ${files.length} file${files.length > 1 ? "s" : ""} to ${targetDir.replace(`${process.cwd()}/`, "")}`);
-    console.log("");
-  }
-  if (options.dryRun) {
-    if (!options.quiet) {
-      console.log("✓ Dry run completed - no files were modified");
-    }
-    return results;
-  }
-  const processPromises = files.map(async (file) => {
-    const sourcePath = path4.join(sourceDir, file);
-    const targetPath = path4.join(targetDir, file);
-    const targetFileDir = path4.dirname(targetPath);
-    if (!fs2.existsSync(targetFileDir)) {
-      fs2.mkdirSync(targetFileDir, { recursive: true });
-    }
-    const localInfo = await getLocalFileInfo(targetPath);
-    let content = fs2.readFileSync(sourcePath, "utf8");
-    content = await transform(content, file);
-    const localProcessed = localInfo ? await transform(localInfo.content, file) : "";
-    const contentChanged = !localInfo || localProcessed !== content;
-    if (contentChanged) {
-      fs2.writeFileSync(targetPath, content, "utf8");
-      results.push({
-        file,
-        status: localInfo ? "updated" : "added",
-        action: localInfo ? "Updated" : "Created"
-      });
-    } else {
-      results.push({
-        file,
-        status: "current",
-        action: "Already current"
-      });
-    }
-  });
-  await Promise.all(processPromises);
-  return results;
-}
-async function appendToFile(sourceDir, targetFile, transform, options = {}) {
-  const files = await collectSourceFiles(sourceDir, options.extension || ".md");
-  if (files.length === 0) {
-    return;
-  }
-  if (options.dryRun) {
-    if (!options.quiet) {
-      console.log(`Dry run: Would append ${files.length} file${files.length > 1 ? "s" : ""} to ${targetFile.replace(`${process.cwd()}/`, "")}`);
-    }
-    return;
-  }
-  let existingContent = "";
-  if (fs2.existsSync(targetFile)) {
-    existingContent = fs2.readFileSync(targetFile, "utf8");
-  }
-  let appendContent = "";
-  for (const file of files) {
-    const sourcePath = path4.join(sourceDir, file);
-    let content = fs2.readFileSync(sourcePath, "utf8");
-    content = await transform(content, file);
-    appendContent += `${content}
-
-`;
-  }
-  fs2.writeFileSync(targetFile, existingContent + appendContent, "utf8");
-  if (options.showProgress && !options.quiet) {
-    console.log(`Appended ${files.length} file${files.length > 1 ? "s" : ""} to ${targetFile.replace(`${process.cwd()}/`, "")}`);
-  }
-}
-async function installFile(sourceFile, targetFile, transform, options = {}) {
-  if (options.dryRun) {
-    if (!options.quiet) {
-      console.log(`Dry run: Would install file to ${targetFile.replace(`${process.cwd()}/`, "")}`);
-    }
-    return;
-  }
-  if (!fs2.existsSync(sourceFile)) {
-    if (!options.quiet) {
-      console.warn(`Source file not found: ${sourceFile}`);
-    }
-    return;
-  }
-  const targetDir = path4.dirname(targetFile);
-  fs2.mkdirSync(targetDir, { recursive: true });
-  const localInfo = await getLocalFileInfo(targetFile);
-  let content = fs2.readFileSync(sourceFile, "utf8");
-  content = await transform(content);
-  if (localInfo && localInfo.content === content) {
-    if (!options.quiet) {
-      console.log(`File already current: ${targetFile.replace(`${process.cwd()}/`, "")}`);
-    }
-    return;
-  }
-  fs2.writeFileSync(targetFile, content, "utf8");
-  if (options.showProgress && !options.quiet) {
-    const action = localInfo ? "Updated" : "Created";
-    console.log(`${action} file: ${targetFile.replace(`${process.cwd()}/`, "")}`);
-  }
-}
-
-class FileInstaller {
-  async installToDirectory(sourceDir, targetDir, transform, options = {}) {
-    return installToDirectory(sourceDir, targetDir, transform, options);
-  }
-  async appendToFile(sourceDir, targetFile, transform, options = {}) {
-    return appendToFile(sourceDir, targetFile, transform, options);
-  }
-  async installFile(sourceFile, targetFile, transform, options = {}) {
-    return installFile(sourceFile, targetFile, transform, options);
-  }
-}
-
-// src/core/installers/mcp-installer.ts
-import chalk2 from "chalk";
-import inquirer2 from "inquirer";
-import ora2 from "ora";
-
-// src/services/mcp-service.ts
-import chalk from "chalk";
-import inquirer from "inquirer";
-import ora from "ora";
-
-// src/types/mcp.types.ts
-var isStdioConfig = (config) => config.type === "stdio";
-var isCLICommandConfig = (config) => isStdioConfig(config);
-// src/services/mcp-service.ts
-function resolveConfig(config) {
-  if (typeof config === "function") {
-    const result = config();
-    return Promise.resolve(result);
-  }
-  return Promise.resolve(config);
-}
-var createMCPService = (deps) => {
-  const getAllServerIds = () => {
-    return Object.keys(MCP_SERVER_REGISTRY);
-  };
-  const getAvailableServers = async () => {
-    const existingServerIds = await getInstalledServerIds();
-    return getAllServerIds().filter((id) => !existingServerIds.includes(id));
-  };
-  const getInstalledServerIds = async () => {
-    try {
-      const configData = await deps.target.readConfig(process.cwd());
-      const mcpConfigPath = deps.target.config.mcpConfigPath;
-      const existingMcpSection = getNestedProperty(configData, mcpConfigPath) || {};
-      const existingServerNames = Object.keys(existingMcpSection);
-      return Object.values(MCP_SERVER_REGISTRY).filter((server) => existingServerNames.includes(server.name)).map((server) => server.id);
-    } catch (_error) {
-      return [];
-    }
-  };
-  const getRequiringConfiguration = (serverIds) => {
-    return serverIds.filter((id) => {
-      const server = MCP_SERVER_REGISTRY[id];
-      return !!server.envVars;
-    });
-  };
-  const validateServer = (serverId, envValues) => {
-    const server = MCP_SERVER_REGISTRY[serverId];
-    if (!server?.envVars) {
-      return { isValid: true, missingRequired: [], invalidValues: [] };
-    }
-    const missingRequired = [];
-    const invalidValues = [];
-    for (const [key, config] of Object.entries(server.envVars)) {
-      const value = envValues[key] || process.env[key] || "";
-      if (config.required && (!value || value === "")) {
-        missingRequired.push(key);
-      }
-    }
-    return {
-      isValid: missingRequired.length === 0 && invalidValues.length === 0,
-      missingRequired,
-      invalidValues
-    };
-  };
-  const configureServer = async (serverId, collectedEnv = {}) => {
-    const server = MCP_SERVER_REGISTRY[serverId];
-    const values = {};
-    if (!server.envVars) {
-      return values;
-    }
-    console.log("");
-    console.log(chalk.cyan(`▸ ${server.name}`));
-    console.log(chalk.gray(`  ${server.description}`));
-    console.log("");
-    for (const [key, config] of Object.entries(server.envVars)) {
-      if (config.dependsOn) {
-        const missingDeps = config.dependsOn.filter((dep) => !(collectedEnv[dep] || process.env[dep]));
-        if (missingDeps.length > 0) {
-          continue;
-        }
-      }
-      const existingValue = collectedEnv[key] || process.env[key];
-      let value;
-      if (existingValue && existingValue.trim() !== "") {
-        value = existingValue;
-      } else if (config.fetchChoices) {
-        const spinner = ora("Fetching options...").start();
-        for (const [envKey, envValue] of Object.entries(collectedEnv)) {
-          if (envValue) {
-            process.env[envKey] = envValue;
-          }
-        }
-        try {
-          const choices = await config.fetchChoices();
-          spinner.stop();
-          const answer = await inquirer.prompt({
-            type: "list",
-            name: "value",
-            message: `${key}${config.required ? " *" : ""}`,
-            choices,
-            default: config.default || choices[0]
-          });
-          value = answer.value;
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          spinner.fail(chalk.red(`Failed to fetch options: ${errorMsg}`));
-          const answer = await inquirer.prompt({
-            type: "input",
-            name: "value",
-            message: `${key}${config.required ? " *" : ""}`,
-            default: config.default
-          });
-          value = answer.value;
-        }
-      } else if (key === "GEMINI_MODEL") {
-        const answer = await inquirer.prompt({
-          type: "list",
-          name: "model",
-          message: `${key}${config.required ? " *" : ""}`,
-          choices: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-1.5-flash", "gemini-1.5-pro"],
-          default: config.default || "gemini-2.5-flash"
-        });
-        value = answer.model;
-      } else {
-        const answer = await inquirer.prompt({
-          type: config.secret ? "password" : "input",
-          name: "value",
-          message: `${key}${config.required ? " *" : ""}`,
-          default: config.default,
-          mask: config.secret ? "•" : undefined
-        });
-        value = answer.value;
-      }
-      if (value) {
-        values[key] = value;
-        collectedEnv[key] = value;
-      }
-    }
-    console.log(chalk.green("✓ Configured"));
-    console.log("");
-    return values;
-  };
-  const installServers = async (serverIds, serverConfigs = {}) => {
-    if (serverIds.length === 0) {
-      return;
-    }
-    try {
-      const configData = await deps.target.readConfig(process.cwd());
-      const mcpConfigPath = deps.target.config.mcpConfigPath;
-      const existingMcpSection = getNestedProperty(configData, mcpConfigPath) || {};
-      const mcpSection = { ...existingMcpSection };
-      for (const serverId of serverIds) {
-        const server = MCP_SERVER_REGISTRY[serverId];
-        const configuredValues = serverConfigs[serverId] || {};
-        let configToTransform = { ...server.config };
-        let resolvedCommand;
-        let resolvedArgs;
-        if (isCLICommandConfig(server.config)) {
-          resolvedCommand = server.config.command ? await resolveConfig(server.config.command) : undefined;
-          resolvedArgs = server.config.args ? await resolveConfig(server.config.args) : [];
-          if (serverId === "sylphx-flow" && Array.isArray(resolvedArgs)) {
-            const targetConfig = deps.target.mcpServerConfig;
-            if (targetConfig) {
-              if (targetConfig.disableTime) {
-                resolvedArgs.push("--disable-time");
-              }
-              if (targetConfig.disableKnowledge) {
-                resolvedArgs.push("--disable-knowledge");
-              }
-              if (targetConfig.disableCodebase) {
-                resolvedArgs.push("--disable-codebase");
-              }
-            }
-          }
-        }
-        if (isCLICommandConfig(server.config)) {
-          configToTransform = {
-            ...server.config,
-            command: resolvedCommand,
-            args: resolvedArgs
-          };
-        }
-        if (Object.keys(configuredValues).length > 0) {
-          const serverConfigEnv = server.config.type === "local" ? server.config.environment : server.config.type === "stdio" ? server.config.env : {};
-          const updatedEnv = { ...serverConfigEnv };
-          for (const [key, value] of Object.entries(configuredValues)) {
-            if (value && value.trim() !== "") {
-              updatedEnv[key] = value;
-            }
-          }
-          if (configToTransform.type === "local") {
-            configToTransform.environment = updatedEnv;
-          } else if (configToTransform.type === "stdio") {
-            configToTransform.env = updatedEnv;
-          }
-        }
-        const transformedConfig = deps.target.transformMCPConfig(configToTransform, serverId);
-        mcpSection[server.name] = transformedConfig;
-      }
-      setNestedProperty(configData, mcpConfigPath, mcpSection);
-      await deps.target.writeConfig(process.cwd(), configData);
-      if (deps.target.approveMCPServers) {
-        const serverNames = serverIds.map((id) => MCP_SERVER_REGISTRY[id].name);
-        await deps.target.approveMCPServers(process.cwd(), serverNames);
-      }
-    } catch (error) {
-      throw new Error(`Failed to install MCP servers: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  };
-  const readConfig = async () => {
-    try {
-      return await deps.target.readConfig(process.cwd());
-    } catch (_error) {
-      return { settings: {} };
-    }
-  };
-  const writeConfig = async (configData) => {
-    await deps.target.writeConfig(process.cwd(), configData);
-  };
-  const getNestedProperty = (obj, path5) => {
-    return path5.split(".").reduce((current, key) => {
-      if (typeof current === "object" && current !== null) {
-        return current[key];
-      }
-      return;
-    }, obj);
-  };
-  const setNestedProperty = (obj, path5, value) => {
-    const keys = path5.split(".");
-    const lastKey = keys.pop();
-    if (!lastKey) {
-      return;
-    }
-    const target = keys.reduce((current, key) => {
-      if (!current[key]) {
-        current[key] = {};
-      }
-      return current[key];
-    }, obj);
-    target[lastKey] = value;
-  };
-  return {
-    getAllServerIds,
-    getAvailableServers,
-    getInstalledServerIds,
-    getRequiringConfiguration,
-    validateServer,
-    configureServer,
-    installServers,
-    readConfig,
-    writeConfig
-  };
-};
-
-// src/core/installers/mcp-installer.ts
-function createMCPInstaller(target) {
-  const mcpService = createMCPService({ target });
-  const selectServers = async (options = {}) => {
-    const allServers = mcpService.getAllServerIds();
-    const installedServers = await mcpService.getInstalledServerIds();
-    if (!options.quiet) {
-      console.log(chalk2.cyan.bold(`━━━ Configure MCP Tools ━━━
-`));
-    }
-    const serverSelectionAnswer = await inquirer2.prompt([
-      {
-        type: "checkbox",
-        name: "selectedServers",
-        message: "Select MCP tools to install:",
-        choices: allServers.map((id) => {
-          const server = MCP_SERVER_REGISTRY[id];
-          const isInstalled = installedServers.includes(id);
-          return {
-            name: `${server.name} - ${server.description}`,
-            value: id,
-            checked: server.required || isInstalled || server.defaultInInit || false,
-            disabled: server.required ? "(required)" : false
-          };
-        })
-      }
-    ]);
-    let selectedServers = serverSelectionAnswer.selectedServers;
-    const requiredServers = allServers.filter((id) => MCP_SERVER_REGISTRY[id].required);
-    selectedServers = [...new Set([...requiredServers, ...selectedServers])];
-    return selectedServers;
-  };
-  const configureServers = async (selectedServers, options = {}) => {
-    const serversNeedingConfig = selectedServers.filter((id) => {
-      const server = MCP_SERVER_REGISTRY[id];
-      return server.envVars && Object.keys(server.envVars).length > 0;
-    });
-    const serverConfigsMap = {};
-    if (serversNeedingConfig.length > 0) {
-      if (!options.quiet) {
-        console.log(chalk2.cyan.bold(`
-━━━ Server Configuration ━━━
-`));
-      }
-      const collectedEnv = {};
-      for (const serverId of serversNeedingConfig) {
-        const configValues = await mcpService.configureServer(serverId, collectedEnv);
-        serverConfigsMap[serverId] = configValues;
-      }
-    }
-    return serverConfigsMap;
-  };
-  const installServers = async (selectedServers, serverConfigsMap, options = {}) => {
-    if (selectedServers.length === 0) {
-      return;
-    }
-    const spinner = options.quiet ? null : ora2({
-      text: `Installing ${selectedServers.length} MCP server${selectedServers.length > 1 ? "s" : ""}`,
-      color: "cyan"
-    }).start();
-    try {
-      await mcpService.installServers(selectedServers, serverConfigsMap);
-      if (spinner) {
-        spinner.succeed(chalk2.green(`Installed ${chalk2.cyan(selectedServers.length)} MCP server${selectedServers.length > 1 ? "s" : ""}`));
-      }
-    } catch (error) {
-      if (spinner) {
-        spinner.fail(chalk2.red("Failed to install MCP servers"));
-      }
-      throw error;
-    }
-  };
-  const setupMCP = async (options = {}) => {
-    const selectedServers = await selectServers(options);
-    if (selectedServers.length === 0) {
-      return { selectedServers: [], serverConfigsMap: {} };
-    }
-    const serverConfigsMap = await configureServers(selectedServers, options);
-    if (!options.dryRun) {
-      await installServers(selectedServers, serverConfigsMap, options);
-    }
-    return { selectedServers, serverConfigsMap };
-  };
-  return {
-    selectServers,
-    configureServers,
-    installServers,
-    setupMCP
-  };
-}
-
-class MCPInstaller {
-  installer;
-  constructor(target) {
-    this.installer = createMCPInstaller(target);
-  }
-  async selectServers(options = {}) {
-    return this.installer.selectServers(options);
-  }
-  async configureServers(selectedServers, options = {}) {
-    return this.installer.configureServers(selectedServers, options);
-  }
-  async installServers(selectedServers, serverConfigsMap, options = {}) {
-    return this.installer.installServers(selectedServers, serverConfigsMap, options);
-  }
-  async setupMCP(options = {}) {
-    return this.installer.setupMCP(options);
-  }
-}
-
-// src/utils/secret-utils.ts
-import fs3 from "node:fs/promises";
-import path5 from "node:path";
-var secretUtils = {
-  getSecretsDir(cwd) {
-    return path5.join(cwd, ".secrets");
-  },
-  async ensureSecretsDir(cwd) {
-    const secretsDir = secretUtils.getSecretsDir(cwd);
-    await fs3.mkdir(secretsDir, { recursive: true });
-  },
-  async writeSecret(cwd, key, value) {
-    await secretUtils.ensureSecretsDir(cwd);
-    const secretFile = path5.join(".secrets", key);
-    const secretPath = path5.join(cwd, secretFile);
-    await fs3.writeFile(secretPath, value.trim(), "utf8");
-    return secretFile;
-  },
-  async readSecret(cwd, secretFile) {
-    const secretPath = path5.resolve(cwd, secretFile);
-    try {
-      return await fs3.readFile(secretPath, "utf8");
-    } catch (error) {
-      throw new Error(`Failed to read secret file ${secretFile}: ${error}`);
-    }
-  },
-  toFileReference(key) {
-    return `{file:.secrets/${key}}`;
-  },
-  isFileReference(value) {
-    return value.startsWith("{file:") && value.endsWith("}");
-  },
-  extractFilePath(reference) {
-    if (!secretUtils.isFileReference(reference)) {
-      throw new Error(`Invalid file reference: ${reference}`);
-    }
-    return reference.slice(6, -1);
-  },
-  async resolveFileReferences(cwd, obj) {
-    if (typeof obj === "string" && secretUtils.isFileReference(obj)) {
-      const filePath = secretUtils.extractFilePath(obj);
-      return await secretUtils.readSecret(cwd, filePath);
-    }
-    if (Array.isArray(obj)) {
-      return Promise.all(obj.map((item) => secretUtils.resolveFileReferences(cwd, item)));
-    }
-    if (obj && typeof obj === "object") {
-      const resolved = {};
-      for (const [key, value] of Object.entries(obj)) {
-        resolved[key] = await secretUtils.resolveFileReferences(cwd, value);
-      }
-      return resolved;
-    }
-    return obj;
-  },
-  async convertSecretsToFileReferences(cwd, envVars) {
-    const result = {};
-    for (const [key, value] of Object.entries(envVars)) {
-      if (value && !secretUtils.isFileReference(value)) {
-        const _secretFile = await secretUtils.writeSecret(cwd, key, value);
-        result[key] = secretUtils.toFileReference(key);
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  },
-  async saveSecrets(cwd, secrets) {
-    for (const [key, value] of Object.entries(secrets)) {
-      await secretUtils.writeSecret(cwd, key, value);
-    }
-  },
-  async loadSecrets(cwd) {
-    const secretsDir = secretUtils.getSecretsDir(cwd);
-    const secrets = {};
-    try {
-      const files = await fs3.readdir(secretsDir);
-      for (const file of files) {
-        const filePath = path5.join(secretsDir, file);
-        const stat = await fs3.stat(filePath);
-        if (stat.isFile()) {
-          const content = await fs3.readFile(filePath, "utf8");
-          secrets[file] = content.trim();
-        }
-      }
-    } catch (_error) {}
-    return secrets;
-  },
-  async addToGitignore(cwd) {
-    const gitignorePath = path5.join(cwd, ".gitignore");
-    try {
-      let gitignoreContent = "";
-      try {
-        gitignoreContent = await fs3.readFile(gitignorePath, "utf8");
-      } catch {}
-      const lines = gitignoreContent.split(`
-`).map((line) => line.trim());
-      if (!lines.includes(".secrets") && !lines.includes(".secrets/")) {
-        gitignoreContent += `${gitignoreContent && !gitignoreContent.endsWith(`
-`) ? `
-` : ""}.secrets/
-`;
-        await fs3.writeFile(gitignorePath, gitignoreContent, "utf8");
-      }
-    } catch (error) {
-      console.warn("Warning: Could not update .gitignore:", error);
-    }
-  }
-};
-
-// src/utils/error-handler.ts
-class CLIError extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "CLIError";
-  }
-}
-
-// src/targets/opencode.ts
-var opencodeTarget = {
-  id: "opencode",
-  name: "OpenCode",
-  description: "OpenCode IDE with YAML front matter agents (.opencode/agent/*.md)",
-  category: "ide",
-  isImplemented: true,
-  isDefault: true,
-  mcpServerConfig: {
-    disableTime: false,
-    disableKnowledge: false,
-    disableCodebase: false
-  },
-  config: {
-    agentDir: ".opencode/agent",
-    agentExtension: ".md",
-    agentFormat: "yaml-frontmatter",
-    stripYaml: false,
-    flatten: false,
-    configFile: "opencode.jsonc",
-    configSchema: "https://opencode.ai/config.json",
-    mcpConfigPath: "mcp",
-    rulesFile: "AGENTS.md",
-    outputStylesDir: undefined,
-    slashCommandsDir: ".opencode/command",
-    installation: {
-      createAgentDir: true,
-      createConfigFile: true,
-      useSecretFiles: true
-    }
-  },
-  async transformAgentContent(content, metadata, _sourcePath) {
-    const { metadata: existingMetadata, content: baseContent } = await yamlUtils.extractFrontMatter(content);
-    const { name, mode, rules, ...cleanMetadata } = existingMetadata;
-    if (metadata) {
-      const { name: additionalName, mode: additionalMode, rules: additionalRules, ...additionalCleanMetadata } = metadata;
-      const mergedMetadata = { ...cleanMetadata, ...additionalCleanMetadata };
-      return yamlUtils.addFrontMatter(baseContent, mergedMetadata);
-    }
-    return yamlUtils.addFrontMatter(baseContent, cleanMetadata);
-  },
-  transformMCPConfig(config, _serverId) {
-    if (config.type === "stdio") {
-      const openCodeConfig = {
-        type: "local",
-        command: [config.command]
-      };
-      if (config.args && config.args.length > 0) {
-        openCodeConfig.command.push(...config.args);
-      }
-      if (config.env) {
-        openCodeConfig.environment = config.env;
-      }
-      return openCodeConfig;
-    }
-    if (config.type === "http") {
-      return {
-        type: "remote",
-        url: config.url,
-        ...config.headers && { headers: config.headers }
-      };
-    }
-    if (config.type === "local" || config.type === "remote") {
-      return config;
-    }
-    return config;
-  },
-  getConfigPath: (cwd) => Promise.resolve(fileUtils.getConfigPath(opencodeTarget.config, cwd)),
-  async readConfig(cwd) {
-    const config = await fileUtils.readConfig(opencodeTarget.config, cwd);
-    const resolvedConfig = await secretUtils.resolveFileReferences(cwd, config);
-    if (!resolvedConfig.mcp) {
-      resolvedConfig.mcp = {};
-    }
-    return resolvedConfig;
-  },
-  async writeConfig(cwd, config) {
-    if (!config.mcp) {
-      config.mcp = {};
-    }
-    if (opencodeTarget.config.installation?.useSecretFiles) {
-      for (const [serverId, serverConfig] of Object.entries(config.mcp || {})) {
-        if (serverConfig && typeof serverConfig === "object" && "environment" in serverConfig) {
-          const envVars = serverConfig.environment;
-          if (envVars && typeof envVars === "object") {
-            const serverDef = Object.values(MCP_SERVER_REGISTRY).find((s) => s.name === serverId);
-            if (serverDef?.envVars) {
-              const secretEnvVars = {};
-              const nonSecretEnvVars = {};
-              for (const [key, value] of Object.entries(envVars)) {
-                const envConfig = serverDef.envVars[key];
-                if (envConfig?.secret && value && !secretUtils.isFileReference(value)) {
-                  secretEnvVars[key] = value;
-                } else {
-                  nonSecretEnvVars[key] = value;
-                }
-              }
-              const convertedSecrets = await secretUtils.convertSecretsToFileReferences(cwd, secretEnvVars);
-              serverConfig.environment = { ...nonSecretEnvVars, ...convertedSecrets };
-            }
-          }
-        }
-      }
-    }
-    await fileUtils.writeConfig(opencodeTarget.config, cwd, config);
-  },
-  validateRequirements: (cwd) => fileUtils.validateRequirements(opencodeTarget.config, cwd),
-  getHelpText() {
-    let help = generateHelpText(opencodeTarget.config);
-    help += `OpenCode-Specific Information:
-`;
-    help += `  Configuration File: opencode.jsonc
-`;
-    help += `  Schema: https://opencode.ai/config.json
-`;
-    help += `  Agent Format: Markdown with YAML front matter
-`;
-    help += `  MCP Integration: Automatic server discovery
-
-`;
-    help += `Example Agent Structure:
-`;
-    help += `  ---
-`;
-    help += `  name: "My Agent"
-`;
-    help += `  description: "Agent description"
-`;
-    help += `  ---
-
-`;
-    help += `  Agent content here...
-
-`;
-    return help;
-  },
-  detectFromEnvironment() {
-    try {
-      const cwd = process.cwd();
-      return fs4.existsSync(path6.join(cwd, "opencode.jsonc"));
-    } catch {
-      return false;
-    }
-  },
-  async transformRulesContent(content) {
-    return yamlUtils.stripFrontMatter(content);
-  },
-  async setupAgents(cwd, options) {
-    const oldCommandsDir = path6.join(cwd, ".opencode/commands");
-    try {
-      await fs4.rm(oldCommandsDir, { recursive: true, force: true });
-    } catch {}
-    const installer = new FileInstaller;
-    const agentsDir = path6.join(cwd, this.config.agentDir);
-    const results = await installer.installToDirectory(getAgentsDir(), agentsDir, async (content, sourcePath) => {
-      return await this.transformAgentContent(content, undefined, sourcePath);
-    }, {
-      ...options,
-      showProgress: false
-    });
-    return { count: results.length };
-  },
-  async setupOutputStyles(cwd, _options) {
-    if (!this.config.rulesFile) {
-      return { count: 0 };
-    }
-    const rulesFilePath = path6.join(cwd, this.config.rulesFile);
-    let existingContent = "";
-    if (fs4.existsSync(rulesFilePath)) {
-      existingContent = fs4.readFileSync(rulesFilePath, "utf8");
-    }
-    const outputStylesSourceDir = getOutputStylesDir();
-    if (!fs4.existsSync(outputStylesSourceDir)) {
-      return { count: 0 };
-    }
-    let outputStylesContent = `
-
----
-
-# Output Styles
-
-`;
-    const files = fs4.readdirSync(outputStylesSourceDir, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name);
-    if (files.length === 0) {
-      return { count: 0 };
-    }
-    for (const styleFile of files) {
-      const sourcePath = path6.join(outputStylesSourceDir, styleFile);
-      let content = fs4.readFileSync(sourcePath, "utf8");
-      if (this.transformRulesContent) {
-        content = await this.transformRulesContent(content);
-      }
-      outputStylesContent += `${content}
-
-`;
-    }
-    const outputStylesMarker = "# Output Styles";
-    if (existingContent.includes(outputStylesMarker)) {
-      const startIndex = existingContent.indexOf(`---
-
-# Output Styles`);
-      if (startIndex !== -1) {
-        existingContent = existingContent.substring(0, startIndex);
-      }
-    }
-    fs4.writeFileSync(rulesFilePath, existingContent + outputStylesContent, "utf8");
-    return { count: files.length };
-  },
-  async setupRules(cwd, options) {
-    if (!this.config.rulesFile) {
-      return { count: 0 };
-    }
-    if (!ruleFileExists("core")) {
-      throw new Error("Core rules file not found");
-    }
-    const installer = new FileInstaller;
-    const rulesDestPath = path6.join(cwd, this.config.rulesFile);
-    const rulePath = getRulesPath("core");
-    await installer.installFile(rulePath, rulesDestPath, async (content) => {
-      if (this.transformRulesContent) {
-        return await this.transformRulesContent(content);
-      }
-      return content;
-    }, {
-      ...options,
-      showProgress: false
-    });
-    return { count: 1 };
-  },
-  async setupMCP(cwd, options) {
-    if (!options.dryRun) {
-      await secretUtils.ensureSecretsDir(cwd);
-      await secretUtils.addToGitignore(cwd);
-    }
-    const installer = new MCPInstaller(this);
-    const result = await installer.setupMCP({ ...options, quiet: true });
-    return { count: result.selectedServers.length };
-  },
-  async setupSlashCommands(cwd, options) {
-    if (!this.config.slashCommandsDir) {
-      return { count: 0 };
-    }
-    const oldCommandsDir = path6.join(cwd, ".opencode/commands");
-    try {
-      await fs4.rm(oldCommandsDir, { recursive: true, force: true });
-    } catch {}
-    const installer = new FileInstaller;
-    const slashCommandsDir = path6.join(cwd, this.config.slashCommandsDir);
-    const results = await installer.installToDirectory(getSlashCommandsDir(), slashCommandsDir, async (content) => {
-      return content;
-    }, {
-      ...options,
-      showProgress: false
-    });
-    return { count: results.length };
-  },
-  async executeCommand(systemPrompt, userPrompt, options = {}) {
-    if (options.dryRun) {
-      const dryRunArgs = ["opencode"];
-      if (options.print) {
-        dryRunArgs.push("run");
-        if (options.continue) {
-          dryRunArgs.push("-c");
-        }
-        if (userPrompt && userPrompt.trim() !== "") {
-          dryRunArgs.push(`"${userPrompt}"`);
-        }
-      } else {
-        if (options.agent) {
-          dryRunArgs.push("--agent", options.agent);
-        }
-        if (userPrompt && userPrompt.trim() !== "") {
-          dryRunArgs.push("-p", `"${userPrompt}"`);
-        }
-      }
-      console.log(chalk3.cyan("Dry run - Would execute:"));
-      console.log(chalk3.bold(dryRunArgs.join(" ")));
-      console.log(chalk3.dim(`Agent: ${options.agent || "coder"}`));
-      console.log(chalk3.dim(`User prompt: ${userPrompt.length} characters`));
-      console.log("✓ Dry run completed successfully");
-      return;
-    }
-    try {
-      const { spawn } = await import("node:child_process");
-      const args = [];
-      if (options.print) {
-        args.push("run");
-        if (options.continue) {
-          args.push("-c");
-        }
-        if (userPrompt && userPrompt.trim() !== "") {
-          args.push(userPrompt);
-        }
-      } else {
-        if (options.agent) {
-          args.push("--agent", options.agent);
-        }
-        if (userPrompt && userPrompt.trim() !== "") {
-          args.push("-p", userPrompt);
-        }
-      }
-      if (options.verbose || options.print) {
-        console.log(chalk3.dim(`$ opencode ${args.join(" ")}`));
-      }
-      await new Promise((resolve, reject) => {
-        const child = spawn("opencode", args, {
-          stdio: options.print ? ["ignore", "inherit", "inherit"] : "inherit",
-          shell: true,
-          env: process.env
-        });
-        child.on("spawn", () => {
-          if (options.verbose) {
-            console.log("✓ OpenCode process started");
-          }
-        });
-        child.on("error", (error) => {
-          console.error("✗ Error spawning OpenCode:", error);
-          reject(error);
-        });
-        child.on("close", (code) => {
-          if (code !== 0) {
-            reject(new Error(`OpenCode exited with code ${code}`));
-          } else {
-            resolve();
-          }
-        });
-      });
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new CLIError(`Failed to execute OpenCode: ${error.message}`, "OPENCODE_ERROR");
-      }
-      throw error;
-    }
-  }
-};
-export {
-  opencodeTarget
-};
-
-export { secretUtils, CLIError, FileInstaller, MCPInstaller, opencodeTarget };