opencode-agenthub 0.1.0

package/dist/composer/bootstrap.js

@@ -0,0 +1,493 @@
+import { chmod, cp, mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { installPackageDependencies } from "./package-manager.js";
+import {
+  buildBuiltinVersionManifest,
+  getManagedCodingHrHubAssetSpecs
+} from "./builtin-assets.js";
+import { readPackageVersion } from "./package-version.js";
+import { resolveHomeConfigRoot, shouldChmod } from "./platform.js";
+import {
+  buildInitialAgentHubSettings,
+  resolveHrBootstrapAgentModels,
+  mergeAgentHubSettingsDefaults,
+  readAgentHubSettings,
+  writeAgentHubSettings
+} from "./settings.js";
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const libraryRoot = path.join(currentDir, "library");
+const sourceRoot = path.dirname(currentDir);
+const defaultHrGithubSources = [
+  "garrytan/gstack",
+  "anthropics/skills",
+  "msitarzewski/agency-agents",
+  "obra/superpowers"
+];
+const syncManagedAssetSpecs = async (specs, version, options = {}) => {
+  const added = [];
+  const updated = [];
+  const skipped = [];
+  const manifest = {};
+  for (const spec of specs) {
+    const exists = await pathExists(spec.target);
+    manifest[spec.manifestKey] = version;
+    if (exists && !options.force) {
+      skipped.push(spec.manifestKey);
+      continue;
+    }
+    if (!options.dryRun) {
+      await mkdir(path.dirname(spec.target), { recursive: true });
+      await cp(spec.source, spec.target, {
+        recursive: Boolean(spec.recursive),
+        force: true
+      });
+      if (spec.executable && shouldChmod()) {
+        await chmod(spec.target, 493);
+      }
+    }
+    (exists ? updated : added).push(spec.manifestKey);
+  }
+  return { added, updated, skipped, manifest };
+};
+const mergeBuiltinManifest = (existing, next) => ({
+  ...existing || {},
+  ...next
+});
+const pruneBuiltinManifest = (existing, allowedKeys) => {
+  if (!existing) return void 0;
+  const allowed = new Set(allowedKeys);
+  const pruned = Object.fromEntries(
+    Object.entries(existing).filter(([key]) => allowed.has(key))
+  );
+  return Object.keys(pruned).length > 0 ? pruned : void 0;
+};
+const withBuiltinManifest = (settings, manifest) => ({
+  ...settings,
+  meta: {
+    ...settings.meta,
+    builtinVersion: mergeBuiltinManifest(settings.meta?.builtinVersion, manifest)
+  }
+});
+const withBuiltinManifestForMode = (settings, manifest, mode) => ({
+  ...settings,
+  meta: {
+    ...settings.meta,
+    builtinVersion: mergeBuiltinManifest(
+      pruneBuiltinManifest(
+        settings.meta?.builtinVersion,
+        Object.keys(buildBuiltinVersionManifest(mode, readPackageVersion()))
+      ),
+      manifest
+    )
+  }
+});
+const installCodingStarter = async (targetRoot, version) => syncManagedAssetSpecs(
+  getManagedCodingHrHubAssetSpecs(targetRoot, "auto"),
+  version
+);
+const installHrOfficeStarter = async (targetRoot, version) => syncManagedAssetSpecs(
+  getManagedCodingHrHubAssetSpecs(targetRoot, "hr-office"),
+  version
+);
+const installHrHelperScripts = async (hrRoot) => {
+  const scriptsRoot = path.join(sourceRoot, "skills", "hr-support", "bin");
+  const targetBinRoot = path.join(hrRoot, "bin");
+  await mkdir(targetBinRoot, { recursive: true });
+  for (const scriptName of [
+    "sync_sources.py",
+    "vendor_stage_skills.py",
+    "validate_staged_package.py"
+  ]) {
+    const source = path.join(scriptsRoot, scriptName);
+    const target = path.join(targetBinRoot, scriptName);
+    if (!await pathExists(target)) {
+      await cp(source, target, { force: true });
+      if (shouldChmod()) {
+        await chmod(target, 493);
+      }
+    }
+  }
+};
+const defaultAgentHubHome = () => process.env.OPENCODE_AGENTHUB_HOME || resolveHomeConfigRoot(os.homedir(), "opencode-agenthub");
+const defaultHrHome = () => process.env.OPENCODE_AGENTHUB_HR_HOME || resolveHomeConfigRoot(os.homedir(), "opencode-agenthub-hr");
+const pathExists = async (target) => {
+  try {
+    await stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const ensureAgentHubSkeleton = async (targetRoot) => {
+  await mkdir(targetRoot, { recursive: true });
+  await mkdir(path.join(targetRoot, "souls"), { recursive: true });
+  await mkdir(path.join(targetRoot, "skills"), { recursive: true });
+  await mkdir(path.join(targetRoot, "bundles"), { recursive: true });
+  await mkdir(path.join(targetRoot, "profiles"), { recursive: true });
+};
+const ensureHrHomeSkeleton = async (hrRoot) => {
+  await mkdir(hrRoot, { recursive: true });
+  await mkdir(path.join(hrRoot, "bin"), { recursive: true });
+  await mkdir(path.join(hrRoot, "inventory", "workers"), { recursive: true });
+  await mkdir(path.join(hrRoot, "inventory", "models"), { recursive: true });
+  await mkdir(path.join(hrRoot, "sources", "github"), { recursive: true });
+  await mkdir(path.join(hrRoot, "staging"), { recursive: true });
+  await mkdir(path.join(hrRoot, "output"), { recursive: true });
+  await mkdir(path.join(hrRoot, "logs"), { recursive: true });
+  await mkdir(path.join(hrRoot, "state", "staffing-plans"), { recursive: true });
+  await mkdir(path.join(hrRoot, "state", "architecture-reviews"), { recursive: true });
+  const configPath = path.join(hrRoot, "hr-config.json");
+  if (!await pathExists(configPath)) {
+    const defaultConfig = {
+      schema_version: "1.1",
+      sources: {
+        github: defaultHrGithubSources,
+        models: [
+          {
+            source_id: "models-dev",
+            url: "https://models.dev/api.json",
+            format: "models.dev"
+          }
+        ]
+      },
+      settings: {
+        auto_sync: false,
+        sync_depth: 1
+      }
+    };
+    await writeFile(configPath, `${JSON.stringify(defaultConfig, null, 2)}
+`, "utf-8");
+  }
+  await installHrHelperScripts(hrRoot);
+};
+const ensureHrOfficeSkeleton = async (hrRoot) => {
+  await ensureHrHomeSkeleton(hrRoot);
+  await ensureAgentHubSkeleton(hrRoot);
+};
+const hrHomeInitialized = async (hrRoot = defaultHrHome()) => {
+  const [libraryOk, configOk, profileOk, bundleOk, settingsOk] = await Promise.all([
+    agentHubHomeInitialized(hrRoot),
+    pathExists(path.join(hrRoot, "hr-config.json")),
+    pathExists(path.join(hrRoot, "profiles", "hr.json")),
+    pathExists(path.join(hrRoot, "bundles", "hr.json")),
+    pathExists(path.join(hrRoot, "settings.json"))
+  ]);
+  return libraryOk && configOk && profileOk && bundleOk && settingsOk;
+};
+const installHrOfficeHome = async (hrRoot = defaultHrHome()) => {
+  return installHrOfficeHomeWithOptions({ hrRoot });
+};
+const installHrOfficeHomeWithOptions = async ({
+  hrRoot = defaultHrHome(),
+  hrModelSelection
+}) => {
+  const packageVersion = readPackageVersion();
+  await ensureHrOfficeSkeleton(hrRoot);
+  await copyLibraryReadme(hrRoot);
+  await installHrOfficeStarter(hrRoot, packageVersion);
+  const resolvedHrModels = await resolveHrBootstrapAgentModels({
+    targetRoot: hrRoot,
+    selection: hrModelSelection
+  });
+  const existingSettings = await readAgentHubSettings(hrRoot);
+  if (!existingSettings) {
+    const initialSettings = await buildInitialAgentHubSettings({
+      targetRoot: hrRoot,
+      mode: "hr-office",
+      hrResolvedModels: resolvedHrModels
+    });
+    await writeAgentHubSettings(
+      hrRoot,
+      initialSettings
+    );
+  } else {
+    const mergedSettings = mergeAgentHubSettingsDefaults(existingSettings);
+    const builtinVersion = buildBuiltinVersionManifest("hr-office", packageVersion);
+    mergedSettings.agents = mergedSettings.agents || {};
+    for (const [agentName, modelSelection] of Object.entries(resolvedHrModels.agentModels)) {
+      const existingAgentSettings = mergedSettings.agents[agentName] || {};
+      if (!existingAgentSettings.model || !existingAgentSettings.variant) {
+        mergedSettings.agents[agentName] = {
+          ...existingAgentSettings,
+          ...existingAgentSettings.model ? {} : { model: modelSelection.model },
+          ...existingAgentSettings.variant || !modelSelection.variant ? {} : { variant: modelSelection.variant }
+        };
+      }
+    }
+    mergedSettings.meta = {
+      ...mergedSettings.meta,
+      onboarding: {
+        ...mergedSettings.meta?.onboarding,
+        modelStrategy: mergedSettings.meta?.onboarding?.modelStrategy || resolvedHrModels.strategy
+      }
+    };
+    await writeAgentHubSettings(
+      hrRoot,
+      withBuiltinManifestForMode(mergedSettings, builtinVersion, "hr-office")
+    );
+  }
+  return hrRoot;
+};
+const copyLibraryReadme = async (targetRoot) => {
+  const source = path.join(libraryRoot, "README.md");
+  const target = path.join(targetRoot, "README.md");
+  if (await pathExists(target)) return;
+  await cp(source, target);
+};
+const copySkillsFrom = async (sourceRoot2, targetRoot) => {
+  const targetSkillsRoot = path.join(targetRoot, "skills");
+  await mkdir(targetSkillsRoot, { recursive: true });
+  for (const entry of await readdir(sourceRoot2, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const source = path.join(sourceRoot2, entry.name);
+    const target = path.join(targetSkillsRoot, entry.name);
+    if (await pathExists(target)) continue;
+    await cp(source, target, { recursive: true });
+  }
+};
+const copySoulsFrom = async (sourceRoot2, targetRoot) => {
+  const targetSoulsRoot = path.join(targetRoot, "souls");
+  await mkdir(targetSoulsRoot, { recursive: true });
+  for (const entry of await readdir(sourceRoot2, { withFileTypes: true })) {
+    if (!entry.isFile() || path.extname(entry.name) !== ".md") continue;
+    const source = path.join(sourceRoot2, entry.name);
+    const target = path.join(targetSoulsRoot, entry.name);
+    if (await pathExists(target)) continue;
+    await cp(source, target);
+  }
+};
+const copyInstructionsFrom = async (sourceRoot2, targetRoot) => {
+  const targetInstructionsRoot = path.join(targetRoot, "instructions");
+  await mkdir(targetInstructionsRoot, { recursive: true });
+  for (const entry of await readdir(sourceRoot2, { withFileTypes: true })) {
+    if (!entry.isFile() || path.extname(entry.name) !== ".md") continue;
+    const source = path.join(sourceRoot2, entry.name);
+    const target = path.join(targetInstructionsRoot, entry.name);
+    if (await pathExists(target)) continue;
+    await cp(source, target);
+  }
+};
+const supportedMcpServerExtensions = /* @__PURE__ */ new Set([".ts", ".js", ".mjs", ".cjs"]);
+const mcpServerPackageManifest = "package.json";
+const copyMcpServersFrom = async (sourceRoot2, targetRoot) => {
+  const targetMcpServersRoot = path.join(targetRoot, "mcp-servers");
+  await mkdir(targetMcpServersRoot, { recursive: true });
+  const importedServers = [];
+  const sourcePackageManifest = path.join(sourceRoot2, mcpServerPackageManifest);
+  const targetPackageManifest = path.join(
+    targetMcpServersRoot,
+    mcpServerPackageManifest
+  );
+  if (await pathExists(sourcePackageManifest)) {
+    await cp(sourcePackageManifest, targetPackageManifest, { force: true });
+  }
+  for (const entry of await readdir(sourceRoot2, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    const extension = path.extname(entry.name);
+    if (!supportedMcpServerExtensions.has(extension)) continue;
+    const source = path.join(sourceRoot2, entry.name);
+    const target = path.join(targetMcpServersRoot, entry.name);
+    if (!await pathExists(target)) {
+      await cp(source, target);
+    }
+    importedServers.push({
+      name: path.basename(entry.name, extension),
+      fileName: entry.name
+    });
+  }
+  return importedServers;
+};
+const registerImportedMcpServers = async (servers, targetRoot) => {
+  const targetMcpRoot = path.join(targetRoot, "mcp");
+  await mkdir(targetMcpRoot, { recursive: true });
+  for (const server of servers) {
+    const target = path.join(targetMcpRoot, `${server.name}.json`);
+    if (await pathExists(target)) continue;
+    const extension = path.extname(server.fileName);
+    const scriptPath = `${"$"}{LIBRARY_ROOT}/mcp-servers/${server.fileName}`;
+    const payload = {
+      type: "local",
+      command: extension === ".ts" ? [
+        "node",
+        "--import",
+        `${"$"}{LIBRARY_ROOT}/mcp-servers/node_modules/tsx/dist/loader.mjs`,
+        scriptPath
+      ] : ["node", scriptPath],
+      timeout: 3e4
+    };
+    await writeFile(target, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+  }
+};
+const installMcpServerDependencies = async (targetRoot) => {
+  const targetMcpServersRoot = path.join(targetRoot, "mcp-servers");
+  const packageManifest = path.join(
+    targetMcpServersRoot,
+    mcpServerPackageManifest
+  );
+  if (!await pathExists(packageManifest)) return;
+  await installPackageDependencies(targetMcpServersRoot);
+};
+const installAgentHubHome = async ({
+  targetRoot = defaultAgentHubHome(),
+  importSoulsPath,
+  importInstructionsPath,
+  importSkillsPath,
+  importMcpServersPath,
+  mode = "auto"
+} = {}) => {
+  let importedServers = [];
+  const packageVersion = readPackageVersion();
+  await ensureAgentHubSkeleton(targetRoot);
+  await copyLibraryReadme(targetRoot);
+  if (mode === "auto") {
+    await installCodingStarter(targetRoot, packageVersion);
+  }
+  if (importSoulsPath) {
+    await copySoulsFrom(importSoulsPath, targetRoot);
+  }
+  if (importInstructionsPath) {
+    await copyInstructionsFrom(importInstructionsPath, targetRoot);
+  }
+  if (importSkillsPath) {
+    await copySkillsFrom(importSkillsPath, targetRoot);
+  }
+  if (importMcpServersPath) {
+    importedServers = await copyMcpServersFrom(
+      importMcpServersPath,
+      targetRoot
+    );
+    await registerImportedMcpServers(importedServers, targetRoot);
+    await installMcpServerDependencies(targetRoot);
+  }
+  const existingSettings = await readAgentHubSettings(targetRoot);
+  if (!existingSettings) {
+    await writeAgentHubSettings(
+      targetRoot,
+      await buildInitialAgentHubSettings({ targetRoot, mode })
+    );
+  } else {
+    const mergedSettings = mergeAgentHubSettingsDefaults(existingSettings);
+    const builtinVersion = buildBuiltinVersionManifest(mode, packageVersion);
+    await writeAgentHubSettings(
+      targetRoot,
+      withBuiltinManifestForMode(mergedSettings, builtinVersion, mode)
+    );
+  }
+  return targetRoot;
+};
+const syncBuiltInAgentHubAssets = async ({
+  targetRoot = defaultAgentHubHome(),
+  mode = "auto",
+  force = false,
+  dryRun = false
+}) => {
+  if (!dryRun) {
+    await ensureAgentHubSkeleton(targetRoot);
+  }
+  const report = await syncManagedAssetSpecs(
+    getManagedCodingHrHubAssetSpecs(targetRoot, mode),
+    readPackageVersion(),
+    { force, dryRun }
+  );
+  if (!dryRun) {
+    const existingSettings = await readAgentHubSettings(targetRoot);
+    if (existingSettings) {
+      await writeAgentHubSettings(targetRoot, withBuiltinManifestForMode(existingSettings, report.manifest, mode));
+    }
+  }
+  return report;
+};
+const agentHubHomeInitialized = async (targetRoot = defaultAgentHubHome()) => {
+  const [soulsOk, skillsOk, bundlesOk, profilesOk] = await Promise.all([
+    pathExists(path.join(targetRoot, "souls")),
+    pathExists(path.join(targetRoot, "skills")),
+    pathExists(path.join(targetRoot, "bundles")),
+    pathExists(path.join(targetRoot, "profiles"))
+  ]);
+  return soulsOk && skillsOk && bundlesOk && profilesOk;
+};
+const normalizeOptionalPath = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return path.resolve(trimmed);
+};
+const promptSetupMode = async (rl) => {
+  while (true) {
+    process.stdout.write("\nSetup options:\n");
+    process.stdout.write("  auto  - Full setup with built-in Auto + Plan + Build\n");
+    process.stdout.write("  minimal - Structure only\n\n");
+    const modeAnswer = await rl.question(
+      "Setup [auto/minimal] (recommended: auto): "
+    );
+    const normalizedMode = modeAnswer.trim().toLowerCase();
+    if (!normalizedMode) return "auto";
+    if (normalizedMode === "minimal" || normalizedMode === "auto") {
+      return normalizedMode;
+    }
+    process.stdout.write(
+      "Invalid setup choice. Type 'auto', 'minimal', or press Enter for the recommended default.\n"
+    );
+  }
+};
+const promptHubInitAnswers = async () => {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const suggestedRoot = defaultAgentHubHome();
+    const locationAnswer = await rl.question(
+      `Agent Hub home location [${suggestedRoot}]: `
+    );
+    const targetRoot = normalizeOptionalPath(locationAnswer) || suggestedRoot;
+    const mode = await promptSetupMode(rl);
+    let importSoulsPath;
+    let importInstructionsPath;
+    let importSkillsPath;
+    let importMcpServersPath;
+    if (mode === "minimal") {
+      const importSoulsAnswer = await rl.question(
+        "Existing soul/agent prompt folder to import (leave blank to skip): "
+      );
+      importSoulsPath = normalizeOptionalPath(importSoulsAnswer);
+      const importInstructionsAnswer = await rl.question(
+        "Existing instructions folder to import (leave blank to skip): "
+      );
+      importInstructionsPath = normalizeOptionalPath(importInstructionsAnswer);
+      const importAnswer = await rl.question(
+        "Existing skills folder to import (leave blank to skip): "
+      );
+      importSkillsPath = normalizeOptionalPath(importAnswer);
+      const importMcpAnswer = await rl.question(
+        "Existing MCP server folder to import (leave blank to skip): "
+      );
+      importMcpServersPath = normalizeOptionalPath(importMcpAnswer);
+    }
+    return {
+      targetRoot,
+      importSoulsPath,
+      importInstructionsPath,
+      importSkillsPath,
+      importMcpServersPath,
+      mode
+    };
+  } finally {
+    rl.close();
+  }
+};
+export {
+  agentHubHomeInitialized,
+  defaultAgentHubHome,
+  defaultHrHome,
+  ensureAgentHubSkeleton,
+  ensureHrHomeSkeleton,
+  ensureHrOfficeSkeleton,
+  hrHomeInitialized,
+  installAgentHubHome,
+  installHrOfficeHome,
+  installHrOfficeHomeWithOptions,
+  promptHubInitAnswers,
+  syncBuiltInAgentHubAssets
+};

package/dist/composer/builtin-assets.js

@@ -0,0 +1,139 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const builtInLibraryRoot = path.join(currentDir, "library");
+const builtInSkillsRoot = path.resolve(currentDir, "..", "skills");
+const hrSupportBinRoot = path.join(builtInSkillsRoot, "hr-support", "bin");
+const codingLibraryFiles = [
+  "bundles/auto.json",
+  "bundles/plan.json",
+  "bundles/build.json",
+  "profiles/auto.json",
+  "souls/auto.md",
+  "souls/plan.md",
+  "souls/build.md"
+];
+const hrLibraryFiles = [
+  "bundles/hr.json",
+  "bundles/hr-planner.json",
+  "bundles/hr-sourcer.json",
+  "bundles/hr-evaluator.json",
+  "bundles/hr-cto.json",
+  "bundles/hr-adapter.json",
+  "bundles/hr-verifier.json",
+  "instructions/hr-boundaries.md",
+  "instructions/hr-protocol.md",
+  "profiles/hr.json",
+  "souls/hr.md",
+  "souls/hr-planner.md",
+  "souls/hr-sourcer.md",
+  "souls/hr-evaluator.md",
+  "souls/hr-cto.md",
+  "souls/hr-adapter.md",
+  "souls/hr-verifier.md"
+];
+const hrSkillDirectories = [
+  "hr-staffing",
+  "hr-review",
+  "hr-assembly",
+  "hr-final-check"
+];
+const hrHelperScripts = [
+  "sync_sources.py",
+  "vendor_stage_skills.py",
+  "vendor_stage_mcps.py",
+  "validate_staged_package.py"
+];
+const listNamesByExtension = async (root, extension) => {
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    return new Set(
+      entries.filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => entry.name.slice(0, -extension.length))
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+};
+const listDirectoryNames = async (root) => {
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    return new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+};
+const listBuiltInAssetNames = async (kind) => {
+  if (kind === "bundle") {
+    return listNamesByExtension(path.join(builtInLibraryRoot, "bundles"), ".json");
+  }
+  if (kind === "profile") {
+    return listNamesByExtension(path.join(builtInLibraryRoot, "profiles"), ".json");
+  }
+  if (kind === "soul") {
+    return listNamesByExtension(path.join(builtInLibraryRoot, "souls"), ".md");
+  }
+  if (kind === "instruction") {
+    return listNamesByExtension(path.join(builtInLibraryRoot, "instructions"), ".md");
+  }
+  return listDirectoryNames(builtInSkillsRoot);
+};
+const manifestScopeForMode = (mode) => {
+  if (mode === "auto") {
+    return codingLibraryFiles;
+  }
+  if (mode === "hr-office") {
+    return [
+      ...hrLibraryFiles,
+      ...hrSkillDirectories.map((name) => `skills/${name}`),
+      ...hrHelperScripts.map((name) => `hr-home/bin/${name}`)
+    ];
+  }
+  return [];
+};
+const getBuiltInManifestKeysForMode = (mode) => manifestScopeForMode(mode);
+const buildBuiltinVersionManifest = (mode, version) => Object.fromEntries(
+  getBuiltInManifestKeysForMode(mode).map((manifestKey) => [manifestKey, version])
+);
+const getManagedHubAssetSpecs = (targetRoot, mode) => {
+  const manifestKeys = manifestScopeForMode(mode).filter(
+    (key) => !key.startsWith("hr-home/") && !key.startsWith("skills/")
+  );
+  return manifestKeys.map((manifestKey) => ({
+    manifestKey,
+    source: path.join(builtInLibraryRoot, ...manifestKey.split("/")),
+    target: path.join(targetRoot, ...manifestKey.split("/")),
+    recursive: false
+  }));
+};
+const getManagedCodingHrHubAssetSpecs = (targetRoot, mode) => {
+  const specs = getManagedHubAssetSpecs(targetRoot, mode);
+  if (mode !== "hr-office") return specs;
+  return [
+    ...specs,
+    ...hrSkillDirectories.map((name) => ({
+      manifestKey: `skills/${name}`,
+      source: path.join(builtInSkillsRoot, name),
+      target: path.join(targetRoot, "skills", name),
+      recursive: true
+    }))
+  ];
+};
+const getManagedHrHomeAssetSpecs = (hrRoot, mode) => {
+  if (mode !== "hr-office") return [];
+  return hrHelperScripts.map((name) => ({
+    manifestKey: `hr-home/bin/${name}`,
+    source: path.join(hrSupportBinRoot, name),
+    target: path.join(hrRoot, "bin", name),
+    recursive: false,
+    executable: true
+  }));
+};
+export {
+  buildBuiltinVersionManifest,
+  getBuiltInManifestKeysForMode,
+  getManagedCodingHrHubAssetSpecs,
+  getManagedHrHomeAssetSpecs,
+  getManagedHubAssetSpecs,
+  listBuiltInAssetNames
+};

package/dist/composer/capabilities.js

@@ -0,0 +1,20 @@
+const PROFILE_ADD_CAPABILITY_REGISTRY = {
+  "hr-suite": [
+    "hr",
+    "hr-planner",
+    "hr-sourcer",
+    "hr-evaluator",
+    "hr-cto",
+    "hr-adapter",
+    "hr-verifier"
+  ]
+};
+const expandProfileAddSelections = (selections) => selections.flatMap(
+  (selection) => PROFILE_ADD_CAPABILITY_REGISTRY[selection] ?? [selection]
+);
+const listProfileAddCapabilityNames = () => Object.keys(PROFILE_ADD_CAPABILITY_REGISTRY).sort();
+export {
+  PROFILE_ADD_CAPABILITY_REGISTRY,
+  expandProfileAddSelections,
+  listProfileAddCapabilityNames
+};