opencode-agenthub 0.1.0

package/dist/plugins/plan-guidance.js

@@ -0,0 +1,263 @@
+const defaultPlanReminderLines = (confidence = "high") => [
+  "PLAN_INJECTION_TEST_ACTIVE",
+  "Keep the user's current task, constraints, and repo context as the source of truth.",
+  "Do not restart the task or replace the answer format.",
+  "Include exactly one short line: workflow-received",
+  ...confidence === "medium" ? ["- If this was not intended as a planning turn, ignore this reminder."] : []
+];
+const DEFAULT_SCAN_LINE_LIMIT = 5;
+const DEFAULT_SCAN_CHAR_LIMIT = 800;
+const CLASSIFICATION_PLAN_RE = /(?:^|\n)\s*(?:#{1,6}\s*)?(?:\*\*)?Classification(?:\s*:|:)(?:\*\*)?\s*(?:\[\s*Plan\s*\]|Plan)(?=[\s:;,.!?-]|$)/mi;
+const I_DETECT_PLAN_RE = /(?:^|\n)\s*I\s+detect\s+(?:\[\s*Plan\s*\]|Plan)(?=[\s:;,.!?-]|$)/i;
+const buildScanWindow = (text, lineLimit = DEFAULT_SCAN_LINE_LIMIT, charLimit = DEFAULT_SCAN_CHAR_LIMIT) => {
+  const lines = text.split("\n");
+  const selected = [];
+  let inFence = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    selected.push(line);
+    if (selected.length >= lineLimit) break;
+  }
+  return selected.join("\n").slice(0, charLimit);
+};
+const confidenceRank = {
+  none: 0,
+  medium: 1,
+  high: 2
+};
+const getTriggerConfidence = (trigger) => trigger.confidence ?? "high";
+const matchTrigger = (scanWindow, trigger) => {
+  if (!trigger.value) return -1;
+  if (trigger.type === "regex") {
+    try {
+      const flags = trigger.caseSensitive ? "m" : "im";
+      const regex = new RegExp(trigger.value, flags);
+      const match = regex.exec(scanWindow);
+      return match?.index ?? -1;
+    } catch {
+      return -1;
+    }
+  }
+  const haystack = trigger.caseSensitive ? scanWindow : scanWindow.toLowerCase();
+  const needle = trigger.caseSensitive ? trigger.value : trigger.value.toLowerCase();
+  return haystack.indexOf(needle);
+};
+const findBestRuleMatch = (scanWindow, rule) => {
+  const activeTriggers = rule.triggers.filter(
+    (trigger) => typeof trigger.value === "string" && trigger.value.trim().length > 0
+  );
+  if (activeTriggers.length === 0) {
+    return { detected: false, confidence: "none", ruleId: null, matchOffset: -1 };
+  }
+  const strategy = rule.match ?? "any";
+  const matches = activeTriggers.map((trigger) => ({
+    trigger,
+    index: matchTrigger(scanWindow, trigger)
+  }));
+  if (strategy === "all" && matches.some((match) => match.index === -1)) {
+    return { detected: false, confidence: "none", ruleId: null, matchOffset: -1 };
+  }
+  const matched = matches.filter((match) => match.index !== -1);
+  if (matched.length === 0) {
+    return { detected: false, confidence: "none", ruleId: null, matchOffset: -1 };
+  }
+  const strongest = matched.reduce((best, current) => {
+    const currentConfidence = getTriggerConfidence(current.trigger);
+    const bestConfidence = getTriggerConfidence(best.trigger);
+    if (confidenceRank[currentConfidence] > confidenceRank[bestConfidence]) {
+      return current;
+    }
+    if (confidenceRank[currentConfidence] === confidenceRank[bestConfidence] && current.index < best.index) {
+      return current;
+    }
+    return best;
+  });
+  const firstOffset = matched.reduce(
+    (offset, current) => Math.min(offset, current.index),
+    matched[0]?.index ?? -1
+  );
+  return {
+    detected: true,
+    confidence: getTriggerConfidence(strongest.trigger),
+    ruleId: rule.id,
+    matchOffset: firstOffset
+  };
+};
+const workflowInjectionFromPlanDetection = (config) => {
+  if (!config?.enabled) return void 0;
+  return {
+    enabled: true,
+    debugLog: config.debugLog,
+    queueVisibleReminder: config.queueVisibleReminder ?? config.userVisibleTrace ?? false,
+    queueVisibleReminderTemplate: config.queueVisibleReminderTemplate ?? config.userVisibleTraceTemplate,
+    scanLineLimit: config.scanLineLimit,
+    scanCharLimit: config.scanCharLimit,
+    maxInjectionsPerSession: config.maxInjectionsPerSession,
+    rules: [
+      {
+        id: "plan",
+        match: "any",
+        triggers: [
+          {
+            type: "regex",
+            value: "(?:^|\\n)\\s*(?:#{1,6}\\s*)?(?:\\*\\*)?Classification(?:\\s*:|:)(?:\\*\\*)?\\s*(?:\\[\\s*Plan\\s*\\]|Plan)(?=[\\s:;,.!?-]|$)",
+            confidence: "high"
+          },
+          {
+            type: "regex",
+            value: "(?:^|\\n)\\s*I\\s+detect\\s+(?:\\[\\s*Plan\\s*\\]|Plan)(?=[\\s:;,.!?-]|$)",
+            confidence: "medium"
+          }
+        ],
+        reminderTemplate: config.reminderTemplate?.trim() || [
+          "PLAN_INJECTION_TEST_ACTIVE",
+          "Keep the user's current task, constraints, and repo context as the source of truth.",
+          "Do not restart the task or replace the answer format.",
+          "Include exactly one short line: workflow-received"
+        ].join("\n"),
+        queueVisibleReminderTemplate: config.queueVisibleReminderTemplate ?? config.userVisibleTraceTemplate
+      }
+    ]
+  };
+};
+const getRule = (config, ruleId) => config?.rules.find((rule) => rule.id === ruleId);
+const extractReminderLine = (reminderTemplate, prefix) => {
+  if (!reminderTemplate?.trim()) return null;
+  for (const line of reminderTemplate.split("\n")) {
+    const trimmed = line.trim();
+    if (prefix.test(trimmed)) return trimmed;
+  }
+  return null;
+};
+const detectWorkflowIntent = (text, config) => {
+  if (!config?.enabled || !text || text.length < 10) {
+    return { detected: false, confidence: "none", ruleId: null, matchOffset: -1 };
+  }
+  const scanWindow = buildScanWindow(
+    text,
+    config.scanLineLimit,
+    config.scanCharLimit
+  );
+  let best = {
+    detected: false,
+    confidence: "none",
+    ruleId: null,
+    matchOffset: -1
+  };
+  for (const rule of config.rules) {
+    if (rule.enabled === false) continue;
+    const signal = findBestRuleMatch(scanWindow, rule);
+    if (!signal.detected) continue;
+    if (confidenceRank[signal.confidence] > confidenceRank[best.confidence]) {
+      best = signal;
+      continue;
+    }
+    if (confidenceRank[signal.confidence] === confidenceRank[best.confidence] && (best.matchOffset === -1 || signal.matchOffset < best.matchOffset)) {
+      best = signal;
+    }
+  }
+  return best;
+};
+const shouldInjectWorkflowGuidance = (signal, config) => signal.detected && !!config?.enabled;
+const buildWorkflowReminder = (signal, config) => {
+  const rule = getRule(config, signal.ruleId);
+  const reminderBody = rule?.reminderTemplate?.trim() ? rule.reminderTemplate.trim() : [
+    "WORKFLOW_INJECTION_TEST_ACTIVE",
+    "Keep the user's current task, constraints, and repo context as the source of truth.",
+    "Do not restart the task or replace the answer format.",
+    "Include exactly one short line: workflow-received"
+  ].join("\n");
+  return `<system-reminder>
+${reminderBody}
+</system-reminder>`;
+};
+const buildWorkflowTraceNotice = (signal, config) => {
+  const rule = getRule(config, signal.ruleId);
+  const traceBody = rule?.queueVisibleReminderTemplate?.trim() || rule?.reminderTemplate?.trim() || config?.queueVisibleReminderTemplate?.trim() || "[agenthub] Workflow reminder injected.";
+  const reportLine = extractReminderLine(rule?.reminderTemplate, /^0\.\s*Report:/i);
+  const firstStep = extractReminderLine(rule?.reminderTemplate, /^1\./i);
+  return [traceBody, reportLine, firstStep].filter((value) => !!value).join("\n");
+};
+const INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+const buildQueuedWorkflowNotice = (signal, config) => {
+  return `${buildWorkflowReminder(signal, config)}
+${INTERNAL_INITIATOR_MARKER}`;
+};
+const detectPlanIntent = (text, config) => {
+  if (!text || text.length < 10) {
+    return { detected: false, confidence: "none", marker: null, matchOffset: -1 };
+  }
+  const scanWindow = buildScanWindow(
+    text,
+    config?.scanLineLimit,
+    config?.scanCharLimit
+  );
+  const classificationMatch = CLASSIFICATION_PLAN_RE.exec(scanWindow);
+  if (classificationMatch) {
+    return {
+      detected: true,
+      confidence: "high",
+      marker: "classification",
+      matchOffset: classificationMatch.index
+    };
+  }
+  const detectMatch = I_DETECT_PLAN_RE.exec(scanWindow);
+  if (detectMatch) {
+    return {
+      detected: true,
+      confidence: "medium",
+      marker: "i-detect",
+      matchOffset: detectMatch.index
+    };
+  }
+  return { detected: false, confidence: "none", marker: null, matchOffset: -1 };
+};
+const shouldInjectPlanGuidance = (signal, config) => {
+  if (!signal.detected) return false;
+  const threshold = config?.threshold ?? "medium";
+  if (threshold === "high") return signal.confidence === "high";
+  return signal.confidence === "high" || signal.confidence === "medium";
+};
+const buildPlanReminder = (signal, config) => {
+  const reminderBody = config?.reminderTemplate?.trim() ? config.reminderTemplate.trim() : defaultPlanReminderLines(signal.confidence).join("\n");
+  return `<system-reminder>
+${reminderBody}
+</system-reminder>`;
+};
+const buildPlanTraceNotice = (config) => {
+  const traceTemplate = config?.queueVisibleReminderTemplate ?? config?.userVisibleTraceTemplate;
+  const traceBody = traceTemplate?.trim() ? traceTemplate.trim() : config?.reminderTemplate?.trim() ? config.reminderTemplate.trim() : "[agenthub] Plan reminder injected.";
+  const reportLine = extractReminderLine(config?.reminderTemplate, /^0\.\s*Report:/i);
+  const firstStep = extractReminderLine(config?.reminderTemplate, /^1\./i);
+  return [
+    traceBody,
+    reportLine,
+    firstStep ?? "Follow a structured plan for the current task before continuing."
+  ].filter((value) => !!value).join("\n");
+};
+const buildQueuedPlanNotice = (config, signal) => {
+  return `${buildPlanReminder(
+    signal ?? { detected: true, confidence: "high", marker: "classification", matchOffset: 0 },
+    config
+  )}
+${INTERNAL_INITIATOR_MARKER}`;
+};
+export {
+  INTERNAL_INITIATOR_MARKER,
+  buildPlanReminder,
+  buildPlanTraceNotice,
+  buildQueuedPlanNotice,
+  buildQueuedWorkflowNotice,
+  buildWorkflowReminder,
+  buildWorkflowTraceNotice,
+  detectPlanIntent,
+  detectWorkflowIntent,
+  shouldInjectPlanGuidance,
+  shouldInjectWorkflowGuidance,
+  workflowInjectionFromPlanDetection
+};

package/dist/plugins/runtime-config.js

@@ -0,0 +1,57 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+const resolvePluginConfigRoot = (explicitRoot) => {
+  if (explicitRoot?.trim()) return path.resolve(explicitRoot);
+  const fromEnv = typeof process !== "undefined" ? process.env.OPENCODE_CONFIG_DIR : void 0;
+  if (fromEnv?.trim()) return path.resolve(fromEnv);
+  return path.resolve(".opencode");
+};
+const runtimeConfigPathForRoot = (configRoot) => path.join(configRoot, "agenthub-runtime.json");
+const parseRuntimeJson = (content) => {
+  const jsonContent = content.split("\n").filter((line) => !line.trim().startsWith("//")).join("\n");
+  return JSON.parse(jsonContent);
+};
+const inspectRuntimeConfig = async (configRoot = resolvePluginConfigRoot()) => {
+  const runtimeConfigPath = runtimeConfigPathForRoot(configRoot);
+  try {
+    const content = await readFile(runtimeConfigPath, "utf-8");
+    return {
+      ok: true,
+      configRoot,
+      runtimeConfigPath,
+      config: parseRuntimeJson(content)
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      configRoot,
+      runtimeConfigPath,
+      error
+    };
+  }
+};
+const summarizeRuntimeFeatureState = (config) => {
+  const allBlockedTools = /* @__PURE__ */ new Set();
+  if (config.globalBlockedTools) {
+    for (const tool of config.globalBlockedTools) {
+      allBlockedTools.add(tool);
+    }
+  }
+  for (const agentInfo of Object.values(config.agents)) {
+    for (const tool of agentInfo.blockedTools) {
+      allBlockedTools.add(tool);
+    }
+  }
+  return {
+    blockedTools: allBlockedTools,
+    planDetection: config.planDetection,
+    workflowInjection: config.workflowInjection
+  };
+};
+export {
+  inspectRuntimeConfig,
+  parseRuntimeJson,
+  resolvePluginConfigRoot,
+  runtimeConfigPathForRoot,
+  summarizeRuntimeFeatureState
+};

package/dist/skills/agenthub-doctor/SKILL.md

@@ -0,0 +1,238 @@
+# Agent Hub Doctor Skill
+
+## Purpose
+
+You are an Agent Hub diagnostic and assembly agent. Your job is to:
+1. **Diagnose** Agent Hub setup issues
+2. **Explain** problems to users clearly  
+3. **Assemble** bundles and profiles interactively
+
+## Interactive Assembly Flow
+
+```
+┌─────────────────────────────────────────┐
+│  setup completes                        │
+│  OR user runs: opencode-agenthub doctor │
+└──────────────────┬──────────────────────┘
+                   │
+                   ▼
+          ┌────────────────────┐
+          │ Run diagnostics    │
+          └────────┬───────────┘
+                   │
+                   ▼
+       ┌───────────────────────┐
+       │ Found orphaned souls? │
+       └─────┬──────────┬──────┘
+             │ No       │ Yes
+             │          ▼
+             │    ┌─────────────────────────────────┐
+             │    │ "Found N souls without bundles: │
+             │    │  - soul-1, soul-2              │
+             │    │                                 │
+             │    │ Create bundles? [Y/n]"         │
+             │    └────────┬────────────────────────┘
+             │             │ Yes
+             │             ▼
+             │    ┌─────────────────────────────────┐
+             │    │ FOR EACH SOUL:                  │
+             │    │ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━│
+             │    │                                 │
+             │    │ 1️⃣ Select skill sets (multi):  │
+             │    │   □ core_reading               │
+             │    │   □ core_editing               │
+             │    │   ☑ full_dev (default)         │
+             │    │                                 │
+             │    │ 2️⃣ Add dedicated skills:        │
+             │    │   > my-skill, custom-skill     │
+             │    │   (comma-separated or skip)    │
+             │    │                                 │
+             │    │ 3️⃣ Select MCP servers:          │
+             │    │   (Only if custom MCPs exist)  │
+             │    │   □ my-mcp                     │
+             │    │   ☑ custom-mcp                 │
+             │    │                                 │
+             │    │ 4️⃣ Apply guards:                │
+             │    │   □ read_only                  │
+             │    │   □ no_task                    │
+             │    │   ☑ none (default)             │
+             │    │                                 │
+             │    │ ✓ Bundle created!              │
+             │    └────────┬────────────────────────┘
+             │             │
+             │             ▼
+             │    ┌─────────────────────────────────┐
+             │    │ Create profile? [Y/n]          │
+             │    │                                 │
+             │    │ Profile name: [imported]       │
+             │    │ Bundles: soul-1, soul-2        │
+             │    │ Default agent: [soul-1]        │
+             │    │                                 │
+             │    │ ✓ Profile created!             │
+             │    └────────┬────────────────────────┘
+             │             │
+             ├─────────────┘
+             ▼
+    ┌─────────────────────────┐
+    │ Missing guards? [Y/n]   │
+    │ ✓ Guards added          │
+    └────────┬────────────────┘
+             │
+             ▼
+    ┌─────────────────────────┐
+    │ ✅ Assembly complete!    │
+    │                         │
+    │ Next steps:             │
+    │  cd /your/project       │
+    │  opencode-agenthub run  │
+    └─────────────────────────┘
+```
+
+## Key Principles
+
+1. **No waste** - Only ask relevant questions
+2. **Smart defaults** - full_dev skill set, no guards
+3. **Smooth flow** - No interruptions, comma-separated inputs
+4. **Clear feedback** - Show what was created
+
+## Capabilities
+
+### Diagnostic Functions
+
+- `diagnoseGuards()` - Check if required guards exist in settings.json
+- `diagnoseOrphanedAssets()` - Find souls/skills not referenced by any bundle
+- `diagnoseProfiles()` - Check if profiles exist and are valid
+- `diagnoseBundles()` - Validate bundle configurations
+
+### Fix Functions
+
+- `fixMissingGuards()` - Add default guards to settings.json
+- `createBundleForSoul()` - Generate bundle for an orphaned soul
+- `createProfile()` - Generate profile referencing bundles
+- `validateAndFix()` - Comprehensive validation and repair
+
+## Workflow
+
+### 1. Initial Diagnosis
+
+```typescript
+const issues = await runDiagnostics(targetRoot);
+```
+
+Report findings to user in this format:
+
+```
+🔍 Agent Hub Diagnostics Report
+
+✅ Healthy:
+  - Settings file exists
+  - 3 souls found
+  - 2 skills found
+
+⚠️  Issues Found:
+  1. Missing guards: no_task, read_only
+  2. Orphaned souls: custom-agent, my-helper
+  3. No profiles found
+```
+
+### 2. Ask User for Consent
+
+Before applying fixes, ask:
+- "Fix missing guards?" (Recommended: Yes)
+- "Create bundles for orphaned souls?" (List which souls)
+- "Create a default profile?" (Explain what it includes)
+
+### 3. Apply Fixes
+
+Apply fixes one by one, reporting progress:
+
+```
+✓ Added default guards to settings.json
+✓ Created bundle for 'custom-agent'
+✓ Created bundle for 'my-helper'
+✓ Created profile 'imported' with 2 bundles
+```
+
+### 4. Verify
+
+Run diagnostics again to confirm all issues resolved:
+
+```
+✅ All issues resolved! Agent Hub is ready to use.
+
+Next steps:
+  cd /your/project
+  opencode-agenthub run imported
+```
+
+## Guard Definitions
+
+Default guards that should exist:
+
+```json
+{
+  "read_only": {
+    "description": "Read-only access - no file modifications",
+    "permission": {
+      "edit": "deny",
+      "write": "deny",
+      "bash": "deny"
+    }
+  },
+  "no_task": {
+    "description": "Block task tool",
+    "blockedTools": ["task"],
+    "permission": {
+      "task": { "*": "deny" }
+    }
+  }
+}
+```
+
+## Bundle Template
+
+When creating bundles for orphaned souls:
+
+```json
+{
+  "name": "<soul-name>",
+  "runtime": "native",
+  "soul": "<soul-name>",
+  "skills": [],
+  "mcp": [],
+  "agent": {
+    "name": "<soul-name>",
+    "mode": "primary",
+    "model": "github-copilot/claude-sonnet-4.5",
+    "description": "Auto-generated bundle for imported soul"
+  }
+}
+```
+
+## Profile Template
+
+When creating profiles:
+
+```json
+{
+  "name": "imported",
+  "description": "Auto-generated profile for imported assets",
+  "bundles": ["<list-of-bundle-names>"],
+  "defaultAgent": "<first-bundle-agent-name>",
+  "plugins": ["opencode-agenthub"]
+}
+```
+
+## Error Handling
+
+- If settings.json doesn't exist, create it with defaults
+- If a soul file is invalid, skip it and warn user
+- If bundle/profile creation fails, roll back and explain why
+- Never modify files without user consent
+
+## Communication Style
+
+- Be clear and concise
+- Use emojis for visual clarity (✓, ⚠️, ✅, ❌)
+- Explain technical terms in plain language
+- Provide actionable next steps