@colin4k1024/tsp 2.4.5 → 2.4.6

package/scripts/install-codegraph.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+'use strict'
+
+const path = require('path')
+const { spawnSync } = require('child_process')
+
+const SUPPORTED_TARGETS = Object.freeze({
+  claude: 'claude',
+  codex: 'codex',
+  cursor: 'cursor',
+  opencode: 'opencode',
+})
+
+function normalizeTarget(value) {
+  return String(value || '').trim().toLowerCase()
+}
+
+function mapTarget(value) {
+  return SUPPORTED_TARGETS[normalizeTarget(value)] || null
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    target: process.env.TSP_INSTALL_TARGET || '',
+    dryRun: process.env.CODEGRAPH_INSTALL_DRY_RUN === '1',
+  }
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+    if (arg === '--target') {
+      parsed.target = argv[index + 1] || ''
+      index += 1
+      continue
+    }
+    if (arg.startsWith('--target=')) {
+      parsed.target = arg.slice('--target='.length)
+      continue
+    }
+    if (arg === '--dry-run') {
+      parsed.dryRun = true
+      continue
+    }
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true
+      continue
+    }
+    throw new Error(`Unknown argument: ${arg}`)
+  }
+
+  return parsed
+}
+
+function resolveCodeGraphBin() {
+  if (process.env.CODEGRAPH_INSTALL_BIN) {
+    return {
+      command: process.env.CODEGRAPH_INSTALL_BIN,
+      argsPrefix: [],
+      displayCommand: process.env.CODEGRAPH_INSTALL_BIN,
+    }
+  }
+
+  let packageJsonPath
+  try {
+    packageJsonPath = require.resolve('@colbymchenry/codegraph/package.json')
+  } catch (error) {
+    throw new Error(
+      'Unable to resolve @colbymchenry/codegraph. Run npm install before applying the CodeGraph integration.'
+    )
+  }
+
+  const binPath = path.join(path.dirname(packageJsonPath), 'dist', 'bin', 'codegraph.js')
+  return {
+    command: process.execPath,
+    argsPrefix: [binPath],
+    displayCommand: `${process.execPath} ${binPath}`,
+  }
+}
+
+function buildInstallCommand(target) {
+  const mappedTarget = mapTarget(target)
+  if (!mappedTarget) {
+    return {
+      supported: false,
+      target: normalizeTarget(target),
+      reason: `CodeGraph upstream installer does not support TSP target: ${target || '(missing)'}`,
+    }
+  }
+
+  const resolved = resolveCodeGraphBin()
+  const args = [
+    ...resolved.argsPrefix,
+    'install',
+    `--target=${mappedTarget}`,
+    '--location=global',
+    '--yes',
+  ]
+
+  return {
+    supported: true,
+    target: mappedTarget,
+    command: resolved.command,
+    args,
+    display: [resolved.displayCommand, ...args.slice(resolved.argsPrefix.length)].join(' '),
+  }
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/install-codegraph.js [--target <claude|codex|cursor|opencode>] [--dry-run]
+
+Runs the upstream CodeGraph installer for the current TSP install target only.
+The project index is not initialized here; run codegraph init -i inside a target project when needed.
+`)
+}
+
+function run(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv)
+  if (options.help) {
+    printHelp()
+    return 0
+  }
+
+  const install = buildInstallCommand(options.target)
+  if (!install.supported) {
+    console.error(`Skipping CodeGraph installer: ${install.reason}`)
+    return 0
+  }
+
+  if (options.dryRun) {
+    console.log(`CodeGraph install command: ${install.display}`)
+    return 0
+  }
+
+  console.error(`Running CodeGraph installer for ${install.target}`)
+  const result = spawnSync(install.command, install.args, {
+    cwd: process.cwd(),
+    env: process.env,
+    encoding: 'utf8',
+    stdio: ['inherit', process.stderr, process.stderr],
+  })
+
+  return typeof result.status === 'number' ? result.status : 1
+}
+
+if (require.main === module) {
+  try {
+    process.exit(run())
+  } catch (error) {
+    console.error(error.message || error)
+    process.exit(1)
+  }
+}
+
+module.exports = {
+  buildInstallCommand,
+  mapTarget,
+  parseArgs,
+  run,
+}

package/scripts/install-plan.js

@@ -137,6 +137,30 @@ function printComponents(components) {
   }
 }
 
+function resolvePlanExternalInstalls(plan) {
+  return plan.selectedModules
+    .map(module => ({ module, externalInstall: module.externalInstall }))
+    .filter(({ externalInstall }) => externalInstall && typeof externalInstall === 'object' && !Array.isArray(externalInstall))
+    .filter(({ externalInstall }) => {
+      const profiles = Array.isArray(externalInstall.profiles)
+        ? externalInstall.profiles.map(value => String(value).trim()).filter(Boolean)
+        : [];
+      return profiles.length === 0 || profiles.includes(plan.profileId);
+    })
+    .map(({ module, externalInstall }) => ({
+      id: externalInstall.id || module.id,
+      moduleId: module.id,
+      description: externalInstall.description || '',
+      command: externalInstall.command || 'node',
+      script: externalInstall.script || null,
+      args: Array.isArray(externalInstall.args)
+        ? externalInstall.args.map(value => String(value))
+        : [],
+      target: plan.target || null,
+      profileId: plan.profileId || null,
+    }));
+}
+
 function printPlan(plan) {
   console.log('Install plan:\n');
   console.log(
@@ -184,20 +208,12 @@ function printPlan(plan) {
     }
   }
 
-  const externalInstalls = plan.selectedModules
-    .map(module => ({ module, externalInstall: module.externalInstall }))
-    .filter(({ externalInstall }) => externalInstall && typeof externalInstall === 'object' && !Array.isArray(externalInstall))
-    .filter(({ externalInstall }) => {
-      const profiles = Array.isArray(externalInstall.profiles)
-        ? externalInstall.profiles.map(value => String(value).trim()).filter(Boolean)
-        : [];
-      return profiles.length === 0 || profiles.includes(plan.profileId);
-    });
+  const externalInstalls = resolvePlanExternalInstalls(plan);
   if (externalInstalls.length > 0) {
     console.log('');
     console.log(`External install plan (${externalInstalls.length}):`);
-    for (const { module, externalInstall } of externalInstalls) {
-      console.log(`- ${externalInstall.id || module.id}: ${externalInstall.description || externalInstall.script}`);
+    for (const externalInstall of externalInstalls) {
+      console.log(`- ${externalInstall.id}: ${externalInstall.description || externalInstall.script}`);
     }
   }
 }
@@ -268,6 +284,7 @@ function main() {
       excludeComponentIds: request.excludeComponentIds,
       target: request.target,
     });
+    plan.externalInstalls = resolvePlanExternalInstalls(plan);
 
     if (options.json) {
       console.log(JSON.stringify(plan, null, 2));

package/scripts/lib/install/apply.js

@@ -1,12 +1,16 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
 const { writeInstallState } = require('../install-state');
 const { writeInstallAuditManifest } = require('../install-audit-manifest');
 
+const PLUGIN_NAME = require('../team-skills-data.json').plugin.name;
+const OPENCODE_AGENTS_MD_MARKER = '<!-- team-skills-platform -->';
+
 function readJsonObject(filePath, label) {
   let parsed;
   try {
@@ -177,6 +181,16 @@ function buildMergedSettings(plan) {
   };
 }
 
+function buildExternalInstallEnv(externalInstall) {
+  return {
+    ...process.env,
+    ...(externalInstall.env || {}),
+    TSP_INSTALL_TARGET: externalInstall.target || '',
+    TSP_INSTALL_PROFILE: externalInstall.profileId || '',
+    TSP_INSTALL_MODULE_ID: externalInstall.moduleId || '',
+  };
+}
+
 function runExternalInstall(externalInstall) {
   const args = [];
   if (externalInstall.scriptPath) {
@@ -190,12 +204,18 @@ function runExternalInstall(externalInstall) {
 
   const command = externalInstall.command || 'node';
   const label = externalInstall.id || externalInstall.moduleId || command;
-  console.log(`Running external install: ${label}`);
+  if (process.env.TSP_SKIP_EXTERNAL_INSTALLS === '1') {
+    console.error(`Skipping external install: ${label}`);
+    return;
+  }
+
+  console.error(`Running external install: ${label}`);
 
   const result = spawnSync(command, args, {
     cwd: externalInstall.cwd || process.cwd(),
+    env: buildExternalInstallEnv(externalInstall),
     encoding: 'utf8',
-    stdio: 'inherit',
+    stdio: ['inherit', process.stderr, process.stderr],
   });
 
   if (result.status !== 0) {
@@ -203,6 +223,232 @@ function runExternalInstall(externalInstall) {
   }
 }
 
+function mergePluginMarketplace(sourceMarketplace, targetMarketplace) {
+  if (!fs.existsSync(sourceMarketplace)) {
+    return;
+  }
+
+  const source = readJsonObject(sourceMarketplace, 'source marketplace');
+  let target = {
+    name: source.name || 'marketplace',
+    interface: source.interface || {},
+    plugins: [],
+  };
+
+  if (fs.existsSync(targetMarketplace)) {
+    target = readJsonObject(targetMarketplace, 'target marketplace');
+    if (!Array.isArray(target.plugins)) {
+      target.plugins = [];
+    }
+  }
+
+  const targetPlugins = target.plugins || [];
+  const nextPluginsByName = new Map();
+  for (const plugin of targetPlugins) {
+    if (plugin && typeof plugin.name === 'string') {
+      nextPluginsByName.set(plugin.name, plugin);
+    }
+  }
+  for (const plugin of source.plugins || []) {
+    if (plugin && typeof plugin.name === 'string') {
+      nextPluginsByName.set(plugin.name, plugin);
+    }
+  }
+
+  target.plugins = [...nextPluginsByName.values()];
+  fs.mkdirSync(path.dirname(targetMarketplace), { recursive: true });
+  fs.writeFileSync(targetMarketplace, JSON.stringify(target, null, 2) + '\n', 'utf8');
+}
+
+function registerCodexPlugin(plan) {
+  const configPath = path.join(plan.targetRoot, 'config.toml');
+  const marker = `[plugins."${PLUGIN_NAME}"]`;
+  const content = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+  if (!content.includes(marker)) {
+    const entry = `\n${marker}\nenabled = true\n`;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `${content.replace(/\n+$/, '')}${entry}`, 'utf8');
+  }
+
+  const homeDir = path.basename(plan.targetRoot) === '.codex'
+    ? path.dirname(plan.targetRoot)
+    : (process.env.HOME || os.homedir());
+  const agentsHome = process.env.AGENTS_HOME_DIR || path.join(homeDir, '.agents');
+  mergePluginMarketplace(
+    path.join(plan.targetRoot, 'plugins', PLUGIN_NAME, '.agents', 'plugins', 'marketplace.json'),
+    path.join(agentsHome, 'plugins', 'marketplace.json')
+  );
+}
+
+function buildOpenCodeAgentsMd(pluginRoot) {
+  const agentsDir = path.join(pluginRoot, 'agents', 'roles');
+  const roleNames = fs.existsSync(agentsDir)
+    ? fs
+      .readdirSync(agentsDir)
+      .filter((name) => name.endsWith('.md'))
+      .map((name) => path.parse(name).name)
+      .sort()
+    : [];
+  const roleDisplay = {
+    'tech-lead': 'Tech Lead（技术负责人）',
+    'product-manager': 'Product Manager（产品经理）',
+    'project-manager': 'Project Manager（项目管理）',
+    architect: 'Architect（架构师）',
+    'frontend-engineer': 'Frontend Engineer（前端开发）',
+    'backend-engineer': 'Backend Engineer（后端开发）',
+    'qa-engineer': 'QA Engineer（测试工程师）',
+    'devops-engineer': 'DevOps Engineer（运维工程师）',
+  };
+  const lines = [
+    OPENCODE_AGENTS_MD_MARKER,
+    '# Team Skills Platform — OpenCode Agent Index',
+    '',
+    '本文件由安装脚本自动生成。在 OpenCode 中与任何角色交互时，可直接引用下列角色和命令。',
+    '',
+    '## 可用角色',
+    '',
+  ];
+  for (const role of roleNames) {
+    lines.push(`- **${roleDisplay[role] || role}**: \`plugins/${PLUGIN_NAME}/agents/roles/${role}.md\``);
+  }
+  lines.push(
+    '',
+    '## 核心团队命令',
+    '',
+    '| 命令 | 用途 |',
+    '|------|------|',
+    '| `/team-help` | 根据当前阶段、artifacts 与阻塞项推荐下一步主链命令 |',
+    '| `/team-intake` | 接收需求并锁定目标、范围、约束 |',
+    '| `/team-plan` | 拆解任务、角色分工、依赖与里程碑 |',
+    '| `/team-execute` | 驱动研发角色在边界内实施 |',
+    '| `/team-review` | 做方案、质量、测试和放行评审 |',
+    '| `/team-release` | 做发布准备、上线检查与回滚保障 |',
+    '| `/team-closeout` | 在观察窗口结束后做最终收口与 backlog 回写 |',
+    '| `/handoff` | 在角色间做结构化交接 |',
+    '',
+    '## 插件根路径',
+    '',
+    '`~/.config/opencode/plugins/team-skills-platform/`',
+    '',
+    `<!-- end ${PLUGIN_NAME} -->`
+  );
+  return `${lines.join('\n')}\n`;
+}
+
+function mergeOpenCodeAgentsMd(targetPath, newContent) {
+  const markerEnd = `<!-- end ${PLUGIN_NAME} -->`;
+  if (!fs.existsSync(targetPath)) {
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, newContent, 'utf8');
+    return;
+  }
+  const existing = fs.readFileSync(targetPath, 'utf8');
+  if (existing.includes(OPENCODE_AGENTS_MD_MARKER)) {
+    const startIdx = existing.indexOf(OPENCODE_AGENTS_MD_MARKER);
+    let endIdx = existing.indexOf(markerEnd, startIdx);
+    if (endIdx !== -1) {
+      endIdx += markerEnd.length;
+      if (existing[endIdx] === '\n') {
+        endIdx += 1;
+      }
+      fs.writeFileSync(targetPath, `${existing.slice(0, startIdx)}${newContent}`, 'utf8');
+      return;
+    }
+  }
+  const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+  fs.writeFileSync(targetPath, `${existing}${separator}${newContent}`, 'utf8');
+}
+
+function mergeOpenCodeAgentsIndex(plan) {
+  const pluginRoot = path.join(plan.targetRoot, 'plugins', PLUGIN_NAME);
+  mergeOpenCodeAgentsMd(
+    path.join(plan.targetRoot, 'AGENTS.md'),
+    buildOpenCodeAgentsMd(pluginRoot)
+  );
+}
+
+function applyTargetPostInstall(plan) {
+  if (plan.adapter && plan.adapter.target === 'codex') {
+    registerCodexPlugin(plan);
+  }
+  if (plan.adapter && plan.adapter.target === 'opencode') {
+    mergeOpenCodeAgentsIndex(plan);
+  }
+}
+
+function replaceOperationByDestination(operations, replacement) {
+  let replaced = false;
+  const nextOperations = operations.map((operation) => {
+    if (operation.destinationPath !== replacement.destinationPath) {
+      return { ...operation };
+    }
+    replaced = true;
+    return {
+      ...operation,
+      ...replacement,
+    };
+  });
+
+  if (!replaced) {
+    nextOperations.push(replacement);
+  }
+
+  return nextOperations;
+}
+
+function appendOperationIfMissing(operations, operation) {
+  if (operations.some((item) => item.destinationPath === operation.destinationPath)) {
+    return operations.map((item) => ({ ...item }));
+  }
+  return [...operations.map((item) => ({ ...item })), operation];
+}
+
+function buildPlanWithRuntimeManagedOperations(plan, mergedSettingsPlan) {
+  if (!mergedSettingsPlan) {
+    return plan;
+  }
+
+  const renderedHooksConfig = JSON.stringify(mergedSettingsPlan.resolvedHooksConfig, null, 2) + '\n';
+  const hooksOperation = {
+    kind: 'render-template',
+    moduleId: 'hooks-runtime',
+    sourceRelativePath: path.join('hooks', 'hooks.json'),
+    destinationPath: mergedSettingsPlan.hooksDestinationPath,
+    strategy: 'rendered-hooks-config',
+    ownership: 'managed',
+    scaffoldOnly: false,
+    renderedContent: renderedHooksConfig,
+  };
+  const settingsOperation = {
+    kind: 'merge-json',
+    moduleId: 'hooks-runtime',
+    sourceRelativePath: 'settings.json',
+    destinationPath: mergedSettingsPlan.settingsPath,
+    strategy: 'merge-claude-settings',
+    ownership: 'managed',
+    scaffoldOnly: false,
+    payload: {
+      hooks: mergedSettingsPlan.mergedSettings.hooks || {},
+    },
+  };
+
+  const rewriteOperations = (operations = []) => appendOperationIfMissing(
+    replaceOperationByDestination(operations, hooksOperation),
+    settingsOperation
+  );
+
+  return {
+    ...plan,
+    operations: rewriteOperations(plan.operations),
+    statePreview: plan.statePreview
+      ? {
+        ...plan.statePreview,
+        operations: rewriteOperations(plan.statePreview.operations),
+      }
+      : plan.statePreview,
+  };
+}
+
 function applyInstallPlan(plan) {
   const mergedSettingsPlan = buildMergedSettings(plan);
 
@@ -230,11 +476,14 @@ function applyInstallPlan(plan) {
     runExternalInstall(externalInstall);
   }
 
-  writeInstallState(plan.installStatePath, plan.statePreview);
-  const { installManifestPath } = writeInstallAuditManifest(plan);
+  applyTargetPostInstall(plan);
+
+  const statefulPlan = buildPlanWithRuntimeManagedOperations(plan, mergedSettingsPlan);
+  writeInstallState(statefulPlan.installStatePath, statefulPlan.statePreview);
+  const { installManifestPath } = writeInstallAuditManifest(statefulPlan);
 
   return {
-    ...plan,
+    ...statefulPlan,
     applied: true,
     installManifestPath,
   };
@@ -242,4 +491,6 @@ function applyInstallPlan(plan) {
 
 module.exports = {
   applyInstallPlan,
+  buildExternalInstallEnv,
+  runExternalInstall,
 };

package/scripts/lib/install/request.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const { validateInstallModuleIds } = require('../install-manifests');
+const { normalizeInstallTarget } = require('../install-targets/registry');
 
-const LEGACY_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity'];
+const LEGACY_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity', 'codex', 'opencode'];
 
 function dedupeStrings(values) {
   return [...new Set((Array.isArray(values) ? values : []).map(value => String(value).trim()).filter(Boolean))];
@@ -104,7 +105,7 @@ function normalizeInstallRequest(options = {}) {
     ...(Array.isArray(options.legacyLanguages) ? options.legacyLanguages : []),
     ...(Array.isArray(options.languages) ? options.languages : []),
   ]).map(language => language.toLowerCase()));
-  const target = options.target || config?.target || 'claude';
+  const target = normalizeInstallTarget(options.target || config?.target || 'claude');
   const hasManifestBaseSelection = Boolean(profileId) || moduleIds.length > 0 || includeComponentIds.length > 0;
   const usingManifestMode = hasManifestBaseSelection || excludeComponentIds.length > 0;
 

package/scripts/lib/install-audit-manifest.js

@@ -40,6 +40,9 @@ function normalizeOperations(operations) {
     if (operation.ownership && operation.ownership !== 'managed') {
       return false;
     }
+    if (operation.kind === 'merge-json') {
+      return false;
+    }
     return typeof operation.destinationPath === 'string' && operation.destinationPath.length > 0;
   });
 }

package/scripts/lib/install-executor.js

@@ -10,7 +10,7 @@ const {
   resolveLegacyCompatibilitySelection,
   resolveInstallPlan,
 } = require('./install-manifests');
-const { getInstallTargetAdapter } = require('./install-targets/registry');
+const { getInstallTargetAdapter, normalizeInstallTarget } = require('./install-targets/registry');
 
 const LANGUAGE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const EXCLUDED_GENERATED_SOURCE_SUFFIXES = [
@@ -85,7 +85,8 @@ function listAvailableLanguages(sourceRoot = getSourceRoot()) {
 }
 
 function validateLegacyTarget(target) {
-  if (!LEGACY_INSTALL_TARGETS.includes(target)) {
+  const normalizedTarget = normalizeInstallTarget(target);
+  if (!LEGACY_INSTALL_TARGETS.includes(normalizedTarget)) {
     throw new Error(
       `Unknown install target: ${target}. Expected one of ${LEGACY_INSTALL_TARGETS.join(', ')}`
     );
@@ -502,10 +503,18 @@ function createLegacyInstallPlan(options = {}) {
   const sourceRoot = options.sourceRoot || getSourceRoot();
   const projectRoot = options.projectRoot || process.cwd();
   const homeDir = options.homeDir || process.env.HOME || os.homedir();
-  const target = options.target || 'claude';
+  const target = normalizeInstallTarget(options.target || 'claude');
 
   validateLegacyTarget(target);
 
+  if (target === 'codex' || target === 'opencode') {
+    return createLegacyCompatInstallPlan({
+      ...options,
+      target,
+      legacyLanguages: options.languages || options.legacyLanguages || [],
+    });
+  }
+
   const context = {
     sourceRoot,
     projectRoot,
@@ -568,7 +577,7 @@ function createLegacyInstallPlan(options = {}) {
 function createLegacyCompatInstallPlan(options = {}) {
   const sourceRoot = options.sourceRoot || getSourceRoot();
   const projectRoot = options.projectRoot || process.cwd();
-  const target = options.target || 'claude';
+  const target = normalizeInstallTarget(options.target || 'claude');
 
   validateLegacyTarget(target);
 
@@ -637,7 +646,7 @@ function materializeScaffoldOperation(sourceRoot, operation) {
 function createManifestInstallPlan(options = {}) {
   const sourceRoot = options.sourceRoot || getSourceRoot();
   const projectRoot = options.projectRoot || process.cwd();
-  const target = options.target || 'claude';
+  const target = normalizeInstallTarget(options.target || 'claude');
   const legacyLanguages = Array.isArray(options.legacyLanguages)
     ? [...options.legacyLanguages]
     : [];

package/scripts/lib/install-lifecycle.js

@@ -14,7 +14,7 @@ const {
 } = require('./install-executor');
 const {
   getInstallTargetAdapter,
-  listInstallTargetAdapters,
+  listPublicInstallTargetAdapters,
 } = require('./install-targets/registry');
 
 const DEFAULT_REPO_ROOT = path.join(__dirname, '../..');
@@ -30,7 +30,7 @@ function readPackageVersion(repoRoot) {
 
 function normalizeTargets(targets) {
   if (!Array.isArray(targets) || targets.length === 0) {
-    return listInstallTargetAdapters().map(adapter => adapter.target);
+    return listPublicInstallTargetAdapters().map(adapter => adapter.target);
   }
 
   const normalizedTargets = [];

package/scripts/lib/install-manifests.js

@@ -1,7 +1,11 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { getInstallTargetAdapter, planInstallTargetScaffold } = require('./install-targets/registry');
+const {
+  getInstallTargetAdapter,
+  normalizeInstallTarget,
+  planInstallTargetScaffold,
+} = require('./install-targets/registry');
 
 const DEFAULT_REPO_ROOT = path.join(__dirname, '../..');
 const SUPPORTED_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity', 'codex', 'gemini', 'opencode', 'codebuddy', 'copilot', 'windsurf', 'augment'];
@@ -35,6 +39,21 @@ const LEGACY_COMPAT_BASE_MODULE_IDS_BY_TARGET = Object.freeze({
     'agents-core',
     'commands-core',
   ],
+  codex: [
+    'rules-core',
+    'agents-core',
+    'commands-core',
+    'platform-configs',
+    'workflow-quality',
+  ],
+  opencode: [
+    'rules-core',
+    'agents-core',
+    'commands-core',
+    'hooks-runtime',
+    'platform-configs',
+    'workflow-quality',
+  ],
 });
 const LEGACY_LANGUAGE_ALIAS_TO_CANONICAL = Object.freeze({
   cpp: 'cpp',
@@ -334,7 +353,7 @@ function validateInstallModuleIds(moduleIds, options = {}) {
 function listInstallComponents(options = {}) {
   const manifests = loadInstallManifests(options);
   const family = options.family || null;
-  const target = options.target || null;
+  const target = options.target ? normalizeInstallTarget(options.target) : null;
 
   if (family && !Object.hasOwn(COMPONENT_FAMILY_PREFIXES, family)) {
     throw new Error(
@@ -424,7 +443,7 @@ function expandComponentIdsToModuleIds(componentIds, manifests) {
 
 function resolveLegacyCompatibilitySelection(options = {}) {
   const manifests = loadInstallManifests(options);
-  const target = options.target || null;
+  const target = options.target ? normalizeInstallTarget(options.target) : null;
 
   if (target && !SUPPORTED_INSTALL_TARGETS.includes(target)) {
     throw new Error(
@@ -508,7 +527,7 @@ function resolveInstallPlan(options = {}) {
     }
   }
 
-  const target = options.target || null;
+  const target = options.target ? normalizeInstallTarget(options.target) : null;
   if (target && !SUPPORTED_INSTALL_TARGETS.includes(target)) {
     throw new Error(
       `Unknown install target: ${target}. Expected one of ${SUPPORTED_INSTALL_TARGETS.join(', ')}`