conductor-install 0.1.1 → 0.1.2

package/dist/conductor-install.cjs

@@ -1,779 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
-
-// src/conductor-install.ts
-var import_yargs = __toESM(require("yargs"), 1);
-var import_helpers = require("yargs/helpers");
-
-// src/cli/prompt.ts
-var import_select = __toESM(require("@inquirer/select"), 1);
-
-// src/generators/opencode/config.ts
-var opencodeConfig = {
-  agentType: "opencode",
-  agentDir: ".opencode",
-  commandsDir: "commands",
-  displayName: "OpenCode",
-  protocolFilename: "AGENTS.md",
-  description: "The open source AI coding agent"
-};
-
-// src/generators/claude-code/config.ts
-var claudeCodeConfig = {
-  agentType: "claude-code",
-  agentDir: ".claude",
-  commandsDir: "commands",
-  displayName: "Claude Code",
-  protocolFilename: "CLAUDE.md",
-  description: "Anthropic's coding assistant"
-};
-
-// src/generators/antigravity/config.ts
-var antigravityConfig = {
-  agentType: "antigravity",
-  agentDir: ".agent",
-  commandsDir: "workflows",
-  displayName: "Antigravity",
-  protocolFilename: "GEMINI.md",
-  description: "Google's agentic coding assistant"
-};
-
-// src/generators/cursor/config.ts
-var cursorConfig = {
-  agentType: "cursor",
-  agentDir: ".cursor",
-  commandsDir: "commands",
-  displayName: "Cursor",
-  protocolFilename: "AGENTS.md",
-  description: "Cursor IDE's AI agent"
-};
-
-// src/generators/vscode-copilot/strategy.ts
-var import_smol_toml = require("smol-toml");
-
-// src/utils/template.ts
-var import_promises = require("fs/promises");
-var import_path = require("path");
-var import_url = require("url");
-var import_os = require("os");
-var import_child_process = require("child_process");
-var import_crypto = require("crypto");
-var import_fs_extra = __toESM(require("fs-extra"), 1);
-var __dirname = (0, import_url.fileURLToPath)(new URL(".", importMetaUrl));
-var DEFAULT_REPO = "https://github.com/gemini-cli-extensions/conductor";
-var DEFAULT_BRANCH = "main";
-function getCacheDir(repo = DEFAULT_REPO, branch = DEFAULT_BRANCH) {
-  const hash = (0, import_crypto.createHash)("md5").update(`${repo}#${branch}`).digest("hex");
-  return (0, import_path.join)((0, import_os.homedir)(), ".gemini/cache/conductor", hash);
-}
-async function ensureTemplates(repo = DEFAULT_REPO, branch = DEFAULT_BRANCH) {
-  const cacheDir = getCacheDir(repo, branch);
-  if (!import_fs_extra.default.existsSync(cacheDir)) {
-    await import_fs_extra.default.ensureDir(cacheDir);
-    console.log(`Downloading templates from ${repo} [${branch}]...`);
-    try {
-      (0, import_child_process.execSync)(`git clone ${repo} --branch ${branch} --depth 1 .`, {
-        cwd: cacheDir,
-        stdio: ["ignore", "ignore", "pipe"]
-      });
-    } catch (e) {
-      await import_fs_extra.default.remove(cacheDir);
-      throw new Error(
-        `Failed to clone templates: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  } else {
-    try {
-      console.log(`Updating templates from ${repo} [${branch}]...`);
-      (0, import_child_process.execSync)("git pull --rebase", {
-        cwd: cacheDir,
-        stdio: ["ignore", "ignore", "pipe"]
-      });
-    } catch (e) {
-      console.warn(
-        `Failed to update templates (using cached version): ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }
-}
-function substituteVariables(template, variables) {
-  return template.replace(/\{(\w+)\}/g, (match, key) => {
-    if (Object.prototype.hasOwnProperty.call(variables, key)) {
-      return variables[key];
-    }
-    return match;
-  });
-}
-function getBundledTemplateRoot() {
-  const prodDest = (0, import_path.resolve)(__dirname, "conductor");
-  if (import_fs_extra.default.existsSync(prodDest)) {
-    return prodDest;
-  }
-  return (0, import_path.resolve)(__dirname, "../conductor");
-}
-async function getTemplateRoot(repo, branch) {
-  if (!repo && !branch) {
-    const bundledRoot = getBundledTemplateRoot();
-    if (await import_fs_extra.default.pathExists(bundledRoot)) {
-      return bundledRoot;
-    }
-  }
-  await ensureTemplates(repo, branch);
-  return getCacheDir(repo, branch);
-}
-async function loadTemplate(templatePath, repo, branch) {
-  if (!repo && !branch) {
-    const bundledPath = (0, import_path.resolve)(getBundledTemplateRoot(), templatePath);
-    if (await import_fs_extra.default.pathExists(bundledPath)) {
-      return (0, import_promises.readFile)(bundledPath, "utf-8");
-    }
-  }
-  if (!repo && !branch) {
-    console.log(
-      `Bundled template not found: ${templatePath}, falling back to remote repository...`
-    );
-    await ensureTemplates(repo, branch);
-  }
-  const rootDir = await getTemplateRoot(repo, branch);
-  const fullPath = (0, import_path.join)(rootDir, templatePath);
-  return (0, import_promises.readFile)(fullPath, "utf-8");
-}
-
-// src/generators/vscode-copilot/strategy.ts
-var VsCodeCopilotContentStrategy = class {
-  process(templateContent, options) {
-    const { installPath, agentType, fixedAgent } = options;
-    const parsed = (0, import_smol_toml.parse)(templateContent);
-    if (!parsed.prompt) {
-      return null;
-    }
-    let prompt = parsed.prompt;
-    prompt = prompt.replace(/__\$\$CODE_AGENT_INSTALL_PATH\$\$__/g, installPath);
-    const finalContent = substituteVariables(prompt, { agent_type: agentType });
-    return `---
-description: ${parsed.description || ""}
-agent: ${fixedAgent}
----
-${finalContent}`;
-  }
-};
-var vscodeCopilotContentStrategy = new VsCodeCopilotContentStrategy();
-
-// src/generators/vscode-copilot/config.ts
-var vscodeCopilotConfig = {
-  agentType: "vscode-copilot",
-  agentDir: ".github",
-  commandsDir: "prompts",
-  displayName: "VS Code Copilot",
-  protocolFilename: "AGENTS.md",
-  description: "VS Code Copilot's Prompt Files",
-  extension: ".prompt.md",
-  fixedAgent: "agent",
-  strategy: {
-    content: vscodeCopilotContentStrategy
-  }
-};
-
-// src/generators/codex/config.ts
-var codexConfig = {
-  agentType: "codex",
-  agentDir: ".codex",
-  commandsDir: "prompts",
-  displayName: "Codex",
-  protocolFilename: "AGENTS.md",
-  description: "OpenAI Codex Agent",
-  extension: ".md"
-};
-
-// src/generators/windsurf/config.ts
-var windsurfConfig = {
-  agentType: "windsurf",
-  agentDir: ".windsurf",
-  commandsDir: "workflows",
-  displayName: "Windsurf",
-  protocolFilename: "AGENTS.md",
-  description: "Windsurf Cascade AI Agent"
-};
-
-// src/generators/cline/strategy.ts
-var import_smol_toml2 = require("smol-toml");
-var ClineContentStrategy = class {
-  process(templateContent, options) {
-    const { installPath, agentType, commandName } = options;
-    const parsed = (0, import_smol_toml2.parse)(templateContent);
-    if (!parsed.prompt) {
-      return null;
-    }
-    let prompt = parsed.prompt;
-    prompt = prompt.replace(/__\$\$CODE_AGENT_INSTALL_PATH\$\$__/g, installPath);
-    const finalContent = substituteVariables(prompt, { agent_type: agentType });
-    const title = commandName ? commandName.charAt(0).toUpperCase() + commandName.slice(1) : "Command";
-    return `# Conductor ${title}${parsed.description ? "\n\n" + parsed.description + "\n\n" : "\n\n"}${finalContent}`;
-  }
-};
-var clineContentStrategy = new ClineContentStrategy();
-
-// src/generators/cline/config.ts
-var clineConfig = {
-  agentType: "cline",
-  agentDir: ".clinerules",
-  commandsDir: "workflows",
-  displayName: "Cline",
-  protocolFilename: "AGENTS.md",
-  description: "Cline AI coding assistant",
-  strategy: {
-    content: clineContentStrategy
-  }
-};
-
-// src/generators/gemini/strategy.ts
-var import_path2 = require("path");
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var import_smol_toml3 = require("smol-toml");
-var { writeFile } = import_fs_extra2.default;
-var GeminiContentStrategy = class {
-  process(templateContent, options) {
-    const { installPath, agentType } = options;
-    const parsed = (0, import_smol_toml3.parse)(templateContent);
-    if (!parsed.prompt) {
-      return null;
-    }
-    const content = templateContent.replace(/__\$\$CODE_AGENT_INSTALL_PATH\$\$__/g, installPath);
-    return substituteVariables(content, { agent_type: agentType });
-  }
-};
-var GeminiFileStrategy = class {
-  async write(options) {
-    const { targetDir, agentDir, commandsDir, commandName, extension, content } = options;
-    const fileName = `${commandName}${extension}`;
-    await writeFile((0, import_path2.join)(targetDir, agentDir, commandsDir, fileName), content);
-  }
-};
-var geminiContentStrategy = new GeminiContentStrategy();
-var geminiFileStrategy = new GeminiFileStrategy();
-
-// src/generators/gemini/config.ts
-var geminiConfig = {
-  agentType: "gemini",
-  agentDir: ".gemini",
-  commandsDir: "commands/conductor",
-  displayName: "Gemini CLI",
-  protocolFilename: "GEMINI.md",
-  description: "Google Gemini CLI agent",
-  extension: ".toml",
-  usesPrefix: false,
-  strategy: {
-    content: geminiContentStrategy,
-    file: geminiFileStrategy
-  }
-};
-
-// src/generators/registry.ts
-var ALL_AGENT_CONFIGS = [
-  opencodeConfig,
-  claudeCodeConfig,
-  antigravityConfig,
-  cursorConfig,
-  vscodeCopilotConfig,
-  codexConfig,
-  windsurfConfig,
-  clineConfig,
-  geminiConfig
-];
-
-// src/cli/prompt.ts
-async function promptForInstallScope(agent) {
-  const isCodex = agent === "codex";
-  const isCline = agent === "cline";
-  const choices = isCodex ? [{ name: "Global (User Home Directory)", value: "global" }] : [{ name: "Project (Current Directory)", value: "project" }];
-  const answer = await (0, import_select.default)({
-    message: "Select installation method:",
-    choices,
-    default: isCodex ? "global" : "project"
-  });
-  return answer;
-}
-async function promptForAgent() {
-  const choices = ALL_AGENT_CONFIGS.map((config) => {
-    const {
-      displayName,
-      agentType,
-      protocolFilename,
-      agentDir,
-      commandsDir,
-      description
-    } = config;
-    const finalDescription = description || `${displayName} agent`;
-    const pathInfo = `\x1B[90m(${protocolFilename}, ${agentDir}/${commandsDir})\x1B[0m`;
-    return {
-      name: `${displayName} ${pathInfo}`,
-      value: agentType,
-      description: finalDescription
-    };
-  });
-  const answer = await (0, import_select.default)({
-    message: "Select your coding agent:",
-    choices,
-    default: "opencode",
-    loop: true
-  });
-  return answer;
-}
-
-// src/generators/default/strategy.ts
-var import_path3 = require("path");
-var import_fs_extra3 = __toESM(require("fs-extra"), 1);
-var import_smol_toml4 = require("smol-toml");
-var { writeFile: writeFile2 } = import_fs_extra3.default;
-var DefaultContentStrategy = class {
-  process(templateContent, options) {
-    const { installPath, agentType } = options;
-    const parsed = (0, import_smol_toml4.parse)(templateContent);
-    if (!parsed.prompt) {
-      return null;
-    }
-    let prompt = parsed.prompt;
-    prompt = prompt.replace(/__\$\$CODE_AGENT_INSTALL_PATH\$\$__/g, installPath);
-    const finalContent = substituteVariables(prompt, { agent_type: agentType });
-    if (parsed.description) {
-      return `---
-description: ${parsed.description}
----
-${finalContent}`;
-    }
-    return finalContent;
-  }
-};
-var DefaultFileStrategy = class {
-  async write(options) {
-    const { targetDir, agentDir, commandsDir, commandName, extension, content } = options;
-    const fileName = `conductor:${commandName}${extension}`;
-    await writeFile2((0, import_path3.join)(targetDir, agentDir, commandsDir, fileName), content);
-  }
-};
-var defaultContentStrategy = new DefaultContentStrategy();
-var defaultFileStrategy = new DefaultFileStrategy();
-
-// src/generators/ConfigurableGenerator.ts
-var import_path4 = require("path");
-var import_select2 = __toESM(require("@inquirer/select"), 1);
-var import_fs_extra4 = __toESM(require("fs-extra"), 1);
-var { existsSync, ensureDir, writeFile: writeFile3, copy } = import_fs_extra4.default;
-var ConfigurableGenerator = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async validate(targetDir, scope) {
-    if (!existsSync(targetDir)) {
-      throw new Error(`Target directory does not exist: ${targetDir}`);
-    }
-    const { agentDir, commandsDir, displayName, extension, usesPrefix } = this.config;
-    const ext = extension || ".md";
-    const prefix = usesPrefix !== false ? "conductor:" : "";
-    const setupFileName = `${prefix}setup${ext}`;
-    const setupFile = (0, import_path4.join)(targetDir, agentDir, commandsDir, setupFileName);
-    const conductorPath = (0, import_path4.join)(targetDir, agentDir, "conductor");
-    if (existsSync(conductorPath) && existsSync(setupFile)) {
-      throw new Error(
-        `Conductor (${displayName}) is already installed in: ${targetDir}`
-      );
-    }
-    return targetDir;
-  }
-  async generate(targetDir, scope, repo, branch, force) {
-    const { agentDir, commandsDir, agentType } = this.config;
-    const agentPath = (0, import_path4.join)(targetDir, agentDir);
-    const targetCommandsDir = (0, import_path4.join)(agentPath, commandsDir);
-    let installPath = (0, import_path4.join)(agentDir, "conductor");
-    if (scope === "global") {
-      installPath = `~/${agentDir}/conductor`;
-    }
-    await ensureDir(targetCommandsDir);
-    await ensureDir((0, import_path4.join)(agentPath, "conductor"));
-    const templateRoot = await getTemplateRoot(repo, branch);
-    try {
-      const templateSource = (0, import_path4.join)(templateRoot, "templates");
-      const templateDest = (0, import_path4.join)(agentPath, "conductor", "templates");
-      await copy(templateSource, templateDest);
-    } catch (e) {
-      console.warn("Failed to copy templates directory:", e);
-    }
-    const { protocolFilename } = this.config;
-    if (protocolFilename) {
-      try {
-        const protocolSource = (0, import_path4.join)(templateRoot, "GEMINI.md");
-        const protocolDest = (0, import_path4.join)(targetDir, protocolFilename);
-        if (existsSync(protocolSource)) {
-          let shouldCopy = true;
-          if (existsSync(protocolDest) && !force) {
-            shouldCopy = await (0, import_select2.default)({
-              message: `The protocol file '${protocolFilename}' already exists. Do you want to overwrite it?`,
-              choices: [
-                { value: true, name: "Overwrite" },
-                { value: false, name: "Skip" }
-              ]
-            });
-          }
-          if (shouldCopy) {
-            await copy(protocolSource, protocolDest);
-          }
-        }
-      } catch (e) {
-        console.warn("Failed to handle protocol file:", e);
-      }
-    }
-    const commands = [
-      "setup",
-      "newTrack",
-      "implement",
-      "status",
-      "revert",
-      "review"
-    ];
-    const extension = this.config.extension || ".md";
-    const fixedAgent = this.config.fixedAgent;
-    for (const cmd of commands) {
-      try {
-        const tomlContent = await loadTemplate(
-          `commands/conductor/${cmd}.toml`,
-          repo,
-          branch
-        );
-        const contentStrategy = this.config.strategy?.content || defaultContentStrategy;
-        const finalContent = contentStrategy.process(tomlContent, {
-          installPath,
-          agentType,
-          fixedAgent,
-          commandName: cmd
-        });
-        if (finalContent) {
-          const fileStrategy = this.config.strategy?.file || defaultFileStrategy;
-          await fileStrategy.write({
-            targetDir,
-            agentDir,
-            commandsDir,
-            commandName: cmd,
-            extension,
-            content: finalContent
-          });
-        }
-      } catch (e) {
-        console.warn(`Failed to process ${cmd}:`, e);
-      }
-    }
-  }
-};
-
-// src/generators/factory.ts
-function createGenerator(config) {
-  return new ConfigurableGenerator(config);
-}
-
-// src/generators/opencode/generator.ts
-var OpenCodeGenerator = class {
-  generator = createGenerator(opencodeConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/claude-code/generator.ts
-var ClaudeCodeGenerator = class {
-  generator = createGenerator(claudeCodeConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/antigravity/generator.ts
-var AntigravityGenerator = class {
-  generator = createGenerator(antigravityConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/cursor/generator.ts
-var CursorGenerator = class {
-  generator = createGenerator(cursorConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/vscode-copilot/generator.ts
-var VSCodeCopilotGenerator = class {
-  generator = createGenerator(vscodeCopilotConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/codex/generator.ts
-var import_os2 = require("os");
-var CodexGenerator = class {
-  generator = createGenerator(codexConfig);
-  validate(targetDir, scope) {
-    if (scope === "global") {
-      targetDir = (0, import_os2.homedir)();
-    }
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    if (scope === "global") {
-      targetDir = (0, import_os2.homedir)();
-    }
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/windsurf/generator.ts
-var WindsurfGenerator = class {
-  generator = createGenerator(windsurfConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/cline/generator.ts
-var ClineGenerator = class {
-  generator = createGenerator(clineConfig);
-  validate(targetDir, scope) {
-    return this.generator.validate(targetDir, scope);
-  }
-  generate(targetDir, scope, repo, branch) {
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/gemini/generator.ts
-var GeminiGenerator = class {
-  generator = createGenerator(geminiConfig);
-  async validate(targetDir, scope) {
-    if (scope === "global") {
-      throw new Error("Gemini CLI agent only supports project-level installation");
-    }
-    return this.generator.validate(targetDir, scope);
-  }
-  async generate(targetDir, scope, repo, branch) {
-    if (scope === "global") {
-      throw new Error("Gemini CLI agent only supports project-level installation");
-    }
-    return this.generator.generate(targetDir, scope, repo, branch);
-  }
-};
-
-// src/generators/index.ts
-function getGenerator(agentType) {
-  switch (agentType) {
-    case "claude-code":
-      return new ClaudeCodeGenerator();
-    case "antigravity":
-      return new AntigravityGenerator();
-    case "cursor":
-      return new CursorGenerator();
-    case "vscode-copilot":
-      return new VSCodeCopilotGenerator();
-    case "codex":
-      return new CodexGenerator();
-    case "windsurf":
-      return new WindsurfGenerator();
-    case "cline":
-      return new ClineGenerator();
-    case "gemini":
-      return new GeminiGenerator();
-    case "opencode":
-    default:
-      return new OpenCodeGenerator();
-  }
-}
-
-// src/commands/install.ts
-var import_path5 = require("path");
-var import_select3 = __toESM(require("@inquirer/select"), 1);
-async function installHandler(argv) {
-  const targetDir = (0, import_path5.resolve)(process.cwd(), argv.path);
-  const force = argv.force ?? false;
-  try {
-    console.log(`Initializing Conductor in: ${targetDir}`);
-    let agent;
-    if (argv.agent) {
-      agent = argv.agent;
-      console.log(`Using provided agent: ${agent}`);
-    } else {
-      console.log("Step 1: Prompting for agent selection...");
-      agent = await promptForAgent();
-      console.log(`\u2714 Selected agent: ${agent}`);
-    }
-    let scope;
-    if (argv.scope) {
-      scope = argv.scope;
-      console.log(`Using provided scope: ${scope}`);
-    } else {
-      scope = await promptForInstallScope(agent);
-    }
-    console.log(`\u2714 Selected scope: ${scope}`);
-    const generator = getGenerator(agent);
-    console.log("\nStep 3: Validating project directory...");
-    let validatedPath;
-    try {
-      validatedPath = await generator.validate(targetDir, scope);
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("already installed")) {
-        if (force) {
-          console.log("\u26A0 Force mode: Overwriting existing installation");
-          validatedPath = targetDir;
-        } else {
-          const shouldOverwrite = await (0, import_select3.default)({
-            message: `${err.message}
-Do you want to overwrite the existing installation?`,
-            choices: [
-              { value: true, name: "Yes, overwrite" },
-              { value: false, name: "No, cancel" }
-            ]
-          });
-          if (shouldOverwrite) {
-            console.log("Overwriting existing installation...");
-            validatedPath = targetDir;
-          } else {
-            console.log("Installation cancelled.");
-            return;
-          }
-        }
-      } else {
-        throw err;
-      }
-    }
-    console.log(`\u2714 Validation complete: ${validatedPath}`);
-    console.log("\nStep 4: Generating files...");
-    await generator.generate(
-      validatedPath,
-      scope,
-      argv.repo,
-      argv.branch,
-      force
-    );
-    console.log("\u2714 Files generated");
-    console.log("\n\u2714 Conductor initialized successfully!");
-  } catch (err) {
-    console.error(
-      "\n\u2718 Installation failed:",
-      err instanceof Error ? err.message : err
-    );
-    process.exit(1);
-  }
-}
-
-// src/utils/banner.ts
-var import_gradient_string = __toESM(require("gradient-string"), 1);
-var CONDUCTOR_INSTALL_BANNER = `
-   __________  _   ______  __  __________________  ____     _____   _______________  __    __ 
-  / ____/ __ \\/ | / / __ \\/ / / / ____/_  __/ __ \\/ __ \\   /  _/ | / / ___/_  __/   |/ /   / / 
- / /   / / / /  |/ / / / / / / / /     / / / / / / /_/ /   / //  |/ /\\__ \\ / / / /| / /   / /  
-/ /___/ /_/ / /|  / /_/ / /_/ / /___  / / / /_/ / _, _/  _/ // /|  /___/ // / / ___ / /___/ /___
-\\____/\\____/_/ |_/_____/\\____/\\____/ /_/  \\____/_/ |_|  /___/_/ |_//____//_/ /_/  |_/_____/_____/
-                                                                                                
-`;
-function printInstallBanner() {
-  console.log((0, import_gradient_string.default)("green", "cyan")(CONDUCTOR_INSTALL_BANNER));
-}
-
-// src/conductor-install.ts
-async function main() {
-  printInstallBanner();
-  const argv = await (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName("conductor-install").usage("$0 [path] [options]").positional("path", {
-    describe: "Directory to install Conductor",
-    default: ".",
-    type: "string"
-  }).option("agent", {
-    alias: "a",
-    describe: "Specify the coding agent",
-    type: "string",
-    choices: [
-      "opencode",
-      "claude-code",
-      "antigravity",
-      "cursor",
-      "vscode-copilot",
-      "codex",
-      "windsurf",
-      "cline",
-      "gemini"
-    ]
-  }).option("repo", {
-    alias: "r",
-    describe: "Git repository URL for conductor",
-    type: "string",
-    default: DEFAULT_REPO
-  }).option("branch", {
-    alias: "b",
-    describe: "Branch name for conductor repository",
-    type: "string",
-    default: DEFAULT_BRANCH
-  }).option("scope", {
-    alias: "s",
-    describe: "Installation scope (project or global)",
-    type: "string",
-    choices: ["project", "global"]
-  }).option("force", {
-    alias: "f",
-    describe: "Force overwrite existing installation",
-    type: "boolean",
-    default: false
-  }).help().alias("h", "help").version().alias("v", "version").parseAsync();
-  const pathArg = argv._[0];
-  await installHandler({
-    ...argv,
-    path: pathArg || argv.path || ".",
-    $0: "conductor-install",
-    _: argv._
-  });
-}
-main().catch((err) => {
-  console.error("Error:", err instanceof Error ? err.message : err);
-  process.exit(1);
-});