mednotes-opencode 0.1.0

package/.opencode/plugins/mednotes_hook/adapters/opencode_user_config_sync.mjs

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// OpenCode imports the project plugin before user agents are invoked. This
+// adapter uses that boot point to apply only runtime knobs from the user TOML:
+// specialist model ids and reasoning effort. FSM state and workflow policy do
+// not live here.
+const FIELD_TO_AGENT = new Map([
+  ["med_chat_triager", "med-chat-triager"],
+  ["med_flashcard_maker", "med-flashcard-maker"],
+  ["med_knowledge_architect", "med-knowledge-architect"],
+  ["med_link_graph_curator", "med-link-graph-curator"],
+  ["med_publish_guard", "med-publish-guard"],
+]);
+const REASONING_EFFORTS = new Set(["minimal", "low", "medium", "high"]);
+
+export function syncMedNotesOpenCodeUserConfig(projectRoot = opencodeProjectRoot()) {
+  if (autoSyncDisabled()) return { status: "disabled", agents: [] };
+  const runtimeByAgent = readRuntimeOverrides(projectRoot);
+  applyRuntimeOverridesToFiles(projectRoot, runtimeByAgent);
+  return {
+    status: "synced",
+    project_root: projectRoot,
+    agents: Object.keys(runtimeByAgent).sort(),
+  };
+}
+
+export function applyMedNotesOpenCodeRuntimeConfig(config, projectRoot = opencodeProjectRoot()) {
+  const runtimeByAgent = readRuntimeOverrides(projectRoot);
+  config.agent = config.agent && typeof config.agent === "object" ? config.agent : {};
+  for (const [agentId, runtimeConfig] of Object.entries(runtimeByAgent)) {
+    const entry = config.agent[agentId] && typeof config.agent[agentId] === "object" ? config.agent[agentId] : {};
+    config.agent[agentId] = { ...entry, ...runtimeConfig };
+  }
+}
+
+function readRuntimeOverrides(projectRoot) {
+  const configPath = findConfigPath(projectRoot);
+  if (!configPath || !existsSync(configPath)) return {};
+  return parseAgentRuntimeConfig(readFileSync(configPath, "utf8"), configPath);
+}
+
+function applyRuntimeOverridesToFiles(projectRoot, runtimeByAgent) {
+  if (Object.keys(runtimeByAgent).length === 0) return;
+  updateOpenCodeJson(path.join(projectRoot, ".opencode", "opencode.json"), runtimeByAgent);
+  for (const [agentId, runtimeConfig] of Object.entries(runtimeByAgent)) {
+    updateAgentMarkdown(path.join(projectRoot, ".opencode", "agents", `${agentId}.md`), runtimeConfig);
+  }
+}
+
+function updateOpenCodeJson(configPath, runtimeByAgent) {
+  if (!existsSync(configPath)) return;
+  const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+  parsed.agent = parsed.agent && typeof parsed.agent === "object" ? parsed.agent : {};
+  for (const [agentId, runtimeConfig] of Object.entries(runtimeByAgent)) {
+    const entry = parsed.agent[agentId] && typeof parsed.agent[agentId] === "object" ? parsed.agent[agentId] : {};
+    parsed.agent[agentId] = { ...entry, ...runtimeConfig };
+  }
+  writeIfChanged(configPath, `${JSON.stringify(parsed, null, 2)}\n`);
+}
+
+function updateAgentMarkdown(agentPath, runtimeConfig) {
+  if (!existsSync(agentPath)) return;
+  let text = readFileSync(agentPath, "utf8");
+  if (runtimeConfig.model) {
+    text = replaceFrontmatterLine(agentPath, text, "model", runtimeConfig.model);
+  }
+  if (runtimeConfig.reasoningEffort) {
+    text = replaceFrontmatterLine(agentPath, text, "reasoningEffort", runtimeConfig.reasoningEffort);
+  }
+  writeIfChanged(agentPath, text);
+}
+
+function replaceFrontmatterLine(agentPath, text, key, value) {
+  const pattern = new RegExp(`^${key}: .+$`, "m");
+  if (!pattern.test(text)) {
+    throw new Error(`MedNotes OpenCode auto-sync could not find ${key} in ${agentPath}`);
+  }
+  return text.replace(pattern, `${key}: ${frontmatterScalar(value)}`);
+}
+
+function parseAgentRuntimeConfig(text, configPath) {
+  // The MedNotes config template emits simple [agents.<name>] TOML sections.
+  // Keeping this parser narrow avoids making plugin startup depend on Python or
+  // a package install before OpenCode opens.
+  const runtimeByAgent = {};
+  let currentAgentId = "";
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+
+    const section = line.match(/^\[agents\.([A-Za-z0-9_]+)\]$/);
+    if (section) {
+      currentAgentId = FIELD_TO_AGENT.get(section[1]) || "";
+      continue;
+    }
+    if (line.startsWith("[")) {
+      currentAgentId = "";
+      continue;
+    }
+    if (!currentAgentId) continue;
+
+    const assignment = line.match(/^([A-Za-z0-9_]+)\s*=\s*(.+)$/);
+    if (!assignment) continue;
+    const key = assignment[1];
+    const value = parseTomlStringValue(assignment[2], configPath);
+    if (key === "model") {
+      if (!value) throw new Error(`MedNotes OpenCode config has empty model for ${currentAgentId}`);
+      runtimeByAgent[currentAgentId] = { ...(runtimeByAgent[currentAgentId] || {}), model: value };
+    }
+    if (key === "reasoning_effort") {
+      if (!REASONING_EFFORTS.has(value)) {
+        throw new Error(`MedNotes OpenCode config has invalid reasoning_effort for ${currentAgentId}: ${value}`);
+      }
+      runtimeByAgent[currentAgentId] = { ...(runtimeByAgent[currentAgentId] || {}), reasoningEffort: value };
+    }
+  }
+  return runtimeByAgent;
+}
+
+function parseTomlStringValue(rawValue, configPath) {
+  const value = rawValue.trim();
+  if (value.startsWith('"')) {
+    let escaped = false;
+    for (let index = 1; index < value.length; index += 1) {
+      const char = value[index];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') return JSON.parse(value.slice(0, index + 1));
+    }
+    throw new Error(`Invalid quoted TOML string in ${configPath}`);
+  }
+  if (value.startsWith("'")) {
+    const end = value.indexOf("'", 1);
+    if (end > 0) return value.slice(1, end);
+    throw new Error(`Invalid literal TOML string in ${configPath}`);
+  }
+  return value.split("#", 1)[0].trim();
+}
+
+function findConfigPath(projectRoot) {
+  if (process.env.MEDNOTES_CONFIG) return path.resolve(process.env.MEDNOTES_CONFIG);
+  if (process.env.MEDNOTES_HOME) return path.resolve(process.env.MEDNOTES_HOME, "config.toml");
+  for (let current = path.resolve(projectRoot); ; current = path.dirname(current)) {
+    const candidate = path.join(current, "config.toml");
+    if (existsSync(candidate)) return candidate;
+    if (current === path.dirname(current)) break;
+  }
+  return path.join(os.homedir(), ".mednotes", "config.toml");
+}
+
+function opencodeProjectRoot() {
+  const adapterDir = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(adapterDir, "..", "..", "..", "..");
+}
+
+function autoSyncDisabled() {
+  return /^(0|false|no)$/i.test(process.env.MEDNOTES_OPENCODE_AUTO_SYNC || "");
+}
+
+function frontmatterScalar(value) {
+  const text = String(value);
+  return /^[A-Za-z0-9_./:@-]+$/.test(text) ? text : JSON.stringify(text);
+}
+
+function writeIfChanged(filePath, nextText) {
+  const current = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+  if (current !== nextText) writeFileSync(filePath, nextText, "utf8");
+}

package/.opencode/plugins/mednotes_hook/anki_preflight.mjs

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import http from "node:http";
+
+import { ankiAutoStart, ankiConnectUrl, ankiStartTimeoutMs, quiet } from "./runtime.mjs";
+
+export function isAnkiTool(payload) {
+  const toolName = String(payload.tool_name || payload.toolName || payload.name || "");
+  if (/^mcp_anki(?:-mcp)?_/.test(toolName)) return true;
+  const fields = [
+    payload.tool_name,
+    payload.toolName,
+    payload.name,
+    payload.server_name,
+    payload.serverName,
+    payload.mcp_server_name,
+    payload.mcpServerName,
+    payload.tool?.name,
+  ]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  return /\banki\b/.test(fields);
+}
+
+export function ankiConnectReady(timeoutMs = 800) {
+  return new Promise((resolve) => {
+    const body = JSON.stringify({ action: "version", version: 6 });
+    const request = http.request(
+      ankiConnectUrl,
+      {
+        method: "POST",
+        timeout: timeoutMs,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+        },
+      },
+      (response) => {
+        let text = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          text += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsed = JSON.parse(text || "{}");
+            resolve(response.statusCode === 200 && parsed.error == null && parsed.result != null);
+          } catch {
+            resolve(false);
+          }
+        });
+      },
+    );
+    request.on("timeout", () => {
+      request.destroy();
+      resolve(false);
+    });
+    request.on("error", () => resolve(false));
+    request.write(body);
+    request.end();
+  });
+}
+
+function runProcess(command, args, timeoutMs) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(command, args, { windowsHide: true, stdio: ["ignore", "ignore", "pipe"] });
+    } catch (error) {
+      resolve({ ok: false, message: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill();
+      resolve({ ok: false, timedOut: true, message: stderr.trim() });
+    }, timeoutMs);
+
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({ ok: false, message: error instanceof Error ? error.message : String(error) });
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve({ ok: code === 0, message: stderr.trim() });
+    });
+  });
+}
+
+export async function launchAnki() {
+  if (process.platform === "win32") {
+    const script = String.raw`
+$ErrorActionPreference = "SilentlyContinue"
+$programFilesX86 = [Environment]::GetEnvironmentVariable("ProgramFiles(x86)")
+$paths = @(
+  "$env:LOCALAPPDATA\Programs\Anki\anki.exe",
+  "$env:ProgramFiles\Anki\anki.exe",
+  $(if ($programFilesX86) { Join-Path $programFilesX86 "Anki\anki.exe" })
+)
+$running = (Get-Process -Name "anki" -ErrorAction SilentlyContinue | Select-Object -First 1) -or (Get-Process | Where-Object { $_.MainWindowTitle -match "Anki" } | Select-Object -First 1)
+if (-not $running) {
+  $ankiPath = $paths | Where-Object { $_ -and (Test-Path $_) } | Select-Object -First 1
+  if ($ankiPath) {
+    Start-Process -FilePath $ankiPath -WindowStyle Minimized
+  } else {
+    Write-Error "anki.exe not found in standard paths"
+    exit 2
+  }
+}
+$code = @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32Anki {
+  [DllImport("user32.dll")]
+  [return: MarshalAs(UnmanagedType.Bool)]
+  public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+}
+"@
+try { Add-Type -TypeDefinition $code -ErrorAction SilentlyContinue } catch { }
+
+$stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
+$ankiReady = $false
+$windowMinimized = $false
+$ankiWindow = $null
+while ($stopwatch.Elapsed.TotalSeconds -lt 20) {
+  if (-not $ankiReady) {
+    try {
+      Invoke-RestMethod -Uri "http://127.0.0.1:8765" -Method Get -TimeoutSec 1 -ErrorAction Stop | Out-Null
+      $ankiReady = $true
+    } catch { }
+  }
+
+  if (-not $windowMinimized) {
+    $ankiWindow = Get-Process | Where-Object { $_.MainWindowTitle -match "Anki" -and $_.MainWindowHandle -ne [IntPtr]::Zero } | Select-Object -First 1
+    if ($ankiWindow) {
+      try {
+        [Win32Anki]::ShowWindow($ankiWindow.MainWindowHandle, 6) | Out-Null
+        $windowMinimized = $true
+      } catch { }
+    }
+  }
+
+  if ($ankiReady -and $windowMinimized) {
+    Start-Sleep -Milliseconds 500
+    if ($ankiWindow) {
+      try { [Win32Anki]::ShowWindow($ankiWindow.MainWindowHandle, 6) | Out-Null } catch { }
+    }
+    break
+  }
+  Start-Sleep -Milliseconds 200
+}
+exit 0
+`;
+    const result = await runProcess(
+      "powershell.exe",
+      ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script],
+      ankiStartTimeoutMs + 1000,
+    );
+    if (!result.ok && result.message) console.error(result.message);
+    return result.ok;
+  }
+
+  if (process.platform === "darwin") {
+    const result = await runProcess("open", ["-g", "-j", "-a", "Anki"], 3000);
+    if (!result.ok && result.message) console.error(result.message);
+    return result.ok;
+  }
+
+  try {
+    const child = spawn("anki", [], { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch (error) {
+    console.error(`Could not start Anki: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+
+export async function waitForAnkiConnect(timeoutMs) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (await ankiConnectReady()) return true;
+    await new Promise((resolve) => setTimeout(resolve, 350));
+  }
+  return false;
+}
+
+export async function ensureAnkiBefore(payload) {
+  if (!isAnkiTool(payload)) return quiet();
+  if (await ankiConnectReady()) return quiet();
+  if (!ankiAutoStart) return quiet();
+
+  console.error("AnkiConnect is not ready. Trying a bounded Anki preflight before Anki MCP tool use.");
+  const launched = await launchAnki();
+  const ready = launched ? await waitForAnkiConnect(ankiStartTimeoutMs) : false;
+
+  if (ready) {
+    return {
+      systemMessage: "Anki foi aberto; AnkiConnect esta pronto para usar o MCP.",
+      suppressOutput: true,
+    };
+  }
+
+  return {
+    systemMessage:
+      "AnkiConnect nao respondeu; a ferramenta Anki MCP pode falhar. Abra o Anki Desktop e confira o add-on AnkiConnect.",
+    suppressOutput: true,
+  };
+}

package/.opencode/plugins/mednotes_hook/cli.mjs

@@ -0,0 +1,143 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { normalizePayloadForRuntime, renderAntigravityOutput } from "./adapters/antigravity.mjs";
+import { ensureAnkiBefore } from "./anki_preflight.mjs";
+import { diagnose } from "./diagnostics.mjs";
+import {
+  captureAgentDirectiveAfterTool,
+  guardAgentDirectiveBeforeTool,
+  injectAgentDirectiveBeforeAgent,
+  validateAgentDirectiveAfterAgent,
+} from "./fsm_directive.mjs";
+import { recordHookError } from "./hook_errors.mjs";
+import { quiet, readPayloadResult, writeJson } from "./runtime.mjs";
+import { captureAfterTool } from "./telemetry_capture.mjs";
+import { guardVaultBefore } from "./vault_guard.mjs";
+
+const STATUS_SCHEMA = "medical-notes-workbench.antigravity-hook-status.v1";
+const STATUS_DIR = path.join(appHomeDir(), "antigravity-hooks");
+const STATUS_FILE = path.join(STATUS_DIR, "status.json");
+const HOOK_PLUGIN_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+
+function appHomeDir() {
+  return process.env.MEDNOTES_HOME || path.join(os.homedir(), ".mednotes");
+}
+
+function compactPath(value) {
+  const text = String(value || "");
+  if (!text) return "";
+  const home = os.homedir();
+  return text.startsWith(home) ? `~${text.slice(home.length)}` : text;
+}
+
+async function readStatus() {
+  try {
+    const parsed = JSON.parse(await fs.readFile(STATUS_FILE, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+async function recordHookStatus(mode, payload, output, status = "executed") {
+  try {
+    const previous = await readStatus();
+    const now = new Date().toISOString();
+    const previousByMode = previous.by_mode && typeof previous.by_mode === "object" ? previous.by_mode : {};
+    const previousLast = previous.last_hook && typeof previous.last_hook === "object" ? previous.last_hook : {};
+    const nextByMode = {
+      ...previousByMode,
+      [mode || "unknown"]: Number(previousByMode[mode || "unknown"] || 0) + 1,
+    };
+    const eventName = String(payload?.hook_event_name || "");
+    const toolName = String(payload?.tool_name || "");
+    const cwd = compactPath(payload?.cwd || "");
+    const observedToolName = toolName || String(previousLast.tool_name || "");
+    const observedCwd = cwd || String(previousLast.cwd || "");
+    const next = {
+      schema: STATUS_SCHEMA,
+      status,
+      updated_at: now,
+      total_invocations: Number(previous.total_invocations || 0) + 1,
+      by_mode: nextByMode,
+      last_hook: {
+        mode: mode || "unknown",
+        hook_event_name: eventName,
+        tool_name: observedToolName,
+        decision: String(output?.decision || ""),
+        cwd: observedCwd,
+        plugin_root: compactPath(HOOK_PLUGIN_ROOT),
+        conversation_id_seen: Boolean(payload?.session_id),
+        transcript_path_seen: Boolean(payload?.transcript_path),
+        current_payload_tool_name_seen: Boolean(toolName),
+        current_payload_cwd_seen: Boolean(cwd),
+      },
+      note: "Redacted operational heartbeat only. No command text, note content, raw chat, markdown, HTML, token or secret is stored here.",
+    };
+    await fs.mkdir(STATUS_DIR, { recursive: true });
+    const tmp = `${STATUS_FILE}.tmp`;
+    await fs.writeFile(tmp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    await fs.rename(tmp, STATUS_FILE);
+  } catch {
+    // Hook status is observability only. Never let it change hook behavior.
+  }
+}
+
+export async function dispatch(mode, payload) {
+  if (mode === "ensure-anki-before") return ensureAnkiBefore(payload);
+  if (mode === "guard-vault-before") return guardVaultBefore(payload);
+  if (mode === "capture-after-tool") return captureAfterTool(payload);
+  if (mode === "capture-agent-directive-after-tool") return captureAgentDirectiveAfterTool(payload);
+  if (mode === "inject-agent-directive-before-agent") return injectAgentDirectiveBeforeAgent(payload);
+  if (mode === "guard-agent-directive-before-tool") return guardAgentDirectiveBeforeTool(payload);
+  if (mode === "validate-agent-directive-after-agent") return validateAgentDirectiveAfterAgent(payload);
+  return quiet();
+}
+
+export async function run(argv = process.argv.slice(2)) {
+  const mode = argv[0] || "";
+  if (mode === "diagnose") {
+    writeJson(await diagnose());
+    return;
+  }
+
+  const payloadResult = await readPayloadResult();
+  if (payloadResult.error) {
+    await recordHookError({
+      mode,
+      type: payloadResult.error.type,
+      message: payloadResult.error.message,
+      details: payloadResult.error.details,
+    });
+  }
+  const payload = await normalizePayloadForRuntime(payloadResult.payload, mode);
+  const result = await dispatch(mode, payload);
+  const output = payload.antigravity_payload_seen ? renderAntigravityOutput(mode, result, payload) : result;
+  // Status heartbeat is observability only and fail-open inside recordHookStatus,
+  // but tests and diagnostics depend on it being flushed before the one-shot
+  // hook process exits.
+  await recordHookStatus(mode, payload, output);
+  writeJson(output);
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  try {
+    await run(argv);
+  } catch (error) {
+    await recordHookError({
+      mode: argv[0] || "",
+      type: "hook_main_error",
+      error,
+    });
+    console.error(`mednotes hook failed open: ${error instanceof Error ? error.message : String(error)}`);
+    writeJson(quiet());
+    process.exitCode = 0;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}

package/.opencode/plugins/mednotes_hook/diagnostics.mjs

@@ -0,0 +1,11 @@
+import { ankiAutoStart, ankiConnectUrl, ankiStartTimeoutMs, stdinHardTimeoutMs, stdinTimeoutMs } from "./runtime.mjs";
+
+export async function diagnose() {
+  return {
+    anki_connect_url: ankiConnectUrl,
+    anki_auto_start: ankiAutoStart,
+    stdin_timeout_ms: stdinTimeoutMs,
+    stdin_hard_timeout_ms: stdinHardTimeoutMs,
+    anki_start_timeout_ms: ankiStartTimeoutMs,
+  };
+}