opencode-agenthub 0.1.0

package/dist/skills/agenthub-doctor/diagnose.js

@@ -0,0 +1,213 @@
+import { readdir, readFile, access } from "node:fs/promises";
+import path from "node:path";
+import { readAgentHubSettings } from "../../composer/settings.js";
+const readJson = async (filePath) => {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+};
+const pathExists = async (p) => {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const REQUIRED_GUARDS = ["read_only", "no_task", "no_omo"];
+async function runDiagnostics(targetRoot) {
+  const report = {
+    healthy: [],
+    issues: [],
+    metadata: {
+      targetRoot,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  const settingsPath = path.join(targetRoot, "settings.json");
+  if (!await pathExists(settingsPath)) {
+    report.issues.push({
+      type: "invalid_settings",
+      severity: "error",
+      message: "settings.json not found",
+      details: { path: settingsPath }
+    });
+    return report;
+  }
+  report.healthy.push("Settings file exists");
+  const settings = await readAgentHubSettings(targetRoot);
+  if (!settings) {
+    report.issues.push({
+      type: "invalid_settings",
+      severity: "error",
+      message: "Failed to read settings.json"
+    });
+    return report;
+  }
+  const missingGuards = await diagnoseMissingGuards(settings);
+  if (missingGuards.length > 0) {
+    report.issues.push({
+      type: "missing_guards",
+      severity: "warning",
+      message: `Missing guards: ${missingGuards.join(", ")}`,
+      details: { guards: missingGuards }
+    });
+  } else {
+    report.healthy.push("All required guards present");
+  }
+  const orphanedSouls = await diagnoseOrphanedSouls(targetRoot);
+  if (orphanedSouls.length > 0) {
+    report.issues.push({
+      type: "orphaned_souls",
+      severity: "warning",
+      message: `${orphanedSouls.length} souls not referenced by any bundle`,
+      details: { souls: orphanedSouls }
+    });
+  } else {
+    report.healthy.push("All souls have bundles");
+  }
+  const orphanedSkills = await diagnoseOrphanedSkills(targetRoot);
+  if (orphanedSkills.length > 0) {
+    report.issues.push({
+      type: "orphaned_skills",
+      severity: "info",
+      message: `${orphanedSkills.length} skills not referenced by any bundle`,
+      details: { skills: orphanedSkills }
+    });
+  }
+  const profilesExist = await diagnoseProfiles(targetRoot);
+  if (!profilesExist) {
+    report.issues.push({
+      type: "no_profiles",
+      severity: "error",
+      message: "No profiles found - cannot run agents"
+    });
+  } else {
+    report.healthy.push("Profiles exist");
+  }
+  const bundlesExist = await diagnoseBundles(targetRoot);
+  if (!bundlesExist) {
+    report.issues.push({
+      type: "no_bundles",
+      severity: "error",
+      message: "No bundles found - cannot compose agents"
+    });
+  } else {
+    report.healthy.push("Bundles exist");
+  }
+  const omoIssue = await diagnoseOmoMixedProfile(targetRoot);
+  if (omoIssue) {
+    report.issues.push(omoIssue);
+  }
+  return report;
+}
+async function diagnoseMissingGuards(settings) {
+  if (!settings) return REQUIRED_GUARDS;
+  const existingGuards = Object.keys(settings.guards || {});
+  return REQUIRED_GUARDS.filter((guard) => !existingGuards.includes(guard));
+}
+async function diagnoseOrphanedSouls(targetRoot) {
+  const soulsDir = path.join(targetRoot, "souls");
+  if (!await pathExists(soulsDir)) return [];
+  const entries = await readdir(soulsDir, { withFileTypes: true });
+  const soulNames = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name.replace(/\.md$/, ""));
+  const bundlesDir = path.join(targetRoot, "bundles");
+  if (!await pathExists(bundlesDir)) return soulNames;
+  const bundleEntries = await readdir(bundlesDir, { withFileTypes: true });
+  const referencedSouls = /* @__PURE__ */ new Set();
+  for (const entry of bundleEntries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    try {
+      const bundlePath = path.join(bundlesDir, entry.name);
+      const bundle = await readJson(bundlePath);
+      if (bundle.soul) {
+        referencedSouls.add(bundle.soul);
+      }
+    } catch {
+    }
+  }
+  return soulNames.filter((soul) => !referencedSouls.has(soul));
+}
+async function diagnoseOrphanedSkills(targetRoot) {
+  const skillsDir = path.join(targetRoot, "skills");
+  if (!await pathExists(skillsDir)) return [];
+  const entries = await readdir(skillsDir, { withFileTypes: true });
+  const skillNames = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const bundlesDir = path.join(targetRoot, "bundles");
+  if (!await pathExists(bundlesDir)) return skillNames;
+  const bundleEntries = await readdir(bundlesDir, { withFileTypes: true });
+  const referencedSkills = /* @__PURE__ */ new Set();
+  for (const entry of bundleEntries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    try {
+      const bundlePath = path.join(bundlesDir, entry.name);
+      const bundle = await readJson(bundlePath);
+      if (bundle.skills) {
+        for (const skill of bundle.skills) {
+          referencedSkills.add(skill);
+        }
+      }
+    } catch {
+    }
+  }
+  return skillNames.filter((skill) => !referencedSkills.has(skill));
+}
+async function diagnoseProfiles(targetRoot) {
+  const profilesDir = path.join(targetRoot, "profiles");
+  if (!await pathExists(profilesDir)) return false;
+  const entries = await readdir(profilesDir, { withFileTypes: true });
+  return entries.some((entry) => entry.isFile() && entry.name.endsWith(".json"));
+}
+async function diagnoseBundles(targetRoot) {
+  const bundlesDir = path.join(targetRoot, "bundles");
+  if (!await pathExists(bundlesDir)) return false;
+  const entries = await readdir(bundlesDir, { withFileTypes: true });
+  return entries.some((entry) => entry.isFile() && entry.name.endsWith(".json"));
+}
+async function diagnoseOmoMixedProfile(targetRoot) {
+  const profilesDir = path.join(targetRoot, "profiles");
+  if (!await pathExists(profilesDir)) return null;
+  const profileEntries = await readdir(profilesDir, { withFileTypes: true });
+  const profileFiles = profileEntries.filter(
+    (e) => e.isFile() && e.name.endsWith(".json")
+  );
+  for (const profileEntry of profileFiles) {
+    const profilePath = path.join(profilesDir, profileEntry.name);
+    try {
+      const profile = await readJson(profilePath);
+      if (!profile.bundles || profile.bundles.length === 0) continue;
+      const bundlesDir = path.join(targetRoot, "bundles");
+      const omoBundles = [];
+      const nativeWithoutOmoGuard = [];
+      for (const bundleName of profile.bundles) {
+        const bundlePath = path.join(bundlesDir, `${bundleName}.json`);
+        if (!await pathExists(bundlePath)) continue;
+        const bundle = await readJson(bundlePath);
+        const runtime = bundle.runtime || "native";
+        if (runtime === "omo") {
+          omoBundles.push(bundleName);
+        } else if (runtime === "native") {
+          if (!bundle.guards?.includes("no_omo")) {
+            nativeWithoutOmoGuard.push(bundleName);
+          }
+        }
+      }
+      if (omoBundles.length > 0 && nativeWithoutOmoGuard.length > 0) {
+        return {
+          type: "omo_mixed_profile",
+          severity: "warning",
+          message: `Profile '${profileEntry.name.replace(".json", "")}' has OMO bundles but native agents lack no_omo guard`,
+          details: {
+            profile: profileEntry.name.replace(".json", ""),
+            omoBundles,
+            nativeWithoutOmoGuard
+          }
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+export {
+  runDiagnostics
+};

package/dist/skills/agenthub-doctor/fix.js

@@ -0,0 +1,293 @@
+import path from "node:path";
+import { readdir, readFile, writeFile, access } from "node:fs/promises";
+import { getDefaultProfilePlugins } from "../../composer/defaults.js";
+import { readAgentHubSettings, writeAgentHubSettings } from "../../composer/settings.js";
+const readJson = async (filePath) => {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+};
+const writeJson = async (filePath, data) => {
+  await writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+};
+const pathExists = async (p) => {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const DEFAULT_GUARDS = {
+  read_only: {
+    description: "Read-only access - no file modifications",
+    permission: {
+      edit: "deny",
+      write: "deny",
+      bash: "deny"
+    }
+  },
+  no_subagent: {
+    description: "Legacy alias for no_task",
+    blockedTools: ["task"],
+    permission: {
+      task: { "*": "deny" }
+    }
+  },
+  no_task: {
+    description: "Block task tool",
+    blockedTools: ["task"],
+    permission: {
+      task: { "*": "deny" }
+    }
+  },
+  no_omo: {
+    description: "Block OMO (Oh-My-OpenCode) multi-agent calls - for native agents in OMO profiles",
+    blockedTools: ["call_omo_agent"],
+    permission: {
+      call_omo_agent: "deny"
+    }
+  }
+};
+async function fixMissingGuards(targetRoot, guardsToAdd) {
+  try {
+    const settings = await readAgentHubSettings(targetRoot);
+    if (!settings) {
+      return {
+        success: false,
+        message: "settings.json not found or invalid"
+      };
+    }
+    if (!settings.guards) {
+      settings.guards = {};
+    }
+    let addedCount = 0;
+    for (const guardName of guardsToAdd) {
+      if (!settings.guards[guardName] && DEFAULT_GUARDS[guardName]) {
+        settings.guards[guardName] = DEFAULT_GUARDS[guardName];
+        addedCount++;
+      }
+    }
+    await writeAgentHubSettings(targetRoot, settings);
+    return {
+      success: true,
+      message: `Added ${addedCount} guard(s) to settings.json`,
+      details: { guards: guardsToAdd }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to fix guards: ${error.message}`
+    };
+  }
+}
+const readBundleAgentReferences = async (targetRoot, bundleNames) => Promise.all(
+  bundleNames.map(async (bundleName) => {
+    const bundlePath = path.join(targetRoot, "bundles", `${bundleName}.json`);
+    if (!await pathExists(bundlePath)) {
+      throw new Error(`Bundle '${bundleName}' not found in ${path.join(targetRoot, "bundles")}.`);
+    }
+    const bundle = await readJson(bundlePath);
+    const agentName = bundle.agent?.name?.trim();
+    if (!agentName) {
+      throw new Error(`Bundle '${bundleName}' is missing required agent.name.`);
+    }
+    return { bundleName, agentName };
+  })
+);
+async function resolveDefaultAgentForBundles(targetRoot, bundleNames, requestedDefaultAgent) {
+  const references = await readBundleAgentReferences(targetRoot, bundleNames);
+  const explicitDefaultAgent = requestedDefaultAgent?.trim();
+  if (explicitDefaultAgent) {
+    const bundleMatch = references.find(
+      (reference) => reference.bundleName === explicitDefaultAgent
+    );
+    if (bundleMatch && bundleMatch.agentName !== explicitDefaultAgent) {
+      throw new Error(
+        `Default agent '${explicitDefaultAgent}' matches bundle name, but profile defaultAgent must use bundle agent.name '${bundleMatch.agentName}'.`
+      );
+    }
+    if (references.some((reference) => reference.agentName === explicitDefaultAgent)) {
+      return explicitDefaultAgent;
+    }
+    return explicitDefaultAgent;
+  }
+  return references[0].agentName;
+}
+async function createBundleForSoul(targetRoot, soulName, options = {}) {
+  try {
+    const bundlesDir = path.join(targetRoot, "bundles");
+    const bundlePath = path.join(bundlesDir, `${soulName}.json`);
+    if (await pathExists(bundlePath)) {
+      return {
+        success: false,
+        message: `Bundle '${soulName}' already exists`
+      };
+    }
+    const bundle = {
+      name: soulName,
+      runtime: "native",
+      soul: soulName,
+      skills: options.skills || [],
+      mcp: options.mcp || [],
+      agent: {
+        name: options.agentName ?? soulName,
+        mode: options.mode ?? "primary",
+        model: options.model || "github-copilot/claude-sonnet-4.5",
+        description: "Auto-generated bundle for imported soul"
+      }
+    };
+    if (options.guards && options.guards.length > 0) {
+      bundle.guards = options.guards;
+    }
+    await writeJson(bundlePath, bundle);
+    return {
+      success: true,
+      message: `Created bundle '${soulName}'`,
+      details: { path: bundlePath }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to create bundle for '${soulName}': ${error.message}`
+    };
+  }
+}
+async function createBundlesForSouls(targetRoot, soulNames, options = {}) {
+  const results = [];
+  for (const soulName of soulNames) {
+    const result = await createBundleForSoul(targetRoot, soulName, options);
+    results.push(result);
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failureCount = results.length - successCount;
+  return {
+    success: successCount > 0,
+    message: `Created ${successCount} bundle(s)${failureCount > 0 ? `, ${failureCount} failed` : ""}`,
+    details: { results }
+  };
+}
+async function createProfile(targetRoot, profileName, options = {}) {
+  try {
+    const profilesDir = path.join(targetRoot, "profiles");
+    const profilePath = path.join(profilesDir, `${profileName}.json`);
+    if (await pathExists(profilePath)) {
+      return {
+        success: false,
+        message: `Profile '${profileName}' already exists`
+      };
+    }
+    let bundleNames = options.bundleNames;
+    if (!bundleNames) {
+      bundleNames = await getAllBundleNames(targetRoot);
+    }
+    if (bundleNames.length === 0) {
+      return {
+        success: false,
+        message: "No bundles found to include in profile"
+      };
+    }
+    const defaultAgent = await resolveDefaultAgentForBundles(
+      targetRoot,
+      bundleNames,
+      options.defaultAgent
+    );
+    const profile = {
+      name: profileName,
+      description: options.description || "Auto-generated profile for imported assets",
+      bundles: bundleNames,
+      defaultAgent,
+      plugins: getDefaultProfilePlugins()
+    };
+    await writeJson(profilePath, profile);
+    return {
+      success: true,
+      message: `Created profile '${profileName}' with ${bundleNames.length} bundle(s)`,
+      details: { path: profilePath, bundles: bundleNames }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to create profile '${profileName}': ${error.message}`
+    };
+  }
+}
+async function getAllBundleNames(targetRoot) {
+  const bundlesDir = path.join(targetRoot, "bundles");
+  if (!await pathExists(bundlesDir)) return [];
+  const entries = await readdir(bundlesDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.replace(/\.json$/, ""));
+}
+async function validateAndFix(targetRoot, options = {}) {
+  const results = [];
+  if (options.fixGuards) {
+    const guardsResult = await fixMissingGuards(targetRoot, [
+      "read_only",
+      "no_task",
+      "no_omo"
+    ]);
+    results.push(guardsResult);
+  }
+  if (options.createBundles) {
+    const { runDiagnostics } = await import("./diagnose.js");
+    const report = await runDiagnostics(targetRoot);
+    const orphanedSoulsIssue = report.issues.find((i) => i.type === "orphaned_souls");
+    if (orphanedSoulsIssue && orphanedSoulsIssue.details) {
+      const souls = orphanedSoulsIssue.details.souls;
+      if (souls.length > 0) {
+        const bundlesResult = await createBundlesForSouls(targetRoot, souls, {
+          model: options.model
+        });
+        results.push(bundlesResult);
+      }
+    }
+  }
+  if (options.createProfile) {
+    const profileResult = await createProfile(
+      targetRoot,
+      options.profileName || "imported"
+    );
+    results.push(profileResult);
+  }
+  return results;
+}
+async function fixOmoMixedProfile(targetRoot, details) {
+  try {
+    const bundlesDir = path.join(targetRoot, "bundles");
+    const fixed = [];
+    for (const bundleName of details.nativeWithoutOmoGuard) {
+      const bundlePath = path.join(bundlesDir, `${bundleName}.json`);
+      if (!await pathExists(bundlePath)) continue;
+      const bundle = await readJson(bundlePath);
+      if (!bundle.guards?.includes("no_omo")) {
+        bundle.guards = [...bundle.guards || [], "no_omo"];
+        await writeJson(bundlePath, bundle);
+        fixed.push(bundleName);
+      }
+    }
+    if (fixed.length === 0) {
+      return {
+        success: true,
+        message: "All native agents already have no_omo guard"
+      };
+    }
+    return {
+      success: true,
+      message: `Added no_omo guard to ${fixed.length} native agent(s): ${fixed.join(", ")}`,
+      details: { fixed }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to fix OMO mixed profile: ${error.message}`
+    };
+  }
+}
+export {
+  createBundleForSoul,
+  createBundlesForSouls,
+  createProfile,
+  fixMissingGuards,
+  fixOmoMixedProfile,
+  resolveDefaultAgentForBundles,
+  validateAndFix
+};

package/dist/skills/agenthub-doctor/index.js

@@ -0,0 +1,30 @@
+import { runDiagnostics } from "./diagnose.js";
+import {
+  fixMissingGuards,
+  createBundleForSoul,
+  createBundlesForSouls,
+  createProfile,
+  validateAndFix,
+  fixOmoMixedProfile
+} from "./fix.js";
+import {
+  interactiveAssembly,
+  interactiveDoctor,
+  updateAgentModelOverride,
+  updateAgentPromptOverride
+} from "./interactive.js";
+import { getAvailableBundles } from "./interactive.js";
+export {
+  createBundleForSoul,
+  createBundlesForSouls,
+  createProfile,
+  fixMissingGuards,
+  fixOmoMixedProfile,
+  getAvailableBundles,
+  interactiveAssembly,
+  interactiveDoctor,
+  runDiagnostics,
+  updateAgentModelOverride,
+  updateAgentPromptOverride,
+  validateAndFix
+};