cc-codeconductor 0.2.6 → 0.2.8

package/dist/index.js

@@ -7044,7 +7044,7 @@ function getExitCode(error) {
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.2.6",
+  version: "0.2.8",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -7073,6 +7073,7 @@ var package_default = {
   },
   type: "module",
   bin: {
+    "cc-codeconductor": "./dist/index.js",
     codeconductor: "./dist/index.js"
   },
   scripts: {
@@ -7131,6 +7132,13 @@ async function detectProject(rootDir) {
     runtimes.push("python");
     frameworks.push("django");
   }
+  const phpSignals = await detectPhp(rootDir);
+  if (phpSignals.length > 0) {
+    signals.push(...phpSignals);
+    languages.push("php");
+    runtimes.push("php");
+    packageManagers.push("composer");
+  }
   const astroSignals = await detectAstro(rootDir);
   if (astroSignals.length > 0) {
     signals.push(...astroSignals);
@@ -7217,6 +7225,22 @@ async function detectAstro(rootDir) {
   }
   return signals;
 }
+async function detectPhp(rootDir) {
+  const { fileExists: fileExists2 } = await Promise.resolve().then(() => (init_safety(), exports_safety));
+  const signals = [];
+  if (await fileExists2(rootDir, "composer.json")) {
+    signals.push("composer.json");
+  }
+  try {
+    const { readdir } = await import("node:fs/promises");
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    const hasPhpFiles = entries.some((entry) => entry.isFile() && entry.name.endsWith(".php"));
+    if (hasPhpFiles) {
+      signals.push("*.php");
+    }
+  } catch {}
+  return signals;
+}
 
 // src/commands/detect.command.ts
 async function detectCommand(options) {
@@ -11346,7 +11370,7 @@ var CodeConductorConfigSchema = exports_external.object({
     profile: exports_external.string().optional()
   }),
   defaults: exports_external.object({
-    target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor"]),
+    target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
     overwrite: exports_external.boolean()
   }),
   presets: exports_external.object({
@@ -11366,6 +11390,7 @@ var RunnerTargetSchema = exports_external.enum([
   "codex",
   "gemini",
   "cursor",
+  "agy",
   "all"
 ]);
 var InstallStrategySchema = exports_external.enum([
@@ -11383,20 +11408,23 @@ var ManifestEntrySchema = exports_external.object({
   template: exports_external.boolean().optional()
 });
 var InstallManifestSchema = exports_external.object({
-  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor"]),
+  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
   entries: exports_external.array(ManifestEntrySchema)
 });
 var ToolProviderNamesSchema = exports_external.record(exports_external.string(), exports_external.string());
+var PermissionProviderNamesSchema = exports_external.record(exports_external.string(), exports_external.string());
 var ModelConfigSchema = exports_external.object({
-  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor"]),
+  target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
   agents: exports_external.record(exports_external.string(), exports_external.object({
     claude: exports_external.string().optional(),
     opencode: exports_external.string().optional(),
     codex: exports_external.string().optional(),
     gemini: exports_external.string().optional(),
-    cursor: exports_external.string().optional()
+    cursor: exports_external.string().optional(),
+    agy: exports_external.string().optional()
   })),
-  tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional()
+  tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional(),
+  permissions: PermissionProviderNamesSchema.optional()
 });
 function validateCouncilSpec(data) {
   return CouncilSpecSchema.parse(data);
@@ -11720,6 +11748,8 @@ function resolveAssets(target) {
       return ["agents", "prompts/v0.2.0"];
     case "cursor":
       return ["agents", "prompts/v0.2.0"];
+    case "agy":
+      return ["agents", "prompts/v0.2.0"];
   }
 }
 
@@ -11903,7 +11933,27 @@ function getResponsibilities(agentId) {
     devil: `- Challenge assumptions
 - Find edge cases
 - Identify failure modes
-- Stress test solutions`
+- Stress test solutions`,
+    "seo-auditor": `- Audit technical SEO
+- Check meta tags and headings
+- Validate crawl directives
+- Assess page speed signals`,
+    "schema-validator": `- Validate Schema.org markup
+- Check JSON-LD syntax
+- Verify required properties
+- Suggest structured data fixes`,
+    "geo-specialist": `- Assess AI-search readiness
+- Validate llms.txt
+- Check citable content
+- Review GEO optimization`,
+    "content-strategist": `- Plan content marketing
+- Guide off-page SEO
+- Suggest backlink strategy
+- Review hotel copywriting`,
+    "astro-specialist": `- Validate Astro SEO patterns
+- Check static generation
+- Review Islands Architecture
+- Optimize image handling`
   };
   return responsibilities[agentId] || "- Provide critical review";
 }
@@ -12081,7 +12131,7 @@ function createCodexInstaller(spec) {
 function generateOpenCodeFiles(spec) {
   const files = [];
   files.push({
-    path: ".opencode/commands/council.md",
+    path: ".opencode/commands/cc-council.md",
     content: generateCouncilCommand(spec),
     overwrite: false
   });
@@ -12093,17 +12143,20 @@ function generateOpenCodeFiles(spec) {
   for (const agent of spec.agents) {
     files.push({
       path: `.opencode/agents/council-${agent.id}.md`,
-      content: generateAgentContent(agent),
+      content: generateOpenCodeAgentContent(agent),
       overwrite: false
     });
   }
   return files;
 }
 function generateCouncilCommand(spec) {
-  return `# Council Command
+  return `---
+description: ${yamlString(spec.description)}
+agent: council-lead
+subtask: true
+---
 
-## Description
-${spec.description}
+Run the CodeConductor council for multi-perspective analysis.
 
 ## Version
 ${spec.version}
@@ -12112,12 +12165,25 @@ ${spec.version}
 ${spec.agents.map((a) => `- ${a.role} (${a.id})`).join(`
 `)}
 
-## Usage
-Invoke this command to get multi-perspective analysis from the council.
+## Instructions
+Coordinate with the council agents and synthesize their perspectives into the configured output contract.
 `;
 }
 function generateCouncilLead(spec) {
-  return `# Council Lead Agent
+  return `---
+description: ${yamlString(`${spec.description} Council lead. Coordinates council members and synthesizes recommendations.`)}
+mode: subagent
+permission:
+  read: allow
+  edit: deny
+  bash: deny
+  glob: allow
+  grep: allow
+  webfetch: deny
+  websearch: deny
+---
+
+# Council Lead Agent
 
 ## Role
 Coordinates the council and synthesizes perspectives
@@ -12136,6 +12202,37 @@ ${spec.agents.map((a) => `- ${a.role}: ${a.focus.join(", ")}`).join(`
 - Provide final recommendation
 `;
 }
+function generateOpenCodeAgentContent(agent) {
+  return `---
+description: ${yamlString(`${agent.role} council agent. Focus: ${agent.focus.join(", ")}. Context: ${agent.context}. Model hint: ${agent.modelHint}.`)}
+mode: subagent
+permission:
+${generatePermissionBlock(agent.context)}
+---
+
+${generateAgentContent(agent)}`;
+}
+function generatePermissionBlock(context) {
+  if (context === "repo-readonly") {
+    return `  read: allow
+  edit: deny
+  bash: deny
+  glob: allow
+  grep: allow
+  webfetch: deny
+  websearch: deny`;
+  }
+  return `  read: deny
+  edit: deny
+  bash: deny
+  glob: deny
+  grep: deny
+  webfetch: deny
+  websearch: deny`;
+}
+function yamlString(value) {
+  return JSON.stringify(value);
+}
 
 // src/adapters/opencode/opencode-installer.ts
 class OpenCodeInstaller {
@@ -12319,7 +12416,7 @@ function renderTemplate(content, modelConfig, filePath) {
     const agentModels = modelConfig.agents[agentRole];
     const targetModel = agentModels[modelConfig.target];
     let result2 = content.replace(/\{\{MODEL\}\}/g, targetModel ?? "").replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "");
-    if (modelConfig.tools) {
+    if (modelConfig.tools || modelConfig.permissions) {
       result2 = substituteToolNames(result2, modelConfig);
     }
     return result2;
@@ -12348,19 +12445,27 @@ function renderTemplate(content, modelConfig, filePath) {
       }
     }
   }
-  if (modelConfig.tools) {
+  if (modelConfig.tools || modelConfig.permissions) {
     result = substituteToolNames(result, modelConfig);
   }
   return result;
 }
 function substituteToolNames(content, modelConfig) {
-  if (!modelConfig.tools)
+  if (!modelConfig.tools && !modelConfig.permissions)
     return content;
   const target = modelConfig.target;
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch)
     return content;
   const frontmatter = fmMatch[1];
+  if (target === "opencode" && modelConfig.permissions) {
+    const updatedFrontmatter2 = frontmatter.replace(/^tools:\s*(.+)\n?/m, "");
+    return content.replace(fmMatch[0], `---
+${updatedFrontmatter2}
+---`);
+  }
+  if (!modelConfig.tools)
+    return content;
   const updatedFrontmatter = frontmatter.replace(/^tools:\s*(.+)$/m, (_match, toolsLine) => {
     const baseNames = toolsLine.split(",").map((t) => t.trim());
     const mappedNames = baseNames.map((baseName) => {
@@ -12389,7 +12494,7 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
   const incomingContent = isTemplate && modelConfig ? renderTemplate(content, modelConfig, srcPath) : content;
   let finalContent = incomingContent;
   let action = "written";
-  if (strategy === "append" && !force) {
+  if (strategy === "append") {
     let existing = "";
     try {
       existing = await readFile4(destPath, "utf-8");
@@ -12402,7 +12507,7 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
 ` + incomingContent;
     }
     action = "appended";
-  } else if (strategy === "merge-json" && !force) {
+  } else if (strategy === "merge-json") {
     let existing = {};
     try {
       existing = JSON.parse(await readFile4(destPath, "utf-8"));
@@ -12503,8 +12608,8 @@ async function loadCouncilPreset(projectRoot) {
 }
 
 // src/core/runner/runner-target.ts
-var RUNNER_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "all"];
-var INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor"];
+var RUNNER_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "all"];
+var INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy"];
 function isRunnerTarget(value) {
   return RUNNER_TARGETS.includes(value);
 }
@@ -12660,6 +12765,638 @@ async function installPresetCommand(options) {
   }
 }
 
+// src/commands/install-lsp.command.ts
+import { homedir as homedir4 } from "node:os";
+import { resolve as resolve8 } from "node:path";
+
+// src/core/lsp/lsp-config-utils.ts
+function getLspCommand(lspId) {
+  switch (lspId) {
+    case "typescript":
+      return { command: "typescript-language-server", args: ["--stdio"] };
+    case "php":
+      return { command: "intelephense", args: ["--stdio"] };
+    case "python":
+      return { command: "pylsp", args: [] };
+    case "kotlin":
+      return { command: "kotlin-language-server", args: [] };
+    default:
+      return;
+  }
+}
+
+// src/adapters/agy/agy-lsp-generator.ts
+class AgyLspGenerator {
+  name = "agy-lsp";
+  target = "agy";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const sections = [
+      "# Agy LSP Configuration (experimental)",
+      "# NOTE: Agy config format may change as the tool evolves",
+      ""
+    ];
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        sections.push(`${lsp.lspId}:`);
+        sections.push(`  command: ${config.command}`);
+        if (config.args.length > 0) {
+          sections.push(`  args: [${config.args.join(", ")}]`);
+        }
+        sections.push("");
+      }
+    }
+    return [
+      {
+        path: ".agy/tools.yaml",
+        content: sections.join(`
+`),
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createAgyLspGenerator() {
+  return new AgyLspGenerator;
+}
+
+// src/adapters/claude/claude-lsp-generator.ts
+class ClaudeLspGenerator {
+  name = "claude-lsp";
+  target = "claude";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const mcpServers = {};
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        mcpServers[lsp.lspId] = { command: config.command, args: [...config.args] };
+      }
+    }
+    const content = JSON.stringify({
+      mcpServers
+    }, null, 2);
+    return [
+      {
+        path: ".claude/settings.json",
+        content,
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createClaudeLspGenerator() {
+  return new ClaudeLspGenerator;
+}
+
+// src/adapters/codex/codex-lsp-generator.ts
+var MCP_STARTUP_TIMEOUT_SEC = 120;
+
+class CodexLspGenerator {
+  name = "codex-lsp";
+  target = "codex";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const sections = ["# Codex LSP Configuration", ""];
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        sections.push(`[mcp_servers.${lsp.lspId}]`);
+        sections.push(`command = "${config.command}"`);
+        if (config.args.length > 0) {
+          sections.push(`args = [${config.args.map((a) => `"${a}"`).join(", ")}]`);
+        }
+        sections.push(`startup_timeout_sec = ${MCP_STARTUP_TIMEOUT_SEC}`);
+        sections.push("");
+      }
+    }
+    return [
+      {
+        path: ".codex/config.toml",
+        content: sections.join(`
+`),
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createCodexLspGenerator() {
+  return new CodexLspGenerator;
+}
+
+// src/adapters/cursor/cursor-lsp-generator.ts
+class CursorLspGenerator {
+  name = "cursor-lsp";
+  target = "cursor";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const mcpServers = {};
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        mcpServers[lsp.lspId] = { command: config.command, args: [...config.args] };
+      }
+    }
+    const content = JSON.stringify({
+      mcpServers
+    }, null, 2);
+    return [
+      {
+        path: ".cursor/mcp.json",
+        content,
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createCursorLspGenerator() {
+  return new CursorLspGenerator;
+}
+
+// src/adapters/gemini/gemini-lsp-generator.ts
+class GeminiLspGenerator {
+  name = "gemini-lsp";
+  target = "gemini";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const mcpServers = {};
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        mcpServers[lsp.lspId] = { command: config.command, args: [...config.args] };
+      }
+    }
+    const content = JSON.stringify({
+      mcpServers
+    }, null, 2);
+    return [
+      {
+        path: ".gemini/settings.json",
+        content,
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createGeminiLspGenerator() {
+  return new GeminiLspGenerator;
+}
+
+// src/adapters/opencode/opencode-lsp-generator.ts
+class OpenCodeLspGenerator {
+  name = "opencode-lsp";
+  target = "opencode";
+  generate(installedLsps) {
+    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    if (successfulLsps.length === 0) {
+      return [];
+    }
+    const mcp = {};
+    for (const lsp of successfulLsps) {
+      const config = getLspCommand(lsp.lspId);
+      if (config) {
+        mcp[lsp.lspId] = {
+          type: "local",
+          command: [config.command, ...config.args],
+          enabled: true,
+          timeout: 120000
+        };
+      }
+    }
+    const content = JSON.stringify({
+      $schema: "https://opencode.ai/config.json",
+      mcp
+    }, null, 2);
+    return [
+      {
+        path: ".opencode/opencode.json",
+        content,
+        overwrite: false
+      }
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+function createOpenCodeLspGenerator() {
+  return new OpenCodeLspGenerator;
+}
+
+// src/core/lsp/lsp-installer.ts
+import { execFile } from "node:child_process";
+import { access as access5, mkdir as mkdir5 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+
+class LspInstaller {
+  lspBinDir;
+  constructor() {
+    this.lspBinDir = join4(homedir3(), ".codeconductor", "lsp", "bin");
+  }
+  async checkInstalled(def) {
+    try {
+      const { stdout } = await execFileAsync("which", [def.binaryName], { timeout: 5000 });
+      const path = stdout.trim();
+      if (path) {
+        const version = await this.getVersion(def);
+        return { installed: true, version, path };
+      }
+    } catch {}
+    if (def.packageManager === "npm" && def.npmDetect) {
+      try {
+        const { stdout } = await execFileAsync("npm", ["list", "-g", def.npmDetect, "--depth=0"], { timeout: 1e4 });
+        if (stdout.includes(def.npmDetect)) {
+          const version = this.parseVersionFromNpmList(stdout, def.npmDetect);
+          return { installed: true, version };
+        }
+      } catch {}
+    }
+    if (def.packageManager === "pip" && def.pipDetect) {
+      try {
+        const { stdout } = await execFileAsync("pip", ["show", def.pipDetect], { timeout: 1e4 });
+        if (stdout.includes("Version:")) {
+          const version = this.parseVersionFromPipShow(stdout);
+          return { installed: true, version };
+        }
+      } catch {}
+    }
+    return { installed: false };
+  }
+  async installLsp(def) {
+    const status = await this.checkInstalled(def);
+    if (status.installed) {
+      return {
+        lspId: def.id,
+        status: "already-installed",
+        version: status.version
+      };
+    }
+    try {
+      switch (def.packageManager) {
+        case "npm":
+          await this.installNpm(def);
+          break;
+        case "pip":
+          await this.installPip(def);
+          break;
+        case "binary":
+          await this.installBinary(def);
+          break;
+      }
+      const newStatus = await this.checkInstalled(def);
+      return {
+        lspId: def.id,
+        status: "installed",
+        version: newStatus.version
+      };
+    } catch (error) {
+      return {
+        lspId: def.id,
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async installAll(lsps, options) {
+    const results = [];
+    for (const lsp of lsps) {
+      if (options.dryRun) {
+        const status = await this.checkInstalled(lsp);
+        results.push({
+          lspId: lsp.id,
+          status: status.installed ? "already-installed" : "installed",
+          version: status.version
+        });
+      } else {
+        const result = await this.installLsp(lsp);
+        results.push(result);
+      }
+    }
+    return {
+      results,
+      allSucceeded: results.every((r) => r.status !== "failed")
+    };
+  }
+  async getVersion(def) {
+    try {
+      const { stdout } = await execFileAsync(def.binaryName, [def.versionFlag], { timeout: 5000 });
+      return stdout.trim().split(`
+`)[0];
+    } catch {
+      return;
+    }
+  }
+  parseVersionFromNpmList(output, packageName) {
+    const match = output.match(new RegExp(`${packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}@([\\d.]+)`));
+    return match?.[1];
+  }
+  parseVersionFromPipShow(output) {
+    const match = output.match(/Version:\s*([\d.]+)/);
+    return match?.[1];
+  }
+  async installNpm(def) {
+    try {
+      await execFileAsync("npm", ["install", "-g", def.package], { timeout: 120000 });
+    } catch (error) {
+      throw new Error(`Failed to install ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async installPip(def) {
+    try {
+      await execFileAsync("pip", ["install", "--user", def.package], { timeout: 120000 });
+    } catch (error) {
+      throw new Error(`Failed to install ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async installBinary(def) {
+    if (!def.binaryPlatforms) {
+      throw new Error(`No binary platforms defined for ${def.serverName}`);
+    }
+    const platformKey = `${process.platform}-${process.arch}`;
+    const binary = def.binaryPlatforms[platformKey];
+    if (!binary) {
+      throw new Error(`No binary available for platform: ${platformKey}`);
+    }
+    await mkdir5(this.lspBinDir, { recursive: true });
+    const destPath = join4(this.lspBinDir, def.binaryName);
+    try {
+      await access5(destPath);
+      return;
+    } catch {}
+    const { execSync } = await import("node:child_process");
+    const isWindows = process.platform === "win32";
+    const extractCmd = binary.url.endsWith(".zip") ? `curl -L "${binary.url}" | tar -xz -C "${this.lspBinDir}"` : `curl -L "${binary.url}" | tar -xz -C "${this.lspBinDir}"`;
+    try {
+      execSync(extractCmd, { timeout: 120000, stdio: "pipe" });
+      if (!isWindows) {
+        execSync(`chmod +x "${destPath}"`, { stdio: "pipe" });
+      }
+    } catch (error) {
+      throw new Error(`Failed to download ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+function createLspInstaller() {
+  return new LspInstaller;
+}
+
+// src/core/lsp/lsp-registry.ts
+var LSP_DEFINITIONS = [
+  {
+    id: "typescript",
+    language: "typescript",
+    serverName: "TypeScript Language Server",
+    packageManager: "npm",
+    package: "typescript-language-server",
+    binaryName: "typescript-language-server",
+    installCmd: "npm install -g typescript-language-server",
+    versionFlag: "--version",
+    npmDetect: "typescript-language-server"
+  },
+  {
+    id: "php",
+    language: "php",
+    serverName: "Intelephense",
+    packageManager: "npm",
+    package: "@bmewburn/vscode-intelephense-client",
+    binaryName: "intelephense",
+    installCmd: "npm install -g @bmewburn/vscode-intelephense-client",
+    versionFlag: "--version",
+    npmDetect: "@bmewburn/vscode-intelephense-client"
+  },
+  {
+    id: "python",
+    language: "python",
+    serverName: "Python LSP Server",
+    packageManager: "pip",
+    package: "python-lsp-server",
+    binaryName: "pylsp",
+    installCmd: "pip install --user python-lsp-server",
+    versionFlag: "--version",
+    pipDetect: "python-lsp-server"
+  },
+  {
+    id: "kotlin",
+    language: "kotlin",
+    serverName: "Kotlin Language Server",
+    packageManager: "binary",
+    package: "kotlin-language-server",
+    binaryName: "kotlin-language-server",
+    installCmd: "Download from GitHub releases",
+    versionFlag: "--version",
+    binaryPlatforms: {
+      "linux-x64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-linux-x64.tar.gz"
+      },
+      "linux-arm64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-linux-arm64.tar.gz"
+      },
+      "darwin-x64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-macos-x64.tar.gz"
+      },
+      "darwin-arm64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-macos-arm64.tar.gz"
+      },
+      "win32-x64": {
+        url: "https://github.com/fwcd/kotlin-language-server/releases/latest/download/server-windows-x64.zip"
+      }
+    }
+  }
+];
+function resolveLsps(languages) {
+  const languageToLspId = {
+    typescript: "typescript",
+    javascript: "typescript",
+    php: "php",
+    python: "python",
+    java: "kotlin",
+    kotlin: "kotlin"
+  };
+  const resolvedIds = new Set;
+  for (const lang of languages) {
+    const lspId = languageToLspId[lang.toLowerCase()];
+    if (lspId) {
+      resolvedIds.add(lspId);
+    }
+  }
+  return LSP_DEFINITIONS.filter((def) => resolvedIds.has(def.id));
+}
+
+// src/commands/install-lsp.command.ts
+async function installLspCommand(options) {
+  const { target, lang, dryRun, force, global: isGlobal, output, projectRoot } = options;
+  const baseDir = isGlobal ? homedir4() : projectRoot;
+  try {
+    const runnerTarget = parseRunnerTarget(target);
+    const targets = getIndividualTargets(runnerTarget);
+    let languages;
+    if (lang && lang.length > 0) {
+      languages = lang;
+    } else {
+      const profile = await detectProject(projectRoot);
+      languages = profile.languages;
+    }
+    if (languages.length === 0) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "install",
+          subcommand: "lsp",
+          errors: ["No languages detected. Use --lang to specify languages manually."]
+        }
+      };
+    }
+    const lsps = resolveLsps(languages);
+    if (lsps.length === 0) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "install",
+          subcommand: "lsp",
+          errors: [`No LSP servers available for languages: ${languages.join(", ")}`]
+        }
+      };
+    }
+    const installer = createLspInstaller();
+    const installReport = await installer.installAll(lsps, { dryRun });
+    const writeOptions = { dryRun, force };
+    const allConfigResults = [];
+    for (const t of targets) {
+      const generator = getLspConfigGenerator(t);
+      if (!generator) {
+        continue;
+      }
+      const generatedFiles = generator.generate(installReport.results);
+      const resolvedFiles = generatedFiles.map((f) => ({
+        ...f,
+        path: resolve8(baseDir, f.path)
+      }));
+      const results = await writeGeneratedFiles(resolvedFiles, writeOptions);
+      for (const result of results) {
+        allConfigResults.push({
+          target: t,
+          path: result.path,
+          success: result.success,
+          error: result.error
+        });
+      }
+    }
+    const errors3 = allConfigResults.filter((r) => !r.success).map((r) => `${r.path}: ${r.error}`);
+    if (output === "json") {
+      return {
+        code: errors3.length > 0 ? 2 : 0,
+        data: {
+          success: errors3.length === 0,
+          command: "install",
+          subcommand: "lsp",
+          targets,
+          languages: [...languages],
+          global: isGlobal,
+          dryRun,
+          lspResults: installReport.results,
+          configResults: allConfigResults
+        }
+      };
+    }
+    console.log(`
+LSP Installation:`);
+    for (const result of installReport.results) {
+      const icon = result.status === "already-installed" ? "✓" : result.status === "installed" ? "+" : "✗";
+      const version = result.version ? ` (${result.version})` : "";
+      const error = result.error ? `: ${result.error}` : "";
+      console.log(`  ${icon} ${result.lspId}${version}${error}`);
+    }
+    console.log(`
+Config Files:`);
+    for (const result of allConfigResults) {
+      const icon = result.success ? "✓" : "✗";
+      const error = result.error ? `: ${result.error}` : "";
+      console.log(`  ${icon} ${result.target}: ${result.path}${error}`);
+    }
+    const note = dryRun ? " (dry-run)" : "";
+    console.log(`
+${installReport.results.length} LSPs processed, ${allConfigResults.length} config files${note}`);
+    return {
+      code: errors3.length > 0 ? 2 : 0,
+      data: {
+        success: errors3.length === 0,
+        command: "install",
+        subcommand: "lsp",
+        targets,
+        languages: [...languages],
+        global: isGlobal,
+        dryRun,
+        lspResults: installReport.results,
+        configResults: allConfigResults
+      }
+    };
+  } catch (error) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "install",
+        subcommand: "lsp",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+function getLspConfigGenerator(target) {
+  switch (target) {
+    case "opencode":
+      return createOpenCodeLspGenerator();
+    case "claude":
+      return createClaudeLspGenerator();
+    case "codex":
+      return createCodexLspGenerator();
+    case "gemini":
+      return createGeminiLspGenerator();
+    case "cursor":
+      return createCursorLspGenerator();
+    case "agy":
+      return createAgyLspGenerator();
+    default:
+      return;
+  }
+}
+
 // src/commands/update.command.ts
 async function updateCommand(options) {
   const { dryRun, force, output, projectRoot } = options;
@@ -12832,7 +13569,12 @@ function parseArgs(args) {
     const arg = remaining[i];
     if (arg.startsWith("--")) {
       const [key, value] = arg.slice(2).split("=");
-      if (value !== undefined) {
+      if (key === "lang") {
+        const langValue = value !== undefined ? value : remaining[++i];
+        if (langValue && typeof langValue === "string") {
+          options[key] = langValue.split(",").map((s) => s.trim());
+        }
+      } else if (value !== undefined) {
         options[key] = value;
       } else if (remaining[i + 1] && !remaining[i + 1].startsWith("-")) {
         options[key] = remaining[++i];
@@ -12856,6 +13598,7 @@ Commands:
   detect                 Detect project stack and recommended presets
   install council        Install generated council spec files to runner targets
   install preset         Install full preset (agents, prompts, skills, commands)
+  install lsp            Install and configure LSP servers for AI coding tools
   doctor                 Validate configuration and generated files
   update                 Update installed presets
 
@@ -12866,6 +13609,7 @@ Options:
   --force                Allow overwriting existing files
   --global               Install to home directory (~/.claude, ~/.opencode, etc.)
   --output, -o           Output mode: human or json
+  --lang                 Comma-separated list of languages (e.g., typescript,php,python)
 
 Examples:
   npx cc-codeconductor init
@@ -12880,6 +13624,9 @@ Examples:
   npx cc-codeconductor install council --target claude
   npx cc-codeconductor install council --target codex
   npx cc-codeconductor install council --target all
+  npx cc-codeconductor install lsp --target opencode
+  npx cc-codeconductor install lsp --target all --lang typescript,python
+  npx cc-codeconductor install lsp --target claude --dry-run
   npx cc-codeconductor doctor
   npx cc-codeconductor update --dry-run
 `;
@@ -12904,7 +13651,7 @@ async function routeCommand(args, projectRoot) {
       });
     case "install": {
       const isGlobal = options.global === true || options.global === "true";
-      const VALID_TARGETS = ["opencode", "claude", "codex", "all"];
+      const VALID_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "all"];
       let resolvedSubcommand = subcommand;
       let target = options.target;
       if (!target && subcommand && VALID_TARGETS.includes(subcommand)) {
@@ -12912,6 +13659,17 @@ async function routeCommand(args, projectRoot) {
         resolvedSubcommand = undefined;
       }
       target = target || "opencode";
+      if (resolvedSubcommand === "lsp") {
+        return installLspCommand({
+          projectRoot,
+          target,
+          lang: options.lang,
+          dryRun: flags.dryRun,
+          force: flags.force,
+          global: isGlobal,
+          output: flags.output
+        });
+      }
       if (resolvedSubcommand === "preset") {
         return installPresetCommand({
           projectRoot,