opencode-agenthub 0.1.0

package/dist/composer/defaults.js

@@ -0,0 +1,10 @@
+const DEFAULT_PROFILE_PLUGINS = [
+  "opencode-agenthub"
+];
+const getDefaultProfilePlugins = () => [
+  ...DEFAULT_PROFILE_PLUGINS
+];
+export {
+  DEFAULT_PROFILE_PLUGINS,
+  getDefaultProfilePlugins
+};

package/dist/composer/home-transfer.js

@@ -0,0 +1,288 @@
+import { cp, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultAgentHubHome, ensureAgentHubSkeleton } from "./bootstrap.js";
+import { installPackageDependencies } from "./package-manager.js";
+const libraryRootPlaceholder = "${LIBRARY_ROOT}";
+const repoRootPlaceholder = "${REPO_ROOT}";
+const repoSrcRootPlaceholder = "${REPO_SRC_ROOT}";
+const managedDirectories = [
+  "souls",
+  "instructions",
+  "skills",
+  "workflow",
+  "bundles",
+  "profiles",
+  "mcp",
+  "mcp-servers"
+];
+const exportManifestFileName = "agenthub-export.json";
+const settingsFileName = "settings.json";
+const installImportedMcpServerDependencies = async (targetRoot, report) => {
+  const targetMcpServersRoot = path.join(targetRoot, "mcp-servers");
+  if (!await pathExists(targetMcpServersRoot)) return;
+  const packageManifest = path.join(targetMcpServersRoot, "package.json");
+  if (!await pathExists(packageManifest)) return;
+  try {
+    await installPackageDependencies(targetMcpServersRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    report.warnings.push(`Failed to install MCP server dependencies: ${message}`);
+  }
+};
+const pathExists = async (target) => {
+  try {
+    await stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const ensureCleanDirectory = async (target) => {
+  await mkdir(target, { recursive: true });
+};
+const isAbsolutePathString = (value) => path.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value);
+const normalizeMcpValue = (value, sourceRoot, relativeFile, warnings) => {
+  if (typeof value === "string") {
+    let normalized = value;
+    if (normalized.includes(sourceRoot)) {
+      normalized = normalized.split(sourceRoot).join(libraryRootPlaceholder);
+    }
+    if (isAbsolutePathString(normalized) && !normalized.includes(libraryRootPlaceholder) && !normalized.includes(repoRootPlaceholder) && !normalized.includes(repoSrcRootPlaceholder)) {
+      warnings.push(
+        `MCP entry '${relativeFile}' contains an absolute path that may not be portable: ${value}`
+      );
+    }
+    return normalized;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => normalizeMcpValue(item, sourceRoot, relativeFile, warnings)
+    );
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [
+        key,
+        normalizeMcpValue(nested, sourceRoot, relativeFile, warnings)
+      ])
+    );
+  }
+  return value;
+};
+const copyManagedTree = async (sourceRoot, targetRoot, name) => {
+  const source = path.join(sourceRoot, name);
+  if (!await pathExists(source)) return false;
+  await cp(source, path.join(targetRoot, name), { recursive: true });
+  return true;
+};
+const writeNormalizedMcpEntries = async (sourceRoot, outputRoot, warnings) => {
+  const sourceMcpRoot = path.join(sourceRoot, "mcp");
+  if (!await pathExists(sourceMcpRoot)) return false;
+  const outputMcpRoot = path.join(outputRoot, "mcp");
+  await mkdir(outputMcpRoot, { recursive: true });
+  for (const entry of await readdir(sourceMcpRoot, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const sourceFile = path.join(sourceMcpRoot, entry.name);
+    const relativeFile = path.join("mcp", entry.name);
+    const parsed = JSON.parse(await readFile(sourceFile, "utf8"));
+    const normalized = normalizeMcpValue(parsed, sourceRoot, relativeFile, warnings);
+    await writeFile(
+      path.join(outputMcpRoot, entry.name),
+      `${JSON.stringify(normalized, null, 2)}
+`,
+      "utf8"
+    );
+  }
+  return true;
+};
+const detectContents = async (root) => {
+  const entries = await Promise.all([
+    ...managedDirectories.map((name) => pathExists(path.join(root, name))),
+    pathExists(path.join(root, settingsFileName))
+  ]);
+  return {
+    souls: entries[0],
+    instructions: entries[1],
+    skills: entries[2],
+    workflow: entries[3],
+    bundles: entries[4],
+    profiles: entries[5],
+    mcp: entries[6],
+    "mcp-servers": entries[7],
+    settings: entries[8]
+  };
+};
+const isRawImportSource = async (sourceRoot) => {
+  const contents = await detectContents(sourceRoot);
+  return contents.bundles && contents.profiles;
+};
+const detectImportSourceKind = async (sourceRoot) => {
+  if (await pathExists(path.join(sourceRoot, exportManifestFileName))) {
+    return "export";
+  }
+  if (await isRawImportSource(sourceRoot)) {
+    return "raw";
+  }
+  throw new Error(
+    `Import source '${sourceRoot}' is neither an export bundle nor a raw Agent Hub home/vault. Expected ${exportManifestFileName} or at least 'bundles/' and 'profiles/'.`
+  );
+};
+const readExportManifest = async (sourceRoot) => {
+  const manifestPath = path.join(sourceRoot, exportManifestFileName);
+  if (!await pathExists(manifestPath)) {
+    throw new Error(
+      `Export source '${sourceRoot}' is missing ${exportManifestFileName}. Run 'hub-export' first.`
+    );
+  }
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  if (manifest.formatVersion !== 1) {
+    throw new Error(
+      `Unsupported export format version '${String(manifest.formatVersion)}'.`
+    );
+  }
+  return manifest;
+};
+const validateAgentHubHome = async (targetRoot) => {
+  const contents = await detectContents(targetRoot);
+  return contents.souls && contents.skills && contents.bundles && contents.profiles;
+};
+const exportAgentHubHome = async ({
+  sourceRoot = defaultAgentHubHome(),
+  outputRoot,
+  pluginVersion = "0.0.0"
+}) => {
+  const resolvedSourceRoot = path.resolve(sourceRoot);
+  const resolvedOutputRoot = path.resolve(outputRoot);
+  if (!await validateAgentHubHome(resolvedSourceRoot)) {
+    throw new Error(
+      `Source '${resolvedSourceRoot}' is not an initialized Agent Hub home.`
+    );
+  }
+  await ensureCleanDirectory(resolvedOutputRoot);
+  const warnings = [];
+  const copied = [];
+  for (const name of managedDirectories) {
+    if (name === "mcp") continue;
+    if (await copyManagedTree(resolvedSourceRoot, resolvedOutputRoot, name)) {
+      copied.push(name);
+    }
+  }
+  if (await writeNormalizedMcpEntries(resolvedSourceRoot, resolvedOutputRoot, warnings)) {
+    copied.push("mcp");
+  }
+  const sourceSettings = path.join(resolvedSourceRoot, settingsFileName);
+  let settingsAction = "absent";
+  if (await pathExists(sourceSettings)) {
+    await writeFile(
+      path.join(resolvedOutputRoot, settingsFileName),
+      await readFile(sourceSettings, "utf8"),
+      "utf8"
+    );
+    copied.push(settingsFileName);
+    settingsAction = "copied";
+  }
+  const contents = await detectContents(resolvedOutputRoot);
+  const manifest = {
+    formatVersion: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pluginVersion,
+    sourceRoot: resolvedSourceRoot,
+    contents,
+    warnings
+  };
+  await writeFile(
+    path.join(resolvedOutputRoot, exportManifestFileName),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  return {
+    sourceRoot: resolvedSourceRoot,
+    targetRoot: resolvedOutputRoot,
+    copied,
+    skipped: [],
+    overwritten: [],
+    warnings,
+    settingsAction
+  };
+};
+const importDirectoryEntries = async (sourceRoot, targetRoot, overwrite, report) => {
+  for (const name of managedDirectories) {
+    const source = path.join(sourceRoot, name);
+    if (!await pathExists(source)) continue;
+    const target = path.join(targetRoot, name);
+    await mkdir(target, { recursive: true });
+    for (const entry of await readdir(source, { withFileTypes: true })) {
+      const sourceEntry = path.join(source, entry.name);
+      const targetEntry = path.join(target, entry.name);
+      if (await pathExists(targetEntry)) {
+        if (!overwrite) {
+          report.skipped.push(path.join(name, entry.name));
+          continue;
+        }
+        report.overwritten.push(path.join(name, entry.name));
+      } else {
+        report.copied.push(path.join(name, entry.name));
+      }
+      await cp(sourceEntry, targetEntry, { recursive: true, force: overwrite });
+    }
+  }
+};
+const importSettingsFile = async (sourceRoot, targetRoot, mode, report) => {
+  const source = path.join(sourceRoot, settingsFileName);
+  if (!await pathExists(source)) {
+    report.settingsAction = "absent";
+    return;
+  }
+  const target = path.join(targetRoot, settingsFileName);
+  if (await pathExists(target)) {
+    if (mode === "preserve") {
+      report.settingsAction = "preserved";
+      report.skipped.push(settingsFileName);
+      return;
+    }
+    report.settingsAction = "replaced";
+    report.overwritten.push(settingsFileName);
+  } else {
+    report.settingsAction = "copied";
+    report.copied.push(settingsFileName);
+  }
+  await writeFile(target, await readFile(source, "utf8"), "utf8");
+};
+const importAgentHubHome = async ({
+  sourceRoot,
+  targetRoot = defaultAgentHubHome(),
+  overwrite = false,
+  settingsMode = "preserve"
+}) => {
+  const resolvedSourceRoot = path.resolve(sourceRoot);
+  const resolvedTargetRoot = path.resolve(targetRoot);
+  const sourceKind = await detectImportSourceKind(resolvedSourceRoot);
+  await ensureAgentHubSkeleton(resolvedTargetRoot);
+  const report = {
+    sourceRoot: resolvedSourceRoot,
+    targetRoot: resolvedTargetRoot,
+    sourceKind,
+    copied: [],
+    skipped: [],
+    overwritten: [],
+    warnings: sourceKind === "export" ? [...(await readExportManifest(resolvedSourceRoot)).warnings] : [
+      "Importing from a raw Agent Hub home/vault. Files are copied as-is; no export manifest normalization was applied."
+    ],
+    settingsAction: "absent"
+  };
+  await importDirectoryEntries(resolvedSourceRoot, resolvedTargetRoot, overwrite, report);
+  await importSettingsFile(
+    resolvedSourceRoot,
+    resolvedTargetRoot,
+    settingsMode,
+    report
+  );
+  await installImportedMcpServerDependencies(resolvedTargetRoot, report);
+  return report;
+};
+export {
+  exportAgentHubHome,
+  importAgentHubHome,
+  validateAgentHubHome
+};

package/dist/composer/install-home.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { installAgentHubHome } from "./bootstrap.js";
+const targetRoot = await installAgentHubHome();
+process.stdout.write(`${targetRoot}
+`);

package/dist/composer/library/README.md

@@ -0,0 +1,93 @@
+# opencode-agenthub library
+
+This directory is the built-in library shipped with the package. When you run `agenthub setup auto`, the coding assets here are installed into your Agent Hub Home (`~/.config/opencode-agenthub/` by default).
+
+Examples below use the short CLI command `agenthub`. `opencode-agenthub` remains a compatibility alias.
+
+## Asset layers
+
+Core layers:
+
+- `souls/` — agent identity files (system prompts). One file per agent.
+- `bundles/` — bundle definitions (JSON). Each bundle maps one or more agents to a soul, skills, model, and tools.
+- `profiles/` — profile definitions (JSON). A profile selects which bundles to activate in a workspace.
+- `skills/` — skill directories. Each skill has a `SKILL.md` that opencode can load at runtime.
+
+Advanced / optional layers:
+
+- `instructions/` — shared instruction documents referenced by bundles.
+- `mcp/` — MCP server registration JSONs.
+- `mcp-servers/` — MCP server scripts referenced by `mcp/*.json`.
+
+`setup auto` keeps the initial home small. Optional directories such as `instructions/`, `mcp/`, and `mcp-servers/` are created when you actually use them.
+
+## Built-in profiles
+
+| Profile | Bundles included |
+|---|---|
+| `auto` | `auto`, `plan`, `build` |
+| `hr` | `hr`, `hr-sourcer`, `hr-evaluator`, `hr-cto`, `hr-adapter`, `hr-verifier`, `auto`, `plan`, `build` |
+
+## Asset model
+
+```
+agent = soul + bundle + skills + runtime + policy
+```
+
+- **soul** — system prompt / behavioral identity (`souls/<name>.md`)
+- **bundle** — agent definition: soul ref, model, skills, MCP, tool policy (`bundles/<name>.json`)
+- **profile** — workspace composition: which bundles + which plugin + default agent (`profiles/<name>.json`)
+- **skill** — injectable capability loaded on demand (`skills/<name>/SKILL.md`)
+
+## MCP servers
+
+To add a custom MCP server:
+
+1. Put the server implementation in `mcp-servers/my-tool.ts`
+2. Put the registration JSON in `mcp/my-tool.json`
+3. Reference the MCP name in a bundle's `mcp` array
+
+If you stage or export a team that depends on MCP tools, both directories matter:
+
+- `mcp/` contains the registration JSONs
+- `mcp-servers/` contains the runnable server implementations (and optionally `package.json` for dependencies)
+
+Shipping only `mcp/*.json` without the referenced `mcp-servers/` files is incomplete and will fail at runtime.
+
+Example `mcp/my-tool.json`:
+
+```json
+{
+  "type": "local",
+  "command": ["bun", "${LIBRARY_ROOT}/mcp-servers/my-tool.ts"],
+  "timeout": 30000
+}
+```
+
+Available path tokens inside MCP JSON values: `${LIBRARY_ROOT}`, `${REPO_SRC_ROOT}`, `${REPO_ROOT}`.
+
+## Hub Home resolution order
+
+1. `OPENCODE_AGENTHUB_HOME` environment variable
+2. `~/.config/opencode-agenthub`
+3. Built-in repo fallback under `src/composer/library`
+
+## Example commands
+
+```bash
+agenthub setup auto
+agenthub start
+agenthub hr
+agenthub hr recruiter-team
+agenthub new bundle my-bundle
+agenthub new profile my-profile
+agenthub backup --output ./agenthub-backup
+agenthub restore --source ./agenthub-backup --overwrite
+```
+
+## Restore / import behavior
+
+- Skips colliding files by default and reports them
+- `--overwrite` replaces colliding files
+- `--settings replace` replaces the target `settings.json` (default: `preserve`)
+- `hub-import` remains available for advanced import into a chosen target home

package/dist/composer/library/bundles/auto.json

@@ -0,0 +1,18 @@
+{
+  "name": "auto",
+  "runtime": "native",
+  "soul": "auto",
+  "skills": [],
+  "mcp": [],
+  "guards": ["no_omo"],
+  "agent": {
+    "name": "auto",
+    "mode": "primary",
+    "hidden": false,
+    "model": "github-copilot/claude-sonnet-4.5",
+    "description": "Default coding agent with OMO-style intent detection and native build/edit/test workflow",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/build.json

@@ -0,0 +1,17 @@
+{
+  "name": "build",
+  "runtime": "native",
+  "soul": "build",
+  "skills": [],
+  "mcp": [],
+  "agent": {
+    "name": "build",
+    "mode": "primary",
+    "hidden": false,
+    "model": "github-copilot/gpt-5",
+    "description": "Execution-focused coding agent with strong completion and verification discipline",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr-adapter.json

@@ -0,0 +1,26 @@
+{
+  "name": "hr-adapter",
+  "runtime": "native",
+  "soul": "hr-adapter",
+  "instructions": [
+    "hr-boundaries"
+  ],
+  "skills": [
+    "hr-assembly"
+  ],
+  "mcp": [],
+  "guards": [
+    "no_task",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr-adapter",
+    "mode": "subagent",
+    "hidden": true,
+    "model": "github-copilot/gpt-5",
+    "description": "Adapts approved candidates into staged Agent Hub packages without mutating the imported home.",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr-cto.json

@@ -0,0 +1,24 @@
+{
+  "name": "hr-cto",
+  "runtime": "native",
+  "soul": "hr-cto",
+  "instructions": [
+    "hr-boundaries"
+  ],
+  "skills": [],
+  "mcp": [],
+  "guards": [
+    "no_task",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr-cto",
+    "mode": "subagent",
+    "hidden": true,
+    "model": "github-copilot/gpt-5",
+    "description": "CTO-style architecture reviewer for staffing structure, role overlap, and downstream composition choices.",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr-evaluator.json

@@ -0,0 +1,26 @@
+{
+  "name": "hr-evaluator",
+  "runtime": "native",
+  "soul": "hr-evaluator",
+  "instructions": [
+    "hr-boundaries"
+  ],
+  "skills": [
+    "hr-review"
+  ],
+  "mcp": [],
+  "guards": [
+    "no_task",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr-evaluator",
+    "mode": "subagent",
+    "hidden": true,
+    "model": "github-copilot/claude-opus-4.6",
+    "description": "Reviews local inventory candidates for risk, compatibility, testing readiness, and description clarity.",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr-planner.json

@@ -0,0 +1,26 @@
+{
+  "name": "hr-planner",
+  "runtime": "native",
+  "soul": "hr-planner",
+  "instructions": [
+    "hr-boundaries"
+  ],
+  "skills": [
+    "hr-staffing"
+  ],
+  "mcp": [],
+  "guards": [
+    "no_task",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr-planner",
+    "mode": "subagent",
+    "hidden": true,
+    "model": "github-copilot/gpt-5",
+    "description": "Builds the staffing-plan deliverable after requirements are confirmed, including options, draft naming, and initial model recommendations.",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr-sourcer.json

@@ -0,0 +1,24 @@
+{
+  "name": "hr-sourcer",
+  "runtime": "native",
+  "soul": "hr-sourcer",
+  "instructions": [
+    "hr-boundaries"
+  ],
+  "skills": [],
+  "mcp": [],
+  "guards": [
+    "no_task",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr-sourcer",
+    "mode": "subagent",
+    "hidden": true,
+    "model": "github-copilot/gpt-5",
+    "description": "Scans configured GitHub repos, refreshes local inventory worker cards, and classifies discovered agents and skills.",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr-verifier.json

@@ -0,0 +1,26 @@
+{
+  "name": "hr-verifier",
+  "runtime": "native",
+  "soul": "hr-verifier",
+  "instructions": [
+    "hr-boundaries"
+  ],
+  "skills": [
+    "hr-final-check"
+  ],
+  "mcp": [],
+  "guards": [
+    "no_task",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr-verifier",
+    "mode": "subagent",
+    "hidden": true,
+    "model": "github-copilot/claude-sonnet-4.6",
+    "description": "Runs final package QA for clarity, safety, and import readiness before human confirmation.",
+    "permission": {
+      "*": "allow"
+    }
+  }
+}

package/dist/composer/library/bundles/hr.json

@@ -0,0 +1,35 @@
+{
+  "name": "hr",
+  "runtime": "native",
+  "soul": "hr",
+  "instructions": [
+    "hr-boundaries",
+    "hr-protocol"
+  ],
+  "skills": [],
+  "mcp": [],
+  "guards": [
+    "read_only",
+    "no_omo"
+  ],
+  "agent": {
+    "name": "hr",
+    "mode": "primary",
+    "hidden": false,
+    "steps": 3,
+    "model": "github-copilot/gpt-5",
+    "description": "Primary HR orchestration console that gathers requirements, keeps stage gates, dispatches hidden HR workers, and reports important decisions back to the user.",
+    "permission": {
+      "*": "allow",
+      "task": {
+        "*": "deny",
+        "hr-planner": "allow",
+        "hr-sourcer": "allow",
+        "hr-evaluator": "allow",
+        "hr-cto": "allow",
+        "hr-adapter": "allow",
+        "hr-verifier": "allow"
+      }
+    }
+  }
+}

package/dist/composer/library/bundles/plan.json

@@ -0,0 +1,19 @@
+{
+  "name": "plan",
+  "runtime": "native",
+  "soul": "plan",
+  "skills": [],
+  "mcp": [],
+  "agent": {
+    "name": "plan",
+    "mode": "primary",
+    "hidden": false,
+    "model": "github-copilot/claude-sonnet-4.5",
+    "description": "Read-only planning agent for repo-grounded implementation plans",
+    "permission": {
+      "*": "allow",
+      "edit": "ask",
+      "bash": "ask"
+    }
+  }
+}