@cubocompany/opengem 0.1.0

package/dist/index.js

@@ -0,0 +1,1636 @@
+// src/index.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/lib/shell.ts
+function makeBunSpawnShell() {
+  return async (cmd) => {
+    try {
+      const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      const exitCode = await proc.exited;
+      return { exitCode, stdout, stderr };
+    } catch (err) {
+      return { exitCode: 127, stdout: "", stderr: String(err) };
+    }
+  };
+}
+
+// src/lib/commands.ts
+var TOOL_MANIFEST = {
+  obsidian_read: {
+    label: "Read Obsidian Note",
+    description: "Read an Obsidian note by file name or path",
+    futureSlashCommand: "obsidian.read"
+  },
+  obsidian_search: {
+    label: "Search Obsidian Vault",
+    description: "Search vault content by query string",
+    futureSlashCommand: "obsidian.search"
+  },
+  obsidian_create_note: {
+    label: "Create Obsidian Note",
+    description: "Create a new note in a vault",
+    futureSlashCommand: "obsidian.create"
+  },
+  obsidian_append_note: {
+    label: "Append to Obsidian Note",
+    description: "Append text to an existing note",
+    futureSlashCommand: "obsidian.append"
+  },
+  obsidian_set_property: {
+    label: "Set Obsidian Note Property",
+    description: "Set a frontmatter property on a note",
+    futureSlashCommand: "obsidian.property.set"
+  },
+  obsidian_skills_check: {
+    label: "Check Obsidian Skills",
+    description: "Validate that required Obsidian skills are discoverable by OpenCode",
+    futureSlashCommand: "obsidian.skills.check"
+  },
+  obsidian_env_doctor: {
+    label: "Obsidian Environment Doctor",
+    description: "Run environment diagnostics: CLI installed, app running, skills synced",
+    futureSlashCommand: "obsidian.env.doctor"
+  },
+  obsidian_backlinks: {
+    label: "List Backlinks",
+    description: "List all notes that link to a given note path",
+    futureSlashCommand: "obsidian.backlinks"
+  },
+  obsidian_tags: {
+    label: "List Tags",
+    description: "List all tags in the vault, or tags on a specific note",
+    futureSlashCommand: "obsidian.tags"
+  },
+  obsidian_tag_notes: {
+    label: "Notes by Tag",
+    description: "List all notes that use a specific tag",
+    futureSlashCommand: "obsidian.tag.notes"
+  },
+  obsidian_plugins: {
+    label: "List Plugins",
+    description: "List all installed Obsidian plugins",
+    futureSlashCommand: "obsidian.plugins"
+  },
+  obsidian_plugin_reload: {
+    label: "Reload Plugin",
+    description: "Reload an Obsidian plugin by ID without restarting the app",
+    futureSlashCommand: "obsidian.plugin.reload"
+  },
+  obsidian_dev_errors: {
+    label: "Dev: Recent Errors",
+    description: "Get recent JavaScript errors from the running Obsidian app",
+    futureSlashCommand: "obsidian.dev.errors"
+  },
+  obsidian_dev_console: {
+    label: "Dev: Console Capture",
+    description: "Start/stop debug capture or retrieve console output from the running app",
+    futureSlashCommand: "obsidian.dev.console"
+  },
+  obsidian_dev_screenshot: {
+    label: "Dev: Screenshot",
+    description: "Capture a screenshot of the running Obsidian app to a vault path (PNG)",
+    futureSlashCommand: "obsidian.dev.screenshot"
+  },
+  obsidian_dev_dom: {
+    label: "Dev: DOM Inspector",
+    description: "Inspect DOM elements by CSS selector (text, count, attribute, or computed CSS)",
+    futureSlashCommand: "obsidian.dev.dom"
+  },
+  obsidian_dev_css: {
+    label: "Dev: CSS Inspector",
+    description: "Inspect computed CSS properties by CSS selector",
+    futureSlashCommand: "obsidian.dev.css"
+  },
+  obsidian_wiki_init: {
+    label: "Wiki: Initialize",
+    description: "Set up the wiki folder structure (raw/, wiki/, schema/) with SCHEMA.md, INDEX.md, and LOG.md. Run once per vault to get started.",
+    futureSlashCommand: "obsidian.wiki.init"
+  },
+  obsidian_wiki_ingest: {
+    label: "Wiki: Ingest Source",
+    description: "Copy a source document into raw/ and create or update its wiki/ page",
+    futureSlashCommand: "obsidian.wiki.ingest"
+  },
+  obsidian_wiki_update: {
+    label: "Wiki: Update Page",
+    description: "Create or overwrite a wiki/ knowledge page",
+    futureSlashCommand: "obsidian.wiki.update"
+  },
+  obsidian_wiki_refresh_index: {
+    label: "Wiki: Refresh Index",
+    description: "Rebuild wiki/INDEX.md with links to all wiki pages",
+    futureSlashCommand: "obsidian.wiki.refresh-index"
+  },
+  obsidian_wiki_search_cited: {
+    label: "Wiki: Search with Citations",
+    description: "Search wiki/ content and return results with source citations",
+    futureSlashCommand: "obsidian.wiki.search-cited"
+  },
+  obsidian_wiki_save_answer: {
+    label: "Wiki: Save Answer",
+    description: "Save a Q&A answer as a note in wiki/answers/",
+    futureSlashCommand: "obsidian.wiki.save-answer"
+  },
+  obsidian_wiki_lint: {
+    label: "Wiki: Health Check",
+    description: "Detect broken wikilinks, orphan pages, and missing index entries in wiki/",
+    futureSlashCommand: "obsidian.wiki.lint"
+  },
+  obsidian_eval: {
+    label: "Eval (opt-in)",
+    description: "Execute JavaScript in the Obsidian app context. Requires evalEnabled in plugin config.",
+    futureSlashCommand: "obsidian.eval"
+  }
+};
+
+// src/lib/config.ts
+function resolvePluginConfig(input) {
+  return {
+    defaultVault: input.defaultVault ?? null,
+    skills: {
+      mode: input.skills?.mode ?? "external",
+      externalPath: input.skills?.externalPath ?? null,
+      syncDirName: input.skills?.syncDirName ?? "obsidian-opencode-plugin-bundled"
+    },
+    wiki: {
+      rawDir: input.wiki?.rawDir ?? "raw",
+      wikiDir: input.wiki?.wikiDir ?? "wiki",
+      schemaDir: input.wiki?.schemaDir ?? "schema"
+    },
+    evalEnabled: input.evalEnabled ?? false
+  };
+}
+function resolveVault(args) {
+  if (args.inputVault)
+    return args.inputVault;
+  if (args.config.defaultVault)
+    return args.config.defaultVault;
+  if (args.action === "read")
+    return args.activeVault;
+  return null;
+}
+
+// src/lib/capabilities.ts
+async function detectCli(which) {
+  return which();
+}
+async function detectApp(ping) {
+  return ping();
+}
+
+// src/lib/skills.ts
+var {existsSync} = (() => ({}));
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// src/lib/skills.ts
+async function detectSkillsState(args) {
+  const exists = args.exists ?? existsSync;
+  if (args.explicitPath) {
+    return { mode: "external", path: args.explicitPath };
+  }
+  const bundledPath = join(args.homeDir, ".opencode", "skills", args.syncDirName);
+  if (args.mode === "bundled") {
+    return { mode: "bundled", path: bundledPath };
+  }
+  const externalDefault = join(args.homeDir, ".opencode", "skills", "obsidian-skills");
+  return {
+    mode: args.mode,
+    path: exists(externalDefault) ? externalDefault : bundledPath
+  };
+}
+
+// src/lib/wiki.ts
+function resolveWikiPaths(args) {
+  const raw = args.rawDir ?? "raw";
+  const wiki = args.wikiDir ?? "wiki";
+  const schema = args.schemaDir ?? "schema";
+  return {
+    vault: args.vault,
+    raw,
+    wiki,
+    schema,
+    answers: `${wiki}/answers`,
+    index: `${wiki}/INDEX.md`
+  };
+}
+function buildIndexMarkdown(pages) {
+  const sorted = [...pages].sort();
+  const now = new Date().toISOString();
+  const links = sorted.map((p) => {
+    const name = p.replace(/^wiki\//, "").replace(/\.md$/, "");
+    return `- [[${name}]]`;
+  }).join(`
+`);
+  return `# Wiki Index
+
+> generated: ${now}
+
+${links}
+`;
+}
+function buildLogEntry(operation, args) {
+  const now = new Date().toISOString().replace("T", " ").slice(0, 16);
+  const lines = [`
+## ${now} — ${operation}`];
+  if (args.source)
+    lines.push(`- Source: ${args.source}`);
+  if (args.files?.length)
+    lines.push(`- Files touched: ${args.files.map((f) => `[[${f}]]`).join(", ")}`);
+  if (args.notes)
+    lines.push(`- Notes: ${args.notes}`);
+  return lines.join(`
+`) + `
+`;
+}
+function detectBrokenLinks(pages, links) {
+  const pageNames = new Set(pages.map((p) => p.replace(/^wiki\//, "").replace(/\.md$/, "")));
+  const broken = [];
+  for (const [source, sourceLinks] of Object.entries(links)) {
+    for (const link of sourceLinks) {
+      const name = link.replace(/^\[\[/, "").replace(/\]\]$/, "").split("|")[0].trim();
+      if (!pageNames.has(name)) {
+        broken.push({ source, link });
+      }
+    }
+  }
+  return broken;
+}
+
+// node:os
+var homedir = function() {
+  return "/";
+};
+
+// src/lib/cli.ts
+function buildObsidianArgs(command, args) {
+  if (args.file && args.path)
+    throw new Error("MUTUALLY_EXCLUSIVE_TARGET");
+  const flags = Object.entries(args).filter(([, value]) => value !== undefined && value !== null).flatMap(([key, value]) => {
+    if (typeof value === "boolean")
+      return value ? [key] : [];
+    return [`${key}=${String(value)}`];
+  });
+  return [command, ...flags];
+}
+function errorResult(code, message, hint, command = "", args = {}, requiredCapabilities = [], checkedCapabilities = []) {
+  return {
+    schemaVersion: "1.0",
+    ok: false,
+    command,
+    args,
+    requiredCapabilities,
+    checkedCapabilities,
+    data: null,
+    stdout: "",
+    stderr: "",
+    exitCode: 1,
+    hint,
+    error: { code, kind: "capability", message }
+  };
+}
+async function executeObsidianCli(shell, command, args, meta) {
+  const built = buildObsidianArgs(command, args);
+  const result = await shell(["obsidian", ...built]);
+  const mappedError = result.exitCode === 0 ? null : meta.mapError?.({ exitCode: result.exitCode, stderr: result.stderr }) ?? (result.exitCode === 127 ? { code: "CLI_NOT_FOUND", kind: "capability", message: "obsidian CLI is not installed or not on PATH" } : { code: "COMMAND_NOT_ENABLED", kind: "runtime", message: result.stderr || "CLI command failed" });
+  return {
+    schemaVersion: "1.0",
+    ok: result.exitCode === 0,
+    command: `obsidian_${command.replace(":", "_")}`,
+    args,
+    requiredCapabilities: meta.requiredCapabilities,
+    checkedCapabilities: meta.checkedCapabilities,
+    data: null,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode,
+    hint: result.exitCode === 0 ? null : "Ask OpenCode to use obsidian_env_doctor",
+    error: mappedError
+  };
+}
+
+// src/lib/tool-inputs.ts
+function ensureSingleTarget(input) {
+  if (!input.file && !input.path)
+    throw new Error("FILE_OR_PATH_REQUIRED");
+  if (input.file && input.path)
+    throw new Error("MUTUALLY_EXCLUSIVE_TARGET");
+}
+
+// src/tools/read.ts
+async function runReadTool(args) {
+  try {
+    ensureSingleTarget(args.input);
+  } catch (err) {
+    const code = err.message;
+    return errorResult(code, err.message, "Provide exactly one of file or path", "obsidian_read", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const result = await executeObsidianCli(args.shell, "read", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app", "vault"]
+  });
+  return {
+    ...result,
+    data: {
+      target: {
+        file: args.input.file ?? null,
+        path: args.input.path ?? null,
+        vault: args.input.vault ?? null
+      },
+      content: result.stdout
+    }
+  };
+}
+
+// src/tools/search.ts
+async function runSearchTool(args) {
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({
+    action: "read",
+    inputVault: args.input.vault ?? null,
+    activeVault: args.activeVault,
+    config
+  });
+  const cliArgs = { ...args.input, ...vault ? { vault } : {} };
+  const result = await executeObsidianCli(args.shell, "search", cliArgs, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app", "vault"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { query: args.input.query, results: result.stdout } : null
+  };
+}
+
+// src/tools/create-note.ts
+async function runCreateNoteTool(args) {
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({
+    action: "write",
+    inputVault: args.input.vault ?? null,
+    activeVault: args.activeVault,
+    config
+  });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_create_note", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const result = await executeObsidianCli(args.shell, "create", { ...args.input, vault }, {
+    requiredCapabilities: ["cli", "app", "vault"],
+    checkedCapabilities: ["cli", "app", "vault"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { name: args.input.name, created: true, opened: !args.input.silent } : null
+  };
+}
+
+// src/tools/append-note.ts
+async function runAppendNoteTool(args) {
+  try {
+    ensureSingleTarget(args.input);
+  } catch (err) {
+    const code = err.message;
+    return errorResult(code, err.message, "Provide exactly one of file or path", "obsidian_append_note", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({
+    action: "write",
+    inputVault: args.input.vault ?? null,
+    activeVault: args.activeVault,
+    config
+  });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_append_note", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const result = await executeObsidianCli(args.shell, "append", { ...args.input, vault }, {
+    requiredCapabilities: ["cli", "app", "vault"],
+    checkedCapabilities: ["cli", "app", "vault"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { target: { file: args.input.file ?? null, path: args.input.path ?? null }, appended: true } : null
+  };
+}
+
+// src/tools/set-property.ts
+async function runSetPropertyTool(args) {
+  try {
+    ensureSingleTarget(args.input);
+  } catch (err) {
+    const code = err.message;
+    return errorResult(code, err.message, "Provide exactly one of file or path", "obsidian_set_property", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({
+    action: "write",
+    inputVault: args.input.vault ?? null,
+    activeVault: args.activeVault,
+    config
+  });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_set_property", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const result = await executeObsidianCli(args.shell, "property:set", { ...args.input, vault }, {
+    requiredCapabilities: ["cli", "app", "vault"],
+    checkedCapabilities: ["cli", "app", "vault"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { property: args.input.name, value: args.input.value, updated: true } : null
+  };
+}
+
+// src/tools/skills-check.ts
+var {existsSync: existsSync2} = (() => ({}));
+async function runSkillsCheck(args) {
+  const exists = args.exists ?? existsSync2;
+  const found = [];
+  const missing = [];
+  for (const skill of args.requiredSkills) {
+    if (exists(join(args.skillsPath, skill, "SKILL.md"))) {
+      found.push(skill);
+    } else {
+      missing.push(skill);
+    }
+  }
+  const ok = missing.length === 0;
+  return {
+    schemaVersion: "1.0",
+    ok,
+    command: "obsidian_skills_check",
+    args: { mode: args.mode },
+    requiredCapabilities: [],
+    checkedCapabilities: ["skills"],
+    data: {
+      mode: args.mode,
+      skillsPath: args.skillsPath,
+      found,
+      missing
+    },
+    stdout: "",
+    stderr: "",
+    exitCode: ok ? 0 : 1,
+    hint: ok ? null : "Run obsidian_env_doctor or bun run sync:skills to fix missing skills",
+    error: ok ? null : {
+      code: "BUNDLED_SKILLS_OUT_OF_SYNC",
+      kind: "capability",
+      message: `Missing skills: ${missing.join(", ")}`
+    }
+  };
+}
+
+// src/tools/env-doctor.ts
+async function runEnvDoctor(args) {
+  const [cliInstalled, appRunning, skills] = await Promise.all([
+    args.detectCli(),
+    args.detectApp(),
+    args.detectSkills()
+  ]);
+  return {
+    schemaVersion: "1.0",
+    ok: true,
+    command: "obsidian_env_doctor",
+    args: {},
+    requiredCapabilities: [],
+    checkedCapabilities: ["cli", "app", "skills"],
+    data: {
+      cliInstalled,
+      appRunning,
+      defaultVault: args.defaultVault,
+      skills
+    },
+    stdout: "",
+    stderr: "",
+    exitCode: 0,
+    hint: null,
+    error: null
+  };
+}
+
+// src/tools/backlinks.ts
+async function runBacklinksTool(args) {
+  if (!args.input.path) {
+    return errorResult("INVALID_ARGS", "path is required", "Provide the note path", "obsidian_backlinks", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const result = await executeObsidianCli(args.shell, "backlinks", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { path: args.input.path, backlinks: result.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean) } : null
+  };
+}
+
+// src/tools/tags.ts
+async function runTagsTool(args) {
+  const result = await executeObsidianCli(args.shell, "tags", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { tags: result.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean) } : null
+  };
+}
+
+// src/tools/tag-notes.ts
+async function runTagNotesTool(args) {
+  if (!args.input.name) {
+    return errorResult("INVALID_ARGS", "name is required", "Provide a tag name", "obsidian_tag_notes", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const result = await executeObsidianCli(args.shell, "tag", { ...args.input, verbose: true }, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { tag: args.input.name, notes: result.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean) } : null
+  };
+}
+
+// src/tools/plugins.ts
+async function runPluginsTool(args) {
+  const result = await executeObsidianCli(args.shell, "plugins", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { plugins: result.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean) } : null
+  };
+}
+
+// src/tools/plugin-reload.ts
+async function runPluginReloadTool(args) {
+  if (!args.input.id) {
+    return errorResult("INVALID_ARGS", "id is required", "Provide a plugin id", "obsidian_plugin_reload", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const result = await executeObsidianCli(args.shell, "plugin:reload", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { id: args.input.id, reloaded: true } : null
+  };
+}
+
+// src/tools/dev-errors.ts
+async function runDevErrorsTool(args) {
+  const result = await executeObsidianCli(args.shell, "dev:errors", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return {
+    ...result,
+    data: result.ok ? { errors: result.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean) } : null
+  };
+}
+
+// src/tools/dev-console.ts
+async function runDevConsoleTool(args) {
+  const { action, limit } = args.input;
+  if (action !== "start" && action !== "stop" && action !== "get") {
+    return errorResult("INVALID_ARGS", "action must be start, stop, or get", "Use start, stop, or get", "obsidian_dev_console", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  if (action === "get") {
+    const cliArgs = limit !== undefined ? { limit } : {};
+    const result2 = await executeObsidianCli(args.shell, "dev:console", cliArgs, {
+      requiredCapabilities: ["cli", "app"],
+      checkedCapabilities: ["cli", "app"]
+    });
+    return { ...result2, data: result2.ok ? { action: "get", output: result2.stdout } : null };
+  }
+  const onOff = action === "start" ? "on" : "off";
+  const shell = args.shell;
+  const result = await executeObsidianCli(async (cmd) => shell([...cmd, onOff]), "dev:debug", {}, { requiredCapabilities: ["cli", "app"], checkedCapabilities: ["cli", "app"] });
+  return { ...result, data: result.ok ? { action } : null };
+}
+
+// src/tools/dev-screenshot.ts
+async function runDevScreenshotTool(args) {
+  if (!args.input.path) {
+    return errorResult("INVALID_ARGS", "path is required", "Provide output path inside the vault", "obsidian_dev_screenshot", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "write", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_dev_screenshot", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const result = await executeObsidianCli(args.shell, "dev:screenshot", { path: args.input.path, vault }, {
+    requiredCapabilities: ["cli", "app", "vault"],
+    checkedCapabilities: ["cli", "app", "vault"]
+  });
+  return { ...result, data: result.ok ? { path: args.input.path, vault } : null };
+}
+
+// src/tools/dev-dom.ts
+async function runDevDomTool(args) {
+  if (!args.input.selector) {
+    return errorResult("INVALID_ARGS", "selector is required", "Provide a CSS selector", "obsidian_dev_dom", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const { selector, mode, attr, css } = args.input;
+  const cliArgs = { selector };
+  if (mode && ["text", "all", "total"].includes(mode))
+    cliArgs[mode] = true;
+  if (attr)
+    cliArgs["attr"] = attr;
+  if (css)
+    cliArgs["css"] = css;
+  const result = await executeObsidianCli(args.shell, "dev:dom", cliArgs, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return { ...result, data: result.ok ? { selector, output: result.stdout } : null };
+}
+
+// src/tools/dev-css.ts
+async function runDevCssTool(args) {
+  if (!args.input.selector) {
+    return errorResult("INVALID_ARGS", "selector is required", "Provide a CSS selector", "obsidian_dev_css", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const result = await executeObsidianCli(args.shell, "dev:css", args.input, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return { ...result, data: result.ok ? { selector: args.input.selector, prop: args.input.prop, output: result.stdout } : null };
+}
+
+// src/lib/vault.ts
+async function detectActiveVault(shell) {
+  const result = await shell(["obsidian", "vault"]);
+  if (result.exitCode !== 0 || !result.stdout.trim())
+    return null;
+  const lines = result.stdout.trim().split(`
+`);
+  const name = lines.find((l) => l.startsWith("name\t"))?.replace("name\t", "").trim();
+  const path = lines.find((l) => l.startsWith("path\t"))?.replace("path\t", "").trim();
+  if (!name)
+    return null;
+  return { name, path: path ?? "" };
+}
+async function listVaults(shell) {
+  const result = await shell(["obsidian", "vaults"]);
+  if (result.exitCode !== 0 || !result.stdout.trim())
+    return [];
+  return result.stdout.trim().split(`
+`).flatMap((line) => {
+    const parts = line.split("\t");
+    const name = parts[0]?.trim();
+    const path = parts[1]?.trim();
+    return name ? [{ name, path: path ?? "" }] : [];
+  });
+}
+
+// src/tools/wiki-init.ts
+var SCHEMA_MD = `# Wiki Schema
+
+This wiki follows the LLM Wiki pattern: a persistent, compounding knowledge base
+maintained by an LLM agent across three layers.
+
+## Folder structure
+
+\`\`\`
+raw/          — Immutable source documents (articles, papers, notes)
+wiki/         — Synthesized knowledge pages (one topic per file)
+wiki/answers/ — Filed answers to past queries
+schema/       — This file and other structural conventions
+\`\`\`
+
+## Special files
+
+- \`wiki/INDEX.md\` — Content catalog, auto-generated by obsidian_wiki_refresh_index
+- \`wiki/LOG.md\`   — Append-only record of all ingests and queries
+
+## Wiki page conventions
+
+- One topic per file, named clearly (e.g. \`Transformers.md\`, \`OpenAI.md\`)
+- Start with a one-paragraph summary
+- Use \`## Sections\` for subtopics
+- Cross-reference with \`[[Page Name]]\` wikilinks
+- Cite sources with \`> Source: [[raw/filename]]\`
+- Prefer updating existing pages over creating new ones
+
+## Operations
+
+**Ingest** (obsidian_wiki_ingest)
+1. Save raw source to \`raw/\`
+2. Read existing related wiki pages
+3. Update or create wiki pages — typically 2-10 files per ingest
+4. Append entry to \`wiki/LOG.md\`
+
+**Query** (obsidian_wiki_search_cited + obsidian_wiki_save_answer)
+1. Search wiki for relevant pages
+2. Synthesize answer citing wiki sources
+3. File the answer to \`wiki/answers/\` if it adds new knowledge
+
+**Lint** (obsidian_wiki_lint + obsidian_wiki_refresh_index)
+1. Find broken links, orphan pages, index gaps
+2. Refresh INDEX.md
+3. Fix issues found
+
+## Log format
+
+Each LOG.md entry:
+\`\`\`
+## YYYY-MM-DD HH:MM — <operation>
+- Source: <name or query>
+- Files touched: [[page1]], [[page2]]
+- Notes: <optional>
+\`\`\`
+`;
+function logEntry(operation, vault) {
+  const now = new Date().toISOString().replace("T", " ").slice(0, 16);
+  return `
+## ${now} — ${operation}
+- Vault: ${vault}
+- Notes: Wiki initialized
+`;
+}
+async function runWikiInitTool(args) {
+  let vault = null;
+  let vaultPath = "";
+  let detectedFrom = "explicit";
+  if (args.input.vault) {
+    vault = args.input.vault;
+    detectedFrom = "explicit";
+  } else if (args.defaultVault) {
+    vault = args.defaultVault;
+    detectedFrom = "config";
+  } else {
+    const active = await detectActiveVault(args.shell);
+    if (active) {
+      vault = active.name;
+      vaultPath = active.path;
+      detectedFrom = "active";
+    } else {
+      const all = await listVaults(args.shell);
+      if (all.length === 1) {
+        vault = all[0].name;
+        vaultPath = all[0].path;
+        detectedFrom = "only-vault";
+      }
+    }
+  }
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Could not detect a vault automatically. Please provide vault name.", "Pass vault='My Vault' or set defaultVault in plugin config", "obsidian_wiki_init", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const force = args.input.force ?? false;
+  const created = [];
+  const skipped = [];
+  const files = [
+    {
+      name: `${args.wikiPaths.schema}/SCHEMA.md`,
+      content: SCHEMA_MD,
+      overwrite: force
+    },
+    {
+      name: args.wikiPaths.index,
+      content: `# Wiki Index
+
+> Run obsidian_wiki_refresh_index to populate this file.
+`,
+      overwrite: force
+    },
+    {
+      name: `${args.wikiPaths.wiki}/LOG.md`,
+      content: `# Wiki Log
+
+Append-only record of all ingests, queries, and maintenance.
+${logEntry("init", vault)}`,
+      overwrite: false
+    },
+    {
+      name: `${args.wikiPaths.raw}/.keep`,
+      content: `# Raw sources folder — do not edit files here manually
+`,
+      overwrite: false
+    }
+  ];
+  for (const file of files) {
+    const result = await executeObsidianCli(args.shell, "create", { name: file.name, content: file.content, vault, overwrite: file.overwrite }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+    if (result.ok) {
+      created.push(file.name);
+    } else if (result.exitCode !== 0 && !file.overwrite) {
+      skipped.push(file.name);
+    } else {
+      return { ...result, data: null };
+    }
+  }
+  return {
+    schemaVersion: "1.0",
+    ok: true,
+    command: "obsidian_wiki_init",
+    args: args.input,
+    requiredCapabilities: ["cli", "app", "vault"],
+    checkedCapabilities: ["cli", "app", "vault"],
+    data: { vault, vaultPath, created, skipped, detectedFrom },
+    stdout: "",
+    stderr: "",
+    exitCode: 0,
+    hint: skipped.length > 0 ? "Some files already existed and were skipped. Use force:true to overwrite." : null,
+    error: null
+  };
+}
+
+// src/tools/wiki-ingest.ts
+async function runWikiIngestTool(args) {
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "write", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_wiki_ingest", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const rawName = `${args.wikiPaths.raw}/${args.input.sourceName}`;
+  const wikiName = `${args.wikiPaths.wiki}/${args.input.sourceName}`;
+  const rawResult = await executeObsidianCli(args.shell, "create", { name: rawName, content: args.input.sourceContent, vault, overwrite: false }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+  if (!rawResult.ok)
+    return { ...rawResult, data: null };
+  const wikiResult = await executeObsidianCli(args.shell, "create", { name: wikiName, content: args.input.wikiContent, vault, overwrite: true }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+  if (!wikiResult.ok)
+    return { ...wikiResult, data: null };
+  const logContent = buildLogEntry("ingest", {
+    source: args.input.sourceName,
+    files: [rawName, wikiName]
+  });
+  await executeObsidianCli(args.shell, "append", { path: `${args.wikiPaths.wiki}/LOG.md`, content: logContent, vault }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] }).catch(() => {});
+  return { ...wikiResult, data: { rawPath: rawName, wikiPath: wikiName, vault } };
+}
+
+// src/tools/wiki-update.ts
+async function runWikiUpdateTool(args) {
+  if (!args.input.pageName) {
+    return errorResult("INVALID_ARGS", "pageName is required", "Provide a wiki page name", "obsidian_wiki_update", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "write", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_wiki_update", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const path = `${args.wikiPaths.wiki}/${args.input.pageName}`;
+  const result = await executeObsidianCli(args.shell, "create", { name: path, content: args.input.content, vault, overwrite: true }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+  return { ...result, data: result.ok ? { path, vault, updated: true } : null };
+}
+
+// src/tools/wiki-refresh-index.ts
+async function runWikiRefreshIndexTool(args) {
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "write", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_wiki_refresh_index", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const searchResult = await executeObsidianCli(args.shell, "files", { folder: args.wikiPaths.wiki, ext: "md", vault }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+  if (!searchResult.ok)
+    return { ...searchResult, data: null };
+  const pages = searchResult.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const indexContent = buildIndexMarkdown(pages);
+  const writeResult = await executeObsidianCli(args.shell, "create", { name: args.wikiPaths.index, content: indexContent, vault, overwrite: true }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+  return { ...writeResult, data: writeResult.ok ? { indexPath: args.wikiPaths.index, pageCount: pages.length, vault } : null };
+}
+
+// src/tools/wiki-search-cited.ts
+async function runWikiSearchCitedTool(args) {
+  if (!args.input.query) {
+    return errorResult("INVALID_ARGS", "query is required", "Provide a search query", "obsidian_wiki_search_cited", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "read", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  const cliArgs = { query: args.input.query, path: args.wikiPaths.wiki };
+  if (args.input.limit)
+    cliArgs["limit"] = args.input.limit;
+  if (vault)
+    cliArgs["vault"] = vault;
+  const result = await executeObsidianCli(args.shell, "search", cliArgs, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return { ...result, data: result.ok ? { query: args.input.query, results: result.stdout } : null };
+}
+
+// src/tools/wiki-save-answer.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+async function runWikiSaveAnswerTool(args) {
+  if (!args.input.question) {
+    return errorResult("INVALID_ARGS", "question is required", "Provide a question", "obsidian_wiki_save_answer", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "write", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  if (!vault) {
+    return errorResult("VAULT_REQUIRED", "Write commands require a vault", "Pass vault or configure defaultVault", "obsidian_wiki_save_answer", args.input, ["cli", "app", "vault"], ["cli", "app", "vault"]);
+  }
+  const slug = slugify(args.input.question);
+  const path = `${args.wikiPaths.answers}/${slug}`;
+  const tags = args.input.tags?.length ? `
+tags: [${args.input.tags.join(", ")}]` : "";
+  const content = `---
+question: "${args.input.question}"${tags}
+---
+
+${args.input.answer}
+`;
+  const result = await executeObsidianCli(args.shell, "create", { name: path, content, vault, overwrite: false }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] });
+  if (!result.ok)
+    return { ...result, data: null };
+  const logContent = buildLogEntry("query", {
+    source: args.input.question,
+    files: [path]
+  });
+  await executeObsidianCli(args.shell, "append", { path: `${args.wikiPaths.wiki}/LOG.md`, content: logContent, vault }, { requiredCapabilities: ["cli", "app", "vault"], checkedCapabilities: ["cli", "app", "vault"] }).catch(() => {});
+  return { ...result, data: { path, vault } };
+}
+
+// src/tools/wiki-lint.ts
+async function runWikiLintTool(args) {
+  const config = resolvePluginConfig({ defaultVault: args.defaultVault });
+  const vault = resolveVault({ action: "read", inputVault: args.input.vault ?? null, activeVault: args.activeVault, config });
+  const searchResult = await executeObsidianCli(args.shell, "files", { folder: args.wikiPaths.wiki, ext: "md", ...vault ? { vault } : {} }, { requiredCapabilities: ["cli", "app"], checkedCapabilities: ["cli", "app"] });
+  const pages = searchResult.ok ? searchResult.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean) : [];
+  const links = args.readLinks ? await args.readLinks() : {};
+  const indexContent = args.readIndex ? await args.readIndex() : "";
+  const brokenLinks = detectBrokenLinks(pages, links);
+  const indexedNames = new Set((indexContent.match(/\[\[([^\]]+)\]\]/g) ?? []).map((l) => l.replace(/^\[\[/, "").replace(/\]\]$/, "").split("|")[0].trim()));
+  const orphanPages = pages.filter((p) => {
+    const name = p.replace(/^wiki\//, "").replace(/\.md$/, "");
+    return !indexedNames.has(name);
+  });
+  const pageNames = new Set(pages.map((p) => p.replace(/^wiki\//, "").replace(/\.md$/, "")));
+  const missingIndexEntries = [...indexedNames].filter((n) => !pageNames.has(n));
+  return {
+    schemaVersion: "1.0",
+    ok: true,
+    command: "obsidian_wiki_lint",
+    args: args.input,
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"],
+    data: { pageCount: pages.length, brokenLinks, orphanPages, missingIndexEntries },
+    stdout: "",
+    stderr: "",
+    exitCode: 0,
+    hint: brokenLinks.length > 0 || orphanPages.length > 0 ? "Run obsidian_wiki_refresh_index to fix index issues" : null,
+    error: null
+  };
+}
+
+// src/tools/eval.ts
+async function runEvalTool(args) {
+  if (!args.evalEnabled) {
+    return errorResult("EVAL_DISABLED", "obsidian_eval is disabled", "Set evalEnabled: true in plugin options to opt in", "obsidian_eval", args.input, ["cli", "app"], []);
+  }
+  if (!args.input.code) {
+    return errorResult("INVALID_ARGS", "code is required", "Provide JavaScript code to evaluate", "obsidian_eval", args.input, ["cli", "app"], ["cli", "app"]);
+  }
+  const result = await executeObsidianCli(args.shell, "eval", { code: args.input.code }, {
+    requiredCapabilities: ["cli", "app"],
+    checkedCapabilities: ["cli", "app"]
+  });
+  return { ...result, data: result.ok ? { result: result.stdout } : null };
+}
+
+// src/index.ts
+var {
+  obsidian_read,
+  obsidian_search,
+  obsidian_create_note,
+  obsidian_append_note,
+  obsidian_set_property,
+  obsidian_skills_check,
+  obsidian_env_doctor,
+  obsidian_backlinks,
+  obsidian_tags,
+  obsidian_tag_notes,
+  obsidian_plugins,
+  obsidian_plugin_reload,
+  obsidian_dev_errors,
+  obsidian_dev_console,
+  obsidian_dev_screenshot,
+  obsidian_dev_dom,
+  obsidian_dev_css,
+  obsidian_wiki_init,
+  obsidian_wiki_ingest,
+  obsidian_wiki_update,
+  obsidian_wiki_refresh_index,
+  obsidian_wiki_search_cited,
+  obsidian_wiki_save_answer,
+  obsidian_wiki_lint,
+  obsidian_eval
+} = TOOL_MANIFEST;
+var OpenGemPlugin = async (_input, options) => {
+  const shell = makeBunSpawnShell();
+  const config = resolvePluginConfig({
+    defaultVault: options?.defaultVault ?? null,
+    wiki: {
+      rawDir: options?.wikiRawDir ?? "raw",
+      wikiDir: options?.wikiDir ?? "wiki",
+      schemaDir: options?.wikiSchemaDir ?? "schema"
+    },
+    evalEnabled: options?.evalEnabled ?? false
+  });
+  const wikiPaths = resolveWikiPaths({
+    vault: config.defaultVault ?? "",
+    rawDir: config.wiki.rawDir,
+    wikiDir: config.wiki.wikiDir,
+    schemaDir: config.wiki.schemaDir
+  });
+  return {
+    tool: {
+      obsidian_read: tool({
+        description: obsidian_read.description,
+        args: {
+          file: tool.schema.string().optional().describe("Note title or Obsidian file name (without path)"),
+          path: tool.schema.string().optional().describe("Exact path relative to vault root"),
+          vault: tool.schema.string().optional().describe("Vault name (optional for read operations)")
+        },
+        async execute(args) {
+          return JSON.stringify(await runReadTool({ shell, input: args }));
+        }
+      }),
+      obsidian_search: tool({
+        description: obsidian_search.description,
+        args: {
+          query: tool.schema.string().describe("Search query"),
+          limit: tool.schema.number().optional().describe("Maximum number of results (default 10)"),
+          vault: tool.schema.string().optional().describe("Vault name (optional, falls back to active vault)")
+        },
+        async execute(args) {
+          return JSON.stringify(await runSearchTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null }));
+        }
+      }),
+      obsidian_create_note: tool({
+        description: obsidian_create_note.description,
+        args: {
+          name: tool.schema.string().describe("Note title"),
+          content: tool.schema.string().describe("Note content in Markdown"),
+          vault: tool.schema.string().optional().describe("Vault name (required if defaultVault is not configured)"),
+          template: tool.schema.string().optional().describe("Template name to use"),
+          silent: tool.schema.boolean().optional().describe("Skip opening the note after creation"),
+          overwrite: tool.schema.boolean().optional().describe("Overwrite if note already exists")
+        },
+        async execute(args) {
+          return JSON.stringify(await runCreateNoteTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null }));
+        }
+      }),
+      obsidian_append_note: tool({
+        description: obsidian_append_note.description,
+        args: {
+          content: tool.schema.string().describe("Text to append"),
+          file: tool.schema.string().optional().describe("Note title or Obsidian file name"),
+          path: tool.schema.string().optional().describe("Exact path relative to vault root"),
+          vault: tool.schema.string().optional().describe("Vault name (required for write operations)")
+        },
+        async execute(args) {
+          return JSON.stringify(await runAppendNoteTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null }));
+        }
+      }),
+      obsidian_set_property: tool({
+        description: obsidian_set_property.description,
+        args: {
+          name: tool.schema.string().describe("Property (frontmatter field) name"),
+          value: tool.schema.string().describe("Value to set"),
+          file: tool.schema.string().optional().describe("Note title or Obsidian file name"),
+          path: tool.schema.string().optional().describe("Exact path relative to vault root"),
+          vault: tool.schema.string().optional().describe("Vault name (required for write operations)")
+        },
+        async execute(args) {
+          return JSON.stringify(await runSetPropertyTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null }));
+        }
+      }),
+      obsidian_skills_check: tool({
+        description: obsidian_skills_check.description,
+        args: {
+          mode: tool.schema.enum(["external", "bundled"]).optional().describe("Skills mode to check")
+        },
+        async execute(args) {
+          const skillsState = await detectSkillsState({ mode: config.skills.mode, explicitPath: config.skills.externalPath, homeDir: homedir(), syncDirName: config.skills.syncDirName });
+          return JSON.stringify(await runSkillsCheck({ mode: args.mode ?? skillsState.mode, skillsPath: skillsState.path, requiredSkills: ["obsidian-markdown", "obsidian-bases", "json-canvas", "obsidian-cli", "defuddle"] }));
+        }
+      }),
+      obsidian_env_doctor: tool({
+        description: obsidian_env_doctor.description,
+        args: {},
+        async execute() {
+          return JSON.stringify(await runEnvDoctor({
+            detectCli: () => detectCli(async () => (await makeBunSpawnShell()(["obsidian", "--version"])).exitCode === 0),
+            detectApp: () => detectApp(async () => (await makeBunSpawnShell()(["obsidian", "vault"])).exitCode === 0),
+            detectSkills: async () => {
+              const state = await detectSkillsState({ mode: config.skills.mode, explicitPath: config.skills.externalPath, homeDir: homedir(), syncDirName: config.skills.syncDirName });
+              const check = await runSkillsCheck({ mode: state.mode, skillsPath: state.path, requiredSkills: ["obsidian-markdown", "obsidian-bases", "json-canvas", "obsidian-cli", "defuddle"] });
+              return { mode: state.mode, path: state.path, inSync: check.ok };
+            },
+            defaultVault: config.defaultVault
+          }));
+        }
+      }),
+      obsidian_backlinks: tool({
+        description: obsidian_backlinks.description,
+        args: {
+          path: tool.schema.string().describe("Note path relative to vault root"),
+          counts: tool.schema.boolean().optional().describe("Include link counts"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runBacklinksTool({ shell, input: args }));
+        }
+      }),
+      obsidian_tags: tool({
+        description: obsidian_tags.description,
+        args: {
+          path: tool.schema.string().optional().describe("Scope tags to a single note path"),
+          counts: tool.schema.boolean().optional().describe("Include usage counts"),
+          sort: tool.schema.string().optional().describe("Sort order: count or name"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runTagsTool({ shell, input: args }));
+        }
+      }),
+      obsidian_tag_notes: tool({
+        description: obsidian_tag_notes.description,
+        args: {
+          name: tool.schema.string().describe("Tag name (without leading #)"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runTagNotesTool({ shell, input: args }));
+        }
+      }),
+      obsidian_plugins: tool({
+        description: obsidian_plugins.description,
+        args: { vault: tool.schema.string().optional() },
+        async execute(args) {
+          return JSON.stringify(await runPluginsTool({ shell, input: args }));
+        }
+      }),
+      obsidian_plugin_reload: tool({
+        description: obsidian_plugin_reload.description,
+        args: {
+          id: tool.schema.string().describe("Plugin ID as shown in community plugin settings")
+        },
+        async execute(args) {
+          return JSON.stringify(await runPluginReloadTool({ shell, input: args }));
+        }
+      }),
+      obsidian_dev_errors: tool({
+        description: obsidian_dev_errors.description,
+        args: { vault: tool.schema.string().optional() },
+        async execute(args) {
+          return JSON.stringify(await runDevErrorsTool({ shell, input: args }));
+        }
+      }),
+      obsidian_dev_console: tool({
+        description: obsidian_dev_console.description,
+        args: {
+          action: tool.schema.enum(["start", "stop", "get"]).describe("start/stop capture or get output"),
+          limit: tool.schema.number().optional().describe("Max lines to return (get action only)")
+        },
+        async execute(args) {
+          return JSON.stringify(await runDevConsoleTool({ shell, input: args }));
+        }
+      }),
+      obsidian_dev_screenshot: tool({
+        description: obsidian_dev_screenshot.description,
+        args: {
+          path: tool.schema.string().describe("Output path inside the vault (e.g. shots/home.png)"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runDevScreenshotTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null }));
+        }
+      }),
+      obsidian_dev_dom: tool({
+        description: obsidian_dev_dom.description,
+        args: {
+          selector: tool.schema.string().describe("CSS selector to target"),
+          mode: tool.schema.enum(["text", "all", "total"]).optional(),
+          attr: tool.schema.string().optional().describe("Attribute name to read"),
+          css: tool.schema.string().optional().describe("CSS property to read")
+        },
+        async execute(args) {
+          return JSON.stringify(await runDevDomTool({ shell, input: args }));
+        }
+      }),
+      obsidian_dev_css: tool({
+        description: obsidian_dev_css.description,
+        args: {
+          selector: tool.schema.string().describe("CSS selector"),
+          prop: tool.schema.string().optional().describe("Specific CSS property name")
+        },
+        async execute(args) {
+          return JSON.stringify(await runDevCssTool({ shell, input: args }));
+        }
+      }),
+      obsidian_wiki_init: tool({
+        description: obsidian_wiki_init.description,
+        args: {
+          vault: tool.schema.string().optional().describe("Target vault (required if defaultVault is not configured)"),
+          force: tool.schema.boolean().optional().describe("Overwrite SCHEMA.md and INDEX.md if they already exist")
+        },
+        async execute(args) {
+          return JSON.stringify(await runWikiInitTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_wiki_ingest: tool({
+        description: obsidian_wiki_ingest.description,
+        args: {
+          sourceName: tool.schema.string().describe("Source document name (becomes raw/<name> and wiki/<name>)"),
+          sourceContent: tool.schema.string().describe("Raw source content (immutable)"),
+          wikiContent: tool.schema.string().describe("Wiki summary/knowledge content"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runWikiIngestTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_wiki_update: tool({
+        description: obsidian_wiki_update.description,
+        args: {
+          pageName: tool.schema.string().describe("Wiki page name (stored under wiki/)"),
+          content: tool.schema.string().describe("Full page content in Markdown"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runWikiUpdateTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_wiki_refresh_index: tool({
+        description: obsidian_wiki_refresh_index.description,
+        args: { vault: tool.schema.string().optional() },
+        async execute(args) {
+          return JSON.stringify(await runWikiRefreshIndexTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_wiki_search_cited: tool({
+        description: obsidian_wiki_search_cited.description,
+        args: {
+          query: tool.schema.string().describe("Search query scoped to wiki/"),
+          limit: tool.schema.number().optional(),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runWikiSearchCitedTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_wiki_save_answer: tool({
+        description: obsidian_wiki_save_answer.description,
+        args: {
+          question: tool.schema.string().describe("The question being answered"),
+          answer: tool.schema.string().describe("The answer content in Markdown"),
+          tags: tool.schema.array(tool.schema.string()).optional().describe("Optional tags for the answer note"),
+          vault: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return JSON.stringify(await runWikiSaveAnswerTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_wiki_lint: tool({
+        description: obsidian_wiki_lint.description,
+        args: { vault: tool.schema.string().optional() },
+        async execute(args) {
+          return JSON.stringify(await runWikiLintTool({ shell, input: args, defaultVault: config.defaultVault, activeVault: null, wikiPaths }));
+        }
+      }),
+      obsidian_eval: tool({
+        description: obsidian_eval.description,
+        args: {
+          code: tool.schema.string().describe("JavaScript code to execute in the Obsidian app context")
+        },
+        async execute(args) {
+          return JSON.stringify(await runEvalTool({ shell, input: args, evalEnabled: config.evalEnabled }));
+        }
+      })
+    }
+  };
+};
+var src_default = OpenGemPlugin;
+export {
+  src_default as default,
+  OpenGemPlugin
+};