opencode-agenthub 0.1.0

package/dist/plugins/opencode-agenthub.js

@@ -0,0 +1,310 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import {
+  buildPlanTraceNotice,
+  buildQueuedPlanNotice,
+  buildQueuedWorkflowNotice,
+  buildWorkflowTraceNotice,
+  detectPlanIntent,
+  detectWorkflowIntent,
+  INTERNAL_INITIATOR_MARKER,
+  shouldInjectPlanGuidance,
+  shouldInjectWorkflowGuidance
+} from "./plan-guidance.js";
+import {
+  inspectRuntimeConfig,
+  resolvePluginConfigRoot,
+  summarizeRuntimeFeatureState
+} from "./runtime-config.js";
+const loadRuntimeConfig = async () => {
+  const inspection = await inspectRuntimeConfig(resolvePluginConfigRoot());
+  if (!inspection.ok) {
+    process.stderr.write(
+      "[opencode-agenthub] Warning: failed to load hub runtime config \u2014 running in degraded mode (tool blocking disabled, workflow injection disabled). Run 'agenthub setup' to initialize your Agent Hub home.\n"
+    );
+    return { blockedTools: /* @__PURE__ */ new Set(["call_omo_agent"]) };
+  }
+  return summarizeRuntimeFeatureState(inspection.config);
+};
+const DEFAULT_PLAN_STATE = {
+  pendingVisibleNotice: null,
+  pendingVisibleSource: null,
+  detectedAtMessageID: null,
+  injectionCount: 0
+};
+async function opencode_agenthub_default(ctx) {
+  const { blockedTools, planDetection, workflowInjection } = await loadRuntimeConfig();
+  const activeWorkflowInjection = workflowInjection?.enabled ? workflowInjection : void 0;
+  const activePlanDetection = planDetection?.enabled ? planDetection : void 0;
+  const workflowInjectionEnabled = !!activeWorkflowInjection;
+  const planDetectionEnabled = !!activePlanDetection;
+  const maxInjectionsPerSession = activeWorkflowInjection?.maxInjectionsPerSession ?? activePlanDetection?.maxInjectionsPerSession ?? 3;
+  const debugLogPath = join(resolvePluginConfigRoot(), "plan-detection-debug.log");
+  const formatDebugError = (error) => {
+    if (error === void 0) return null;
+    if (error instanceof Error) return error.stack ?? error.message;
+    if (typeof error === "string") return error;
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  };
+  const debugLog = async (message, error) => {
+    if (!activeWorkflowInjection?.debugLog && !activePlanDetection?.debugLog) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const formattedError = formatDebugError(error);
+    const line = formattedError ? `[${timestamp}] ${message}
+${formattedError}
+` : `[${timestamp}] ${message}
+`;
+    try {
+      await mkdir(resolvePluginConfigRoot(), { recursive: true });
+      await appendFile(debugLogPath, line, "utf-8");
+    } catch {
+    }
+  };
+  const summarizeValue = (value) => {
+    if (Array.isArray(value)) return `array(len=${value.length})`;
+    if (value === null) return "null";
+    return typeof value;
+  };
+  const planState = /* @__PURE__ */ new Map();
+  const phases = ["CLARIFY", "GATHER", "ANALYZE", "SYNTHESIZE", "FORMAT", "DELIVER", "ANSWER", "QA_FORMAT"];
+  let currentRunId = null;
+  const knowledgeRoot = resolve(resolvePluginConfigRoot(), "knowledge");
+  const getToolName = (payload) => {
+    const directName = payload?.name;
+    if (typeof directName === "string") return directName;
+    const nestedToolName = payload?.tool?.name;
+    if (typeof nestedToolName === "string") return nestedToolName;
+    const nestedName = payload?.input?.name;
+    if (typeof nestedName === "string") return nestedName;
+    return null;
+  };
+  const generateRunId = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString().slice(0, 19).replace(/:/g, "-");
+  };
+  const extractPhaseOutputs = (text) => {
+    if (!text || text.length < 50) return [];
+    if (/<\/?[a-z][\s\S]*?>/i.test(text.slice(0, 500))) return [];
+    const markerRegex = /(?:^|\n)\s*(?:#{1,6}\s*)?(?:\*\*)?\s*(CLARIFY|GATHER|ANALYZE|SYNTHESIZE|FORMAT|DELIVER|ANSWER|QA_FORMAT)\s*:(?:\*\*)?/gi;
+    const markers = [];
+    for (const match of text.matchAll(markerRegex)) {
+      const phase = match[1]?.toUpperCase();
+      if (!phases.includes(phase)) continue;
+      const start = match.index ?? 0;
+      const markerText = match[0] ?? "";
+      markers.push({ phase, start, contentStart: start + markerText.length });
+    }
+    if (markers.length === 0) return [];
+    const outputs = [];
+    for (let index = 0; index < markers.length; index += 1) {
+      const current = markers[index];
+      const next = markers[index + 1];
+      const sliceEnd = next ? next.start : text.length;
+      const content = text.slice(current.contentStart, sliceEnd).trim();
+      if (content) outputs.push({ phase: current.phase, content });
+    }
+    return outputs;
+  };
+  const persistPhaseOutput = async (phase, content, runId) => {
+    const normalizedPhase = phase.trim().toUpperCase();
+    if (!phases.includes(normalizedPhase)) return;
+    const phaseContent = content.trim();
+    if (!phaseContent) return;
+    const runDirectory = join(knowledgeRoot, runId);
+    const phaseFilePath = join(runDirectory, `${normalizedPhase}.md`);
+    try {
+      await mkdir(runDirectory, { recursive: true });
+      await writeFile(phaseFilePath, `${phaseContent}
+`, "utf-8");
+    } catch {
+    }
+  };
+  const persistFromText = async (text) => {
+    const phaseOutputs = extractPhaseOutputs(text);
+    if (phaseOutputs.length === 0) return;
+    if (!currentRunId) currentRunId = generateRunId();
+    for (const phaseOutput of phaseOutputs) {
+      await persistPhaseOutput(phaseOutput.phase, phaseOutput.content, currentRunId);
+    }
+  };
+  const showVisibleToast = async (message) => {
+    const tuiClient = ctx?.client?.tui;
+    if (!tuiClient || typeof tuiClient.showToast !== "function") return false;
+    try {
+      await tuiClient.showToast({
+        body: {
+          title: "Agent Hub",
+          message,
+          variant: "info",
+          duration: 4e3
+        }
+      });
+      return true;
+    } catch (error) {
+      await debugLog("Failed to show visible plan reminder via tui.showToast.", error);
+      return false;
+    }
+  };
+  const extractSessionID = (hookInput) => {
+    const input = hookInput;
+    const direct = input?.sessionID;
+    if (typeof direct === "string" && direct) return direct;
+    const nested = input?.session?.id;
+    if (typeof nested === "string" && nested) return nested;
+    return void 0;
+  };
+  const getPlanState = (sessionID) => {
+    const existing = planState.get(sessionID);
+    if (existing) return existing;
+    const created = { ...DEFAULT_PLAN_STATE };
+    planState.set(sessionID, created);
+    return created;
+  };
+  const clearPendingReminderState = async (state, sessionID, reason) => {
+    const clearedVisibleReminder = !!state.pendingVisibleNotice;
+    state.pendingVisibleNotice = null;
+    state.pendingVisibleSource = null;
+    state.detectedAtMessageID = null;
+    if (!clearedVisibleReminder) return;
+    await debugLog(
+      `Cleared stale pending visible reminder for session ${sessionID} (${reason}). visible=${clearedVisibleReminder}`
+    );
+  };
+  const injectVisibleReminderIntoToolOutput = async (toolOutput, notice, reminderSource, sessionID) => {
+    const currentText = typeof toolOutput.output === "string" ? toolOutput.output : "";
+    toolOutput.output = currentText ? `${notice}
+
+---
+
+${currentText}` : notice;
+    await debugLog(
+      `Injected visible ${reminderSource} reminder into tool.execute.after output for session ${sessionID}.`
+    );
+  };
+  const queueVisibleReminderForToolOutput = async (state, notice, reminderSource, sessionID) => {
+    state.pendingVisibleNotice = notice;
+    state.pendingVisibleSource = reminderSource;
+    await debugLog(
+      `Queued visible ${reminderSource} reminder for tool.execute.after injection in session ${sessionID}.`
+    );
+  };
+  const claimPendingVisibleReminder = (state) => {
+    if (!state.pendingVisibleNotice) return null;
+    const claimed = {
+      notice: state.pendingVisibleNotice,
+      reminderSource: state.pendingVisibleSource ?? "plan"
+    };
+    state.pendingVisibleNotice = null;
+    state.pendingVisibleSource = null;
+    state.injectionCount += 1;
+    return claimed;
+  };
+  return {
+    "tool.execute.before": async (hookInput) => {
+      const toolName = getToolName(hookInput);
+      if (toolName && blockedTools.has(toolName)) {
+        return {
+          error: `Blocked tool: ${toolName}. This tool is restricted by guard configuration.`
+        };
+      }
+    },
+    "experimental.text.complete": async (hookInput, output) => {
+      const currentOutput = output;
+      const originalText = typeof currentOutput?.text === "string" ? currentOutput.text ?? "" : "";
+      if (originalText.includes(INTERNAL_INITIATOR_MARKER)) {
+        await debugLog("Skipped plan detection for internal initiator message.");
+        return;
+      }
+      const sessionID = extractSessionID(hookInput);
+      const state = sessionID ? getPlanState(sessionID) : void 0;
+      const effectiveText = originalText;
+      await persistFromText(effectiveText);
+      if ((workflowInjectionEnabled || planDetectionEnabled) && effectiveText && sessionID) {
+        const messageID = hookInput?.messageID;
+        if (typeof messageID === "string" && state.detectedAtMessageID === messageID) return;
+        if (state.pendingVisibleNotice || state.injectionCount >= maxInjectionsPerSession) return;
+        const workflowSignal = activeWorkflowInjection ? detectWorkflowIntent(effectiveText, activeWorkflowInjection) : void 0;
+        const shouldInjectWorkflow = workflowSignal ? shouldInjectWorkflowGuidance(workflowSignal, activeWorkflowInjection) : false;
+        const planSignal = !shouldInjectWorkflow && activePlanDetection ? detectPlanIntent(effectiveText, activePlanDetection) : void 0;
+        const shouldInjectPlan = planSignal ? shouldInjectPlanGuidance(planSignal, activePlanDetection) : false;
+        if (!shouldInjectWorkflow && !shouldInjectPlan) return;
+        const shouldInjectVisibleReminder = shouldInjectWorkflow ? activeWorkflowInjection?.queueVisibleReminder ?? false : activePlanDetection?.queueVisibleReminder ?? activePlanDetection?.userVisibleTrace ?? true;
+        if (!shouldInjectVisibleReminder) return;
+        const reminderSource = shouldInjectWorkflow ? "workflow" : "plan";
+        const visibleNotice = shouldInjectWorkflow && workflowSignal ? buildWorkflowTraceNotice(workflowSignal, activeWorkflowInjection) : buildPlanTraceNotice(activePlanDetection);
+        const queuedNotice = shouldInjectWorkflow && workflowSignal ? buildQueuedWorkflowNotice(workflowSignal, activeWorkflowInjection) : buildQueuedPlanNotice(activePlanDetection, planSignal);
+        state.detectedAtMessageID = typeof messageID === "string" ? messageID : null;
+        await queueVisibleReminderForToolOutput(
+          state,
+          queuedNotice,
+          reminderSource,
+          sessionID
+        );
+        const toastShown = await showVisibleToast(visibleNotice);
+        if (toastShown) {
+          await debugLog(
+            `Displayed visible ${reminderSource} reminder via tui.showToast for session ${sessionID}.`
+          );
+        }
+        await debugLog(
+          `After-tool-only ${reminderSource} reminder active for session ${sessionID}: visible reminder goes to tool.execute.after output.`
+        );
+        if (shouldInjectWorkflow) {
+          await debugLog(
+            `Detected workflow marker (${workflowSignal?.ruleId ?? "unknown"}) for session ${sessionID}; queued visible reminder.`
+          );
+        } else {
+          await debugLog(`Detected legacy plan marker for session ${sessionID}; queued visible reminder.`);
+        }
+      }
+    },
+    "experimental.chat.system.transform": async () => {
+      return;
+    },
+    "chat.message": async (hookInput) => {
+      const sessionID = extractSessionID(hookInput);
+      if (!sessionID) return;
+      const state = planState.get(sessionID);
+      if (!state) return;
+      await clearPendingReminderState(state, sessionID, "new chat.message boundary");
+    },
+    "tool.execute.after": async (hookInput, hookOutput) => {
+      const sessionID = extractSessionID(hookInput);
+      const state = sessionID ? planState.get(sessionID) : void 0;
+      const candidateOutput = hookOutput?.output;
+      const claimedReminder = state && typeof candidateOutput === "string" ? claimPendingVisibleReminder(state) : null;
+      if (claimedReminder && sessionID) {
+        await injectVisibleReminderIntoToolOutput(
+          hookOutput,
+          claimedReminder.notice,
+          claimedReminder.reminderSource,
+          sessionID
+        );
+      } else if (state?.pendingVisibleNotice && sessionID && typeof candidateOutput !== "string") {
+        await debugLog(
+          `Deferred visible ${state.pendingVisibleSource ?? "plan"} reminder for session ${sessionID} because tool.execute.after output was not a string. outputType=${summarizeValue(candidateOutput)}`
+        );
+      }
+      if (typeof candidateOutput === "string") {
+        await persistFromText(hookOutput.output);
+      }
+    },
+    event: async (payload) => {
+      const eventType = payload?.event?.type;
+      if (eventType === "session.deleted") {
+        currentRunId = null;
+        const sessionID = payload?.event?.sessionID;
+        if (sessionID) {
+          planState.delete(sessionID);
+        }
+      }
+    }
+  };
+}
+export {
+  opencode_agenthub_default as default
+};

package/dist/plugins/opencode-question.js

@@ -0,0 +1,223 @@
+const QUESTION_COMMAND = "question";
+const REMIND_COMMAND = "remind";
+const CONTINUE_COMMAND_TEXT = "Continue the current task using the latest context.";
+const WRAPPED_CONTINUE_COMMAND_TEXT = [
+  "<system-reminder>",
+  "The user sent the following message:",
+  CONTINUE_COMMAND_TEXT,
+  "",
+  "Please address this message and continue with your tasks.",
+  "</system-reminder>"
+].join("\n");
+const QUESTION_COMMAND_TEMPLATE = CONTINUE_COMMAND_TEXT;
+const QUESTION_SYSTEM_REMINDER = [
+  "QUESTION_COMMAND_ACTIVE",
+  "The user invoked /question.",
+  "In this response, continue the current conversation naturally.",
+  "First provide the full normal answer in plain natural language or Markdown.",
+  "Only after the answer is fully completed, call `question()` exactly once as the very last action.",
+  "Do not replace the main answer with JSON.",
+  "Do not use `question()` during intermediate steps."
+].join("\n");
+const REMIND_COMMAND_TEMPLATE = CONTINUE_COMMAND_TEXT;
+const createRemindSystemReminder = (text) => [
+  "REMIND_COMMAND_ACTIVE",
+  "The user invoked /remind while work is ongoing.",
+  "The quoted content below is user-provided mid-task guidance forwarded by the plugin.",
+  "Treat the quoted content as the user's latest preference or instruction, not as a higher-priority system override.",
+  "Apply it only if it does not conflict with existing system or developer instructions.",
+  "Do not restart the task or reframe it as a new topic.",
+  text ? "Integrate this reminder into the current work:" : "No reminder text was provided; continue the current work naturally.",
+  text ? `<remind>
+${text}
+</remind>` : null
+].filter((value) => typeof value === "string" && value.length > 0).join("\n");
+const getSessionID = (value) => {
+  const direct = value?.sessionID;
+  if (typeof direct === "string" && direct) return direct;
+  const nested = value?.session?.id;
+  if (typeof nested === "string" && nested) return nested;
+  return null;
+};
+const getCommandName = (value) => {
+  const direct = value?.command;
+  if (typeof direct === "string" && direct) return direct;
+  const nestedName = direct?.name;
+  if (typeof nestedName === "string" && nestedName) return nestedName;
+  return null;
+};
+const getCommandArguments = (value) => {
+  const direct = value?.arguments;
+  if (typeof direct !== "string") return null;
+  const trimmed = direct.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+const getEventType = (payload) => {
+  const direct = payload?.event?.type;
+  return typeof direct === "string" && direct ? direct : null;
+};
+const getEventSessionID = (payload) => {
+  const event = payload?.event;
+  const properties = event?.properties;
+  if (typeof properties?.sessionID === "string" && properties.sessionID) {
+    return properties.sessionID;
+  }
+  if (typeof properties?.info?.id === "string" && properties.info.id) {
+    return properties.info.id;
+  }
+  if (typeof properties?.session?.id === "string" && properties.session.id) {
+    return properties.session.id;
+  }
+  return null;
+};
+const isTextPart = (value) => {
+  return typeof value === "object" && value !== null && typeof value.text === "string";
+};
+const normalizeMessageText = (text) => text.replace(/\r\n/g, "\n").trim();
+const isBlankText = (text) => normalizeMessageText(text).length === 0;
+const isContinuationText = (text) => {
+  const normalized = normalizeMessageText(text);
+  return normalized === CONTINUE_COMMAND_TEXT || normalized === WRAPPED_CONTINUE_COMMAND_TEXT;
+};
+const scrubCommandParts = (output) => {
+  const currentOutput = output;
+  if (!Array.isArray(currentOutput.parts)) return;
+  const preservedNonTextParts = currentOutput.parts.filter((part) => !isTextPart(part));
+  const firstTextPart = currentOutput.parts.find(isTextPart);
+  if (firstTextPart) {
+    firstTextPart.text = CONTINUE_COMMAND_TEXT;
+    currentOutput.parts = [firstTextPart, ...preservedNonTextParts];
+    return;
+  }
+  currentOutput.parts = [{ type: "text", text: CONTINUE_COMMAND_TEXT }, ...preservedNonTextParts];
+};
+const isSessionStateActive = (state) => {
+  return !!state && (state.questionActive || Object.hasOwn(state, "remindText"));
+};
+const getMessageSessionID = (msg) => {
+  const direct = msg?.sessionID;
+  if (typeof direct === "string" && direct) return direct;
+  const info = msg?.info;
+  if (!info || typeof info !== "object") return null;
+  const sessionID = info.sessionID;
+  return typeof sessionID === "string" && sessionID ? sessionID : null;
+};
+const getMessageRole = (msg) => {
+  const direct = msg?.role;
+  if (typeof direct === "string" && direct) return direct;
+  const info = msg?.info;
+  if (!info || typeof info !== "object") return null;
+  const role = info.role;
+  return typeof role === "string" && role ? role : null;
+};
+const isUserContinuationMessage = (msg) => {
+  const typed = msg;
+  if (!typed) return false;
+  if (getMessageRole(msg) !== "user") return false;
+  const parts = typed.parts;
+  if (!Array.isArray(parts) || parts.length === 0) return false;
+  const textParts = parts.filter(isTextPart);
+  if (textParts.length === 0) return false;
+  const nonTextParts = parts.filter((p) => !isTextPart(p));
+  if (nonTextParts.length > 0) return false;
+  const [primaryText, ...trailingTextParts] = textParts;
+  if (!isContinuationText(primaryText.text)) return false;
+  return trailingTextParts.every((part) => isBlankText(part.text));
+};
+async function opencode_question_default() {
+  const activeSessions = /* @__PURE__ */ new Map();
+  const getSessionState = (sessionID) => {
+    const existing = activeSessions.get(sessionID);
+    if (existing) return existing;
+    const created = {};
+    activeSessions.set(sessionID, created);
+    return created;
+  };
+  return {
+    config: async (config) => {
+      const cfg = config;
+      if (!cfg.command) cfg.command = {};
+      cfg.command[QUESTION_COMMAND] = {
+        template: QUESTION_COMMAND_TEMPLATE,
+        description: "Continue the current conversation and force a final question() call",
+        subtask: false
+      };
+      cfg.command[REMIND_COMMAND] = {
+        template: REMIND_COMMAND_TEMPLATE,
+        description: "Inject one-shot mid-task guidance and continue the current conversation",
+        subtask: false
+      };
+    },
+    "command.execute.before": async (input, output) => {
+      const sessionID = getSessionID(input);
+      if (!sessionID) return;
+      const commandName = getCommandName(input);
+      if (!commandName) return;
+      if (commandName !== QUESTION_COMMAND && commandName !== REMIND_COMMAND) return;
+      scrubCommandParts(output);
+      const state = getSessionState(sessionID);
+      if (commandName === QUESTION_COMMAND) {
+        state.questionActive = true;
+        return;
+      }
+      if (commandName === REMIND_COMMAND) {
+        state.remindText = getCommandArguments(input);
+      }
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      const sessionID = getSessionID(input);
+      if (!sessionID) return;
+      const state = activeSessions.get(sessionID);
+      if (!state) return;
+      const currentOutput = output;
+      if (!Array.isArray(currentOutput.system)) return;
+      if (state.questionActive && !currentOutput.system.includes(QUESTION_SYSTEM_REMINDER)) {
+        currentOutput.system.push(QUESTION_SYSTEM_REMINDER);
+      }
+      if (Object.hasOwn(state, "remindText")) {
+        const remindSystemReminder = createRemindSystemReminder(state.remindText ?? null);
+        if (!currentOutput.system.includes(remindSystemReminder)) {
+          currentOutput.system.push(remindSystemReminder);
+        }
+      }
+    },
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const currentOutput = output;
+      if (!Array.isArray(currentOutput.messages) || currentOutput.messages.length === 0) return;
+      const hasAnyActiveSession = [...activeSessions.values()].some(isSessionStateActive);
+      if (!hasAnyActiveSession) return;
+      const sessionsToFilter = /* @__PURE__ */ new Set();
+      for (const msg of currentOutput.messages) {
+        const sessionID = getMessageSessionID(msg);
+        if (!sessionID) continue;
+        if (isSessionStateActive(activeSessions.get(sessionID))) {
+          sessionsToFilter.add(sessionID);
+        }
+      }
+      const filtered = [];
+      for (const msg of currentOutput.messages) {
+        if (isUserContinuationMessage(msg)) {
+          const sessionID = getMessageSessionID(msg);
+          if (!sessionID) {
+            continue;
+          }
+          if (sessionsToFilter.has(sessionID)) {
+            continue;
+          }
+        }
+        filtered.push(msg);
+      }
+      currentOutput.messages = filtered;
+    },
+    event: async (payload) => {
+      const eventType = getEventType(payload);
+      if (eventType !== "session.idle" && eventType !== "session.deleted") return;
+      const sessionID = getEventSessionID(payload);
+      if (!sessionID) return;
+      activeSessions.delete(sessionID);
+    }
+  };
+}
+export {
+  opencode_question_default as default
+};