mednotes-opencode 0.1.0

package/.opencode/mednotes/scripts/hooks/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/mednotes/scripts/hooks/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/mednotes/scripts/hooks/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,
+  };
+}

package/.opencode/mednotes/scripts/hooks/mednotes_hook/domain/agent_directive_core.mjs

@@ -0,0 +1,160 @@
+// Pure hook-domain contract logic. This module validates and renders FSM
+// directives, but receives runtime-specific redaction context from adapters.
+export const DIRECTIVE_SCHEMA = "medical-notes-workbench.agent-directive.v1";
+export const WORKFLOW_RUN_RECORD_SCHEMA = "medical-notes-workbench.workflow-run-record.v1";
+export const KNOWN_FSM_SCHEMAS = new Set([
+  "medical-notes-workbench.fix-wiki-fsm-result.v1",
+  "medical-notes-workbench.flashcards-fsm-result.v1",
+  "medical-notes-workbench.link-fsm-result.v1",
+  "medical-notes-workbench.link-related-fsm-result.v1",
+  "medical-notes-workbench.process-chats-fsm-result.v1",
+  "medical-notes-workbench.setup-fsm-result.v1",
+  "medical-notes-workbench.history-fsm-result.v1",
+]);
+const KNOWN_DIRECTIVE_CARRIER_SCHEMAS = new Set([
+  ...KNOWN_FSM_SCHEMAS,
+  "medical-notes-workbench.fix-wiki-agent-stdout-report.v1",
+  "medical-notes-workbench.plan-output-receipt.v1",
+  "medical-notes-workbench.specialist-task-runner-result.v1",
+  "medical-notes-workbench.style-rewrite-atomic-apply-agent-stdout.v1",
+]);
+
+const MAX_CONTEXT_CHARS = 1800;
+
+export function isOfficialWorkflowPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  // Run records are local observability snapshots. They may contain a copied
+  // directive for audit, but they are not the live FSM payload for enforcement.
+  if (String(value.schema || "") === WORKFLOW_RUN_RECORD_SCHEMA) return false;
+  if (!KNOWN_FSM_SCHEMAS.has(String(value.schema || ""))) return false;
+  return isAgentDirective(value.agent_directive);
+}
+
+export function isAgentDirectiveCarrierPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  // Carriers may be official CLI stdout/receipt contracts, but run records stay
+  // observability-only snapshots and must not inject live hook state.
+  if (String(value.schema || "") === WORKFLOW_RUN_RECORD_SCHEMA) return false;
+  if (!KNOWN_DIRECTIVE_CARRIER_SCHEMAS.has(String(value.schema || ""))) return false;
+  return isAgentDirective(value.agent_directive);
+}
+
+export function isAgentDirective(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const control = value.control;
+  const capabilities = control && typeof control === "object" ? control.capabilities : null;
+  if (
+    !(
+      value.schema === DIRECTIVE_SCHEMA &&
+      typeof value.workflow === "string" &&
+      typeof value.run_id === "string" &&
+      control &&
+      typeof control === "object" &&
+      typeof control.status === "string" &&
+      typeof control.state === "string" &&
+      capabilities &&
+      typeof capabilities === "object" &&
+      typeof capabilities.continue === "boolean" &&
+      typeof capabilities.final_report === "boolean"
+    )
+  ) {
+    return false;
+  }
+  return directiveStatusShapeIsValid(control, capabilities);
+}
+
+export function contextFromDirective(directive) {
+  if (!isAgentDirective(directive)) return "";
+  const control = directive.control || {};
+  const capabilities = control.capabilities || {};
+  const effects = Array.isArray(control.effects)
+    ? control.effects
+        .map((effect) => String(effect?.kind || ""))
+        .filter(Boolean)
+        .join(", ")
+    : "";
+  const limits = control.limits && typeof control.limits === "object" ? control.limits : {};
+  const lines = [
+    "MEDNOTES FSM CONTEXT",
+    `workflow: ${safeLine(directive.workflow)}`,
+    `status: ${safeLine(control.status)}`,
+    `state: ${safeLine(control.state)}`,
+    `capabilities: continue=${String(Boolean(capabilities.continue))}; final_report=${String(Boolean(capabilities.final_report))}`,
+  ];
+  if (effects) lines.push(`effects: ${safeLine(effects)}`);
+  lines.push(
+    `limits: raw_content=${String(limits.raw_content !== false)}; absolute_paths=${String(limits.absolute_paths !== false)}; ad_hoc_scripts=${String(limits.ad_hoc_scripts !== false)}`,
+  );
+  const resume = safeLine(control.resume || "");
+  if (resume) lines.push(`resume: ${resume}`);
+  for (const instruction of Array.isArray(directive.instructions) ? directive.instructions.slice(0, 12) : []) {
+    const line = safeLine(instruction);
+    if (line) lines.push(`instruction: ${line}`);
+  }
+  const context = lines.join("\n");
+  return context.length <= MAX_CONTEXT_CHARS ? context : `${context.slice(0, MAX_CONTEXT_CHARS - 3).trimEnd()}...`;
+}
+
+export function contextFromWorkflowIntent(intent) {
+  const workflow = safeLine(intent?.workflow || "");
+  if (!workflow) return "";
+  const lines = [
+    "MEDNOTES WORKFLOW INTENT",
+    `workflow: ${workflow}`,
+    "stage: before_workflow_payload",
+    "instruction: load only the official packaged workflow skill if needed.",
+    "instruction: follow the official public workflow route, then wait for official JSON.",
+    "instruction: do not probe permissions, list directories, call MCP, invoke subagents, schedule timers or self-debug before the workflow payload.",
+    "instruction: if a tool schema fails, retry the same necessary tool without invented metadata arguments.",
+  ];
+  const context = lines.join("\n");
+  return context.length <= MAX_CONTEXT_CHARS ? context : `${context.slice(0, MAX_CONTEXT_CHARS - 3).trimEnd()}...`;
+}
+
+export function controlStatus(directive) {
+  return String(directive?.control?.status || "");
+}
+
+export function directiveAllowsFinalReport(directive) {
+  return isAgentDirective(directive) && Boolean(directive?.control?.capabilities?.final_report);
+}
+
+export function directiveAllowsPauseReport(directive) {
+  const capabilities = directive?.control?.capabilities;
+  if (capabilities?.continue !== false) return false;
+  const status = controlStatus(directive);
+  return status === "waiting_external" || status === "waiting_human" || status === "blocked" || status === "failed";
+}
+
+export function limitIsFalse(directive, name) {
+  return directive?.control?.limits?.[name] === false;
+}
+
+function safeLine(value) {
+  return String(value || "")
+    .replace(/\s+/g, " ")
+    .replace(/\/(?:private\/)?(?:var|tmp|Users|home)\/[^\s]+/g, "[path]")
+    .slice(0, 240)
+    .trim();
+}
+
+function directiveStatusShapeIsValid(control, capabilities) {
+  const status = String(control.status || "");
+  const effects = Array.isArray(control.effects) ? control.effects : [];
+  const blockers = Array.isArray(control.blockers)
+    ? control.blockers.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+  const resume = String(control.resume || "").trim();
+  if (status === "waiting_agent") {
+    if (capabilities.continue !== true) return false;
+    if (capabilities.final_report !== false) return false;
+    if (!effects.length) return false;
+  }
+  if (status === "completed" || status === "completed_with_warnings") {
+    if (capabilities.final_report !== true) return false;
+  }
+  if (["waiting_human", "waiting_external", "blocked", "failed"].includes(status)) {
+    if (!blockers.length && !resume) return false;
+  }
+  return true;
+}