conductor-install 0.0.1

package/dist/index.js

@@ -0,0 +1,749 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/cli/prompt.ts
+import select from "@inquirer/select";
+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 select({
+    message: "Select installation method:",
+    choices,
+    default: isCodex ? "global" : "project"
+  });
+  return answer;
+}
+async function promptForAgent() {
+  const answer = await select({
+    message: "Select your coding agent:",
+    choices: [
+      {
+        name: "OpenCode",
+        value: "opencode",
+        description: "The open source AI coding agent"
+      },
+      {
+        name: "Claude Code",
+        value: "claude-code",
+        description: "Anthropic's coding assistant"
+      },
+      {
+        name: "Antigravity",
+        value: "antigravity",
+        description: "Google's agentic coding assistant"
+      },
+      {
+        name: "Cursor",
+        value: "cursor",
+        description: "Cursor IDE's AI agent"
+      },
+      {
+        name: "VS Code Copilot",
+        value: "vscode-copilot",
+        description: "VS Code Copilot's Prompt Files"
+      },
+      {
+        name: "Codex",
+        value: "codex",
+        description: "OpenAI Codex Agent"
+      },
+      {
+        name: "Windsurf",
+        value: "windsurf",
+        description: "Windsurf Cascade AI Agent"
+      },
+      {
+        name: "Cline",
+        value: "cline",
+        description: "Cline AI coding assistant"
+      },
+      {
+        name: "Gemini CLI",
+        value: "gemini",
+        description: "Google Gemini CLI agent"
+      }
+    ],
+    default: "opencode"
+  });
+  return answer;
+}
+
+// src/generators/default/strategy.ts
+import { join as join2 } from "path";
+import fs2 from "fs-extra";
+import { parse } from "smol-toml";
+
+// src/utils/template.ts
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import fs from "fs-extra";
+var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
+var DEFAULT_REPO = "https://github.com/gemini-cli-extensions/conductor";
+var DEFAULT_BRANCH = "main";
+function getCacheDir(repo = DEFAULT_REPO, branch = DEFAULT_BRANCH) {
+  const hash = createHash("md5").update(`${repo}#${branch}`).digest("hex");
+  return join(homedir(), ".gemini/cache/conductor", hash);
+}
+async function ensureTemplates(repo = DEFAULT_REPO, branch = DEFAULT_BRANCH) {
+  const cacheDir = getCacheDir(repo, branch);
+  if (!fs.existsSync(cacheDir)) {
+    await fs.ensureDir(cacheDir);
+    console.log(`Downloading templates from ${repo} [${branch}]...`);
+    try {
+      execSync(`git clone ${repo} --branch ${branch} --depth 1 .`, {
+        cwd: cacheDir,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    } catch (e) {
+      await fs.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}]...`);
+      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 = resolve(__dirname2, "conductor");
+  if (fs.existsSync(prodDest)) {
+    return prodDest;
+  }
+  return resolve(__dirname2, "../conductor");
+}
+async function getTemplateRoot(repo, branch) {
+  if (!repo && !branch) {
+    const bundledRoot = getBundledTemplateRoot();
+    if (await fs.pathExists(bundledRoot)) {
+      return bundledRoot;
+    }
+  }
+  await ensureTemplates(repo, branch);
+  return getCacheDir(repo, branch);
+}
+async function loadTemplate(templatePath, repo, branch) {
+  const bundledPath = resolve(getBundledTemplateRoot(), templatePath);
+  if (await fs.pathExists(bundledPath)) {
+    return 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 = join(rootDir, templatePath);
+  return readFile(fullPath, "utf-8");
+}
+
+// src/generators/default/strategy.ts
+var { writeFile } = fs2;
+var DefaultContentStrategy = class {
+  process(templateContent, options) {
+    const { installPath, agentType } = options;
+    const parsed = 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 writeFile(join2(targetDir, agentDir, commandsDir, fileName), content);
+  }
+};
+var defaultContentStrategy = new DefaultContentStrategy();
+var defaultFileStrategy = new DefaultFileStrategy();
+
+// src/generators/opencode/config.ts
+var opencodeConfig = {
+  agentType: "opencode",
+  agentDir: ".opencode",
+  commandsDir: "commands",
+  displayName: "OpenCode",
+  protocolFilename: "AGENTS.md"
+};
+
+// src/generators/ConfigurableGenerator.ts
+import { join as join3 } from "path";
+import select2 from "@inquirer/select";
+import fs3 from "fs-extra";
+var { existsSync, ensureDir, writeFile: writeFile2, copy } = fs3;
+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 = join3(targetDir, agentDir, commandsDir, setupFileName);
+    const conductorPath = join3(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 = join3(targetDir, agentDir);
+    const targetCommandsDir = join3(agentPath, commandsDir);
+    let installPath = join3(agentDir, "conductor");
+    if (scope === "global") {
+      installPath = `~/${agentDir}/conductor`;
+    }
+    await ensureDir(targetCommandsDir);
+    await ensureDir(join3(agentPath, "conductor"));
+    const templateRoot = await getTemplateRoot(repo, branch);
+    try {
+      const templateSource = join3(templateRoot, "templates");
+      const templateDest = join3(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 = join3(templateRoot, "GEMINI.md");
+        const protocolDest = join3(targetDir, agentDir, protocolFilename);
+        if (existsSync(protocolSource)) {
+          let shouldCopy = true;
+          if (existsSync(protocolDest) && !force) {
+            shouldCopy = await select2({
+              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/config.ts
+var claudeCodeConfig = {
+  agentType: "claude-code",
+  agentDir: ".claude",
+  commandsDir: "commands",
+  displayName: "Claude Code",
+  protocolFilename: "CLAUDE.md"
+};
+
+// 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/config.ts
+var antigravityConfig = {
+  agentType: "antigravity",
+  agentDir: ".agent",
+  commandsDir: "workflows",
+  displayName: "Antigravity",
+  protocolFilename: "GEMINI.md"
+};
+
+// 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/config.ts
+var cursorConfig = {
+  agentType: "cursor",
+  agentDir: ".cursor",
+  commandsDir: "commands",
+  displayName: "Cursor",
+  protocolFilename: "AGENTS.md"
+};
+
+// 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/strategy.ts
+import { parse as parse2 } from "smol-toml";
+var VsCodeCopilotContentStrategy = class {
+  process(templateContent, options) {
+    const { installPath, agentType, fixedAgent } = options;
+    const parsed = parse2(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",
+  extension: ".prompt.md",
+  fixedAgent: "agent",
+  strategy: {
+    content: vscodeCopilotContentStrategy
+  }
+};
+
+// 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/config.ts
+var codexConfig = {
+  agentType: "codex",
+  agentDir: ".codex",
+  commandsDir: "prompts",
+  displayName: "Codex",
+  protocolFilename: "AGENTS.md",
+  extension: ".md"
+};
+
+// src/generators/codex/generator.ts
+import { homedir as homedir2 } from "os";
+var CodexGenerator = class {
+  generator = createGenerator(codexConfig);
+  validate(targetDir, scope) {
+    if (scope === "global") {
+      targetDir = homedir2();
+    }
+    return this.generator.validate(targetDir, scope);
+  }
+  generate(targetDir, scope, repo, branch) {
+    if (scope === "global") {
+      targetDir = homedir2();
+    }
+    return this.generator.generate(targetDir, scope, repo, branch);
+  }
+};
+
+// src/generators/windsurf/config.ts
+var windsurfConfig = {
+  agentType: "windsurf",
+  agentDir: ".windsurf",
+  commandsDir: "workflows",
+  displayName: "Windsurf",
+  protocolFilename: "AGENTS.md"
+};
+
+// 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/strategy.ts
+import { parse as parse3 } from "smol-toml";
+var ClineContentStrategy = class {
+  process(templateContent, options) {
+    const { installPath, agentType, commandName } = options;
+    const parsed = parse3(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",
+  strategy: {
+    content: clineContentStrategy
+  }
+};
+
+// 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/strategy.ts
+import { join as join4 } from "path";
+import fs4 from "fs-extra";
+import { parse as parse4 } from "smol-toml";
+var { writeFile: writeFile3 } = fs4;
+var GeminiContentStrategy = class {
+  process(templateContent, options) {
+    const { installPath, agentType } = options;
+    const parsed = parse4(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 writeFile3(join4(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",
+  extension: ".toml",
+  usesPrefix: false,
+  strategy: {
+    content: geminiContentStrategy,
+    file: geminiFileStrategy
+  }
+};
+
+// 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
+import { resolve as resolve2 } from "path";
+import select3 from "@inquirer/select";
+async function installHandler(argv) {
+  const targetDir = resolve2(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 select3({
+            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/cli/index.ts
+var cli = yargs(hideBin(process.argv)).scriptName("conductor").usage("$0 <cmd> [args]").command(
+  "install [path]",
+  "Install Conductor in the specified directory",
+  (yargs2) => {
+    return yargs2.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 templates",
+      type: "string"
+    }).option("branch", {
+      alias: "b",
+      describe: "Branch name for templates",
+      type: "string"
+    }).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
+    });
+  },
+  installHandler
+).help();
+
+// src/utils/banner.ts
+import gradient from "gradient-string";
+var CONDUCTOR_BANNER = `
+   __________  _   ______  __  __________________  ____     __ __     ___    __    __ 
+  / ____/ __ \\/ | / / __ \\/ / / / ____/_  __/ __ \\/ __ \\   / // /    /   |  / /   / / 
+ / /   / / / /  |/ / / / / / / / /     / / / / / / /_/ /  / // /_   / /| | / /   / /  
+/ /___/ /_/ / /|  / /_/ / /_/ / /___  / / / /_/ / _, _/  /__  __/  / ___ |/ /___/ /___
+\\____/\\____/_/ |_/_____/\\____/\\____/ /_/  \\____/_/ |_|     /_/    /_/  |_/_____/_____/
+                                                                                      
+`;
+function printBanner() {
+  console.log(gradient("green", "blue")(CONDUCTOR_BANNER));
+}
+
+// src/index.ts
+printBanner();
+cli.parse();