diffwiki-core 0.14.0 → 0.15.0

package/dist/plugin.js

@@ -1,14 +1,20 @@
 import {
   commandExists,
   definePlugin,
+  ensureTool,
+  parseArticle,
   resolveDependency,
   runProcess,
-  runProcessJson
-} from "./chunk-EEETAETA.js";
+  runProcessJson,
+  stripFrontmatter
+} from "./chunk-6MW6KSS4.js";
 export {
   commandExists,
   definePlugin,
+  ensureTool,
+  parseArticle,
   resolveDependency,
   runProcess,
-  runProcessJson
+  runProcessJson,
+  stripFrontmatter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffwiki-core",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Core configuration, registry, and article management for diffwiki",
   "license": "MIT",
   "type": "module",

package/dist/chunk-EEETAETA.js

@@ -1,145 +0,0 @@
-// src/plugins/sdk.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { existsSync, readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-var execFileAsync = promisify(execFile);
-async function runProcess(file, args, opts) {
-  const { stdout, stderr } = await execFileAsync(file, args, {
-    env: opts?.env,
-    timeout: opts?.timeout,
-    // Large: qmd emits multi-MB JSON search payloads that overflow the default 1 MB.
-    maxBuffer: 50 * 1024 * 1024
-  });
-  return { stdout, stderr };
-}
-async function runProcessJson(file, args, opts) {
-  const { stdout } = await runProcess(file, args, opts);
-  try {
-    return JSON.parse(stdout);
-  } catch {
-    throw new Error(`${file} ${args.join(" ")} did not return valid JSON: ${stdout.slice(0, 200)}`);
-  }
-}
-async function commandExists(name) {
-  try {
-    await execFileAsync(name, ["--version"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveNpmBin(pkg, command, fromUrl) {
-  try {
-    let dir = dirname(fileURLToPath(fromUrl));
-    for (; ; ) {
-      const pkgJson = join(dir, "node_modules", pkg, "package.json");
-      if (existsSync(pkgJson)) {
-        const raw = JSON.parse(readFileSync(pkgJson, "utf8"));
-        const rel = typeof raw.bin === "string" ? raw.bin : raw.bin?.[command];
-        if (!rel) return null;
-        const binPath = join(dirname(pkgJson), rel);
-        return existsSync(binPath) ? binPath : null;
-      }
-      const parent = dirname(dir);
-      if (parent === dir) return null;
-      dir = parent;
-    }
-  } catch {
-    return null;
-  }
-}
-async function resolveDependency(dep, fromUrl) {
-  if (dep.npm) {
-    const local = resolveNpmBin(dep.npm, dep.command, fromUrl);
-    if (local) return { dependency: dep, command: [local], source: "npm" };
-  }
-  if (await commandExists(dep.command)) {
-    return { dependency: dep, command: [dep.command], source: "path" };
-  }
-  return { dependency: dep, command: null, source: "missing" };
-}
-function definePlugin(def) {
-  const { name, kind, version, capabilities, dependencies, handlers } = def;
-  const describeResult = {
-    name,
-    kind,
-    version,
-    capabilities: {
-      searchTypes: capabilities.searchTypes,
-      collectionFilter: capabilities.collectionFilter,
-      events: capabilities.events
-    },
-    dependencies: (dependencies ?? []).map((d) => ({ command: d.command, npm: d.npm, hint: d.hint }))
-  };
-  async function dispatch(op, params, log) {
-    switch (op) {
-      case "describe":
-        return describeResult;
-      case "search":
-        return handlers.search(params, log);
-      case "index":
-        if (handlers.index) return handlers.index(params, log);
-        return { indexed: 0 };
-      case "setup":
-        if (handlers.setup) return handlers.setup(params, log);
-        return { ready: true };
-      case "event":
-        if (handlers.onEvent) return handlers.onEvent(params, log);
-        return { accepted: true };
-      case "health":
-        if (handlers.health) return handlers.health(params, log);
-        return { ready: true, diagnostics: [] };
-      default:
-        throw new Error(`unknown op: ${op}`);
-    }
-  }
-  function run() {
-    const log = (level, message) => {
-      process.stderr.write(JSON.stringify({ log: { level, message } }) + "\n");
-    };
-    let buffer = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => {
-      buffer += chunk;
-    });
-    process.stdin.on("end", () => {
-      const line = buffer.trim();
-      if (!line) {
-        process.stderr.write(`${name}: no input received on stdin
-`);
-        process.exit(1);
-        return;
-      }
-      let req;
-      try {
-        req = JSON.parse(line);
-      } catch {
-        process.stderr.write(`${name}: malformed JSON on stdin: ${line.slice(0, 200)}
-`);
-        process.exit(1);
-        return;
-      }
-      dispatch(req.op, req.params ?? {}, log).then((result) => {
-        const response = { ok: true, result };
-        process.stdout.write(JSON.stringify(response) + "\n");
-        process.exit(0);
-      }).catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        const response = { ok: false, error: { message } };
-        process.stdout.write(JSON.stringify(response) + "\n");
-        process.exit(1);
-      });
-    });
-  }
-  return { definition: def, run };
-}
-
-export {
-  runProcess,
-  runProcessJson,
-  commandExists,
-  resolveDependency,
-  definePlugin
-};