diffwiki-core 0.4.0 → 0.5.0-rc.202607230329.fb70592

package/dist/chunk-GVSRD5WB.js

@@ -0,0 +1,500 @@
+// src/collections.ts
+import fs2 from "fs/promises";
+
+// src/paths.ts
+import os from "os";
+import path from "path";
+function resolveHome() {
+  const override = process.env.DIFFWIKI_HOME;
+  return override && override.length > 0 ? override : path.join(os.homedir(), ".diffwiki");
+}
+function registryPath() {
+  return path.join(resolveHome(), "registry.json");
+}
+function configPath() {
+  return path.join(resolveHome(), "config.json");
+}
+function collectionsDir() {
+  return path.join(resolveHome(), "collections");
+}
+function collectionDir(name) {
+  return path.join(collectionsDir(), name);
+}
+function pluginsDir() {
+  return path.join(resolveHome(), "plugins");
+}
+function pluginsRegistryPath() {
+  return path.join(resolveHome(), "plugins.json");
+}
+
+// src/registry.ts
+import fs from "fs/promises";
+function isMissing(err) {
+  return err?.code === "ENOENT";
+}
+async function readRegistry() {
+  try {
+    const parsed = JSON.parse(await fs.readFile(registryPath(), "utf8"));
+    return { version: parsed.version ?? 1, collections: parsed.collections ?? [] };
+  } catch (err) {
+    if (isMissing(err)) return { version: 1, collections: [] };
+    throw err;
+  }
+}
+async function writeRegistry(registry) {
+  await fs.mkdir(resolveHome(), { recursive: true });
+  await fs.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+async function registerCollection(entry) {
+  const registry = await readRegistry();
+  const index = registry.collections.findIndex((c) => c.name === entry.name);
+  if (index >= 0) {
+    registry.collections[index] = entry;
+  } else {
+    registry.collections.push(entry);
+  }
+  await writeRegistry(registry);
+}
+async function unregisterCollection(name) {
+  const registry = await readRegistry();
+  registry.collections = registry.collections.filter((c) => c.name !== name);
+  await writeRegistry(registry);
+}
+
+// src/errors.ts
+var DiffwikiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var CollectionExistsError = class extends DiffwikiError {
+  constructor(name) {
+    super(`collection "${name}" already exists`);
+  }
+};
+var CollectionNotFoundError = class extends DiffwikiError {
+  constructor(name) {
+    super(`collection "${name}" not found`);
+  }
+};
+var NoDefaultCollectionError = class extends DiffwikiError {
+  constructor() {
+    super("no default collection set (use: diffwiki config-set defaultCollection <name>)");
+  }
+};
+var ArticleNotFoundError = class extends DiffwikiError {
+  constructor(target) {
+    super(`article "${target}" not found`);
+  }
+};
+var InvalidTargetError = class extends DiffwikiError {
+  constructor(target, expected) {
+    super(`invalid target "${target}" \u2014 ${expected}`);
+  }
+};
+var PluginError = class extends DiffwikiError {
+};
+var WorktreeNotAllowedError = class extends DiffwikiError {
+  constructor(root) {
+    super(`refusing to add a linked worktree \u2014 add the source repository instead (${root})`);
+  }
+};
+var CollectionAlreadyAddedError = class extends DiffwikiError {
+  constructor(name) {
+    super(`this repository is already added as collection "${name}"`);
+  }
+};
+
+// src/collections.ts
+async function fireHook(event, collection) {
+  try {
+    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-XSIUMRBG.js");
+    await emitPluginEvent2(event, collection);
+  } catch {
+  }
+}
+async function listCollections() {
+  return (await readRegistry()).collections;
+}
+async function findCollection(name) {
+  return (await readRegistry()).collections.find((c) => c.name === name);
+}
+async function findCollectionById(id) {
+  return (await readRegistry()).collections.find((c) => c.id === id);
+}
+async function createCollection(name) {
+  if (await findCollection(name)) throw new CollectionExistsError(name);
+  const dir = collectionDir(name);
+  await fs2.mkdir(dir, { recursive: true });
+  const entry = {
+    name,
+    type: "global",
+    path: dir,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await registerCollection(entry);
+  void fireHook("collection-added", name);
+  return entry;
+}
+async function removeCollection(name) {
+  const entry = await findCollection(name);
+  if (!entry) throw new CollectionNotFoundError(name);
+  await unregisterCollection(name);
+  if (entry.type === "global") {
+    await fs2.rm(entry.path, { recursive: true, force: true });
+  }
+  void fireHook("collection-removed", name);
+  return entry;
+}
+
+// src/plugins/registry.ts
+import fs3 from "fs/promises";
+function isMissing2(err) {
+  return err?.code === "ENOENT";
+}
+async function readPluginRegistry() {
+  try {
+    const parsed = JSON.parse(await fs3.readFile(pluginsRegistryPath(), "utf8"));
+    return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
+  } catch (err) {
+    if (isMissing2(err)) return { version: 1, plugins: [] };
+    throw err;
+  }
+}
+async function writePluginRegistry(registry) {
+  await fs3.mkdir(resolveHome(), { recursive: true });
+  await fs3.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+async function upsertPlugin(record) {
+  const registry = await readPluginRegistry();
+  const index = registry.plugins.findIndex((p) => p.name === record.name);
+  if (index >= 0) {
+    registry.plugins[index] = record;
+  } else {
+    registry.plugins.push(record);
+  }
+  await writePluginRegistry(registry);
+}
+async function deregisterPlugin(name) {
+  const registry = await readPluginRegistry();
+  registry.plugins = registry.plugins.filter((p) => p.name !== name);
+  await writePluginRegistry(registry);
+}
+async function listEnabledPlugins(kind) {
+  const registry = await readPluginRegistry();
+  return registry.plugins.filter((p) => p.enabled && p.kind === kind);
+}
+async function findEnabledPlugin(kind, name) {
+  const enabled = await listEnabledPlugins(kind);
+  if (name) return enabled.find((p) => p.name === name);
+  return enabled[0];
+}
+async function findPluginRecord(name) {
+  const registry = await readPluginRegistry();
+  return registry.plugins.find((p) => p.name === name);
+}
+
+// src/plugins/host.ts
+import { spawn } from "child_process";
+import path2, { basename } from "path";
+
+// src/logger.ts
+import { getLogger as logtapeGetLogger } from "@logtape/logtape";
+var LEVELS = ["trace", "debug", "info", "warning", "error", "fatal"];
+var DEFAULT_LEVEL = "warning";
+function getLogger(scope) {
+  const parts = Array.isArray(scope) ? scope : [scope];
+  return logtapeGetLogger(["diffwiki", ...parts]);
+}
+function resolveLogLevel(env = process.env) {
+  const raw = (env.DIFFWIKI_LOG ?? "").toLowerCase();
+  return LEVELS.includes(raw) ? raw : DEFAULT_LEVEL;
+}
+
+// src/types.ts
+var NATIVE_ENGINE = "native";
+
+// src/plugins/host.ts
+var LEVEL_METHOD = {
+  trace: "trace",
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  warning: "warn",
+  error: "error",
+  fatal: "fatal"
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SEARCH_TIMEOUT_MS = 12e4;
+var LONG_TIMEOUT_MS = 18e5;
+async function invokePlugin(command, op, params, opts) {
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const scope = opts?.name ?? basename(command[1] ?? command[0] ?? "plugin");
+  return new Promise((resolve, reject) => {
+    const child = spawn(command[0], command.slice(1), {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let stderrLine = "";
+    let settled = false;
+    const forwardLog = (line) => {
+      const trimmedLine = line.trim();
+      if (!trimmedLine.startsWith("{")) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmedLine);
+      } catch {
+        return;
+      }
+      const entry = parsed.log;
+      if (!entry || typeof entry.message !== "string") return;
+      const rawLevel = typeof entry.level === "string" ? entry.level.toLowerCase() : "";
+      const method = LEVEL_METHOD[rawLevel] ?? "info";
+      getLogger(["plugin", scope])[method](entry.message);
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGKILL");
+      reject(new Error(`plugin "${op}" timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      stderrLine += chunk;
+      let nl;
+      while ((nl = stderrLine.indexOf("\n")) !== -1) {
+        forwardLog(stderrLine.slice(0, nl));
+        stderrLine = stderrLine.slice(nl + 1);
+      }
+    });
+    child.on("error", (err) => {
+      settle(() => reject(new Error(`plugin spawn failed: ${err.message}`)));
+    });
+    child.on("close", (code) => {
+      if (stderrLine.length > 0) {
+        forwardLog(stderrLine);
+        stderrLine = "";
+      }
+      settle(() => {
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+          reject(
+            new Error(`plugin "${op}" produced no output (exit ${code})${stderr ? ": " + stderr.slice(0, 500) : ""}`)
+          );
+          return;
+        }
+        let response;
+        try {
+          response = JSON.parse(trimmed);
+        } catch {
+          reject(new Error(`plugin "${op}" returned invalid JSON: ${trimmed.slice(0, 200)}`));
+          return;
+        }
+        if (response.ok) {
+          resolve(response.result);
+        } else {
+          const message = typeof response.error?.message === "string" ? response.error.message : `plugin "${op}" failed`;
+          reject(new Error(message));
+        }
+      });
+    });
+    const request = JSON.stringify({ op, params });
+    child.stdin.write(request + "\n", (err) => {
+      if (err && !settled) {
+        settle(() => reject(new Error(`failed to write to plugin stdin: ${err.message}`)));
+        return;
+      }
+      child.stdin.end();
+    });
+  });
+}
+function toWireCollections(collections) {
+  return collections.map((c) => ({ name: c.name, path: c.path }));
+}
+function mapHits(result, collections) {
+  const raw = result?.hits;
+  const hits = Array.isArray(raw) ? raw : [];
+  const out = [];
+  for (const item of hits) {
+    if (typeof item !== "object" || item === null) continue;
+    const h = item;
+    if (typeof h.collection !== "string" || typeof h.relPath !== "string") continue;
+    const title = typeof h.title === "string" ? h.title : h.relPath;
+    const coll = collections.find((c) => c.name === h.collection);
+    const abs = coll ? path2.join(coll.path, h.relPath) : h.relPath;
+    out.push({
+      collection: h.collection,
+      path: abs,
+      title,
+      tags: Array.isArray(h.tags) ? h.tags.filter((t) => typeof t === "string") : [],
+      snippet: typeof h.snippet === "string" ? h.snippet : void 0,
+      score: typeof h.score === "number" ? h.score : void 0,
+      docid: typeof h.docid === "string" ? h.docid : void 0
+    });
+  }
+  return out;
+}
+async function loadSearchProvider(name) {
+  const record = await findEnabledPlugin("search", name);
+  if (!record) return null;
+  let capabilities;
+  try {
+    const desc = await invokePlugin(record.command, "describe", {}, { name: record.name });
+    if (desc.kind !== "search") {
+      return null;
+    }
+    capabilities = desc.capabilities;
+  } catch {
+    return null;
+  }
+  const provider = {
+    name: record.name,
+    capabilities,
+    async handleSearch(term, collections, opts) {
+      const result = await invokePlugin(
+        record.command,
+        "search",
+        {
+          term,
+          collections: toWireCollections(collections),
+          collection: opts?.collection,
+          type: opts?.type,
+          limit: opts?.limit
+        },
+        { timeoutMs: SEARCH_TIMEOUT_MS, name: record.name }
+      );
+      return mapHits(result, collections);
+    },
+    async reindex(collections, opts) {
+      const result = await invokePlugin(
+        record.command,
+        "index",
+        {
+          collections: toWireCollections(collections),
+          embed: opts?.embed
+        },
+        { timeoutMs: LONG_TIMEOUT_MS, name: record.name }
+      );
+      return result?.indexed ?? 0;
+    },
+    async emitEvent(event, collection, relPath, collections) {
+      try {
+        const entry = collections.find((c) => c.name === collection);
+        await invokePlugin(
+          record.command,
+          "event",
+          {
+            event,
+            collection: entry ? { name: entry.name, path: entry.path } : { name: collection, path: "" },
+            relPath,
+            collections: toWireCollections(collections)
+          },
+          { name: record.name }
+        );
+      } catch {
+      }
+    },
+    async health(collections) {
+      const result = await invokePlugin(record.command, "health", { collections: toWireCollections(collections) }, { name: record.name });
+      return {
+        ready: result?.ready === true,
+        readiness: result?.readiness,
+        diagnostics: result?.diagnostics ?? []
+      };
+    }
+  };
+  return provider;
+}
+async function listSearchModes() {
+  const modes = [{ plugin: NATIVE_ENGINE, type: "basic", label: "native \xB7 bm25" }];
+  const plugins = await listEnabledPlugins("search");
+  for (const record of plugins) {
+    const caps = record.capabilities;
+    if (!caps) continue;
+    for (const type of caps.searchTypes) {
+      modes.push({ plugin: record.name, type, label: `${record.name} \xB7 ${type}` });
+    }
+  }
+  return modes;
+}
+
+// src/plugins/events.ts
+async function emitPluginEvent(event, collection, relPath) {
+  try {
+    const record = await findEnabledPlugin("search");
+    if (!record) return;
+    if (!record.capabilities?.events) return;
+    const collections = await listCollections();
+    const entry = collections.find((c) => c.name === collection);
+    await invokePlugin(
+      record.command,
+      "event",
+      {
+        event,
+        collection: entry ? { name: entry.name, path: entry.path } : { name: collection, path: "" },
+        relPath,
+        collections: collections.map((c) => ({ name: c.name, path: c.path }))
+      },
+      { name: record.name }
+    );
+  } catch {
+  }
+}
+
+export {
+  NATIVE_ENGINE,
+  DiffwikiError,
+  CollectionExistsError,
+  CollectionNotFoundError,
+  NoDefaultCollectionError,
+  ArticleNotFoundError,
+  InvalidTargetError,
+  PluginError,
+  WorktreeNotAllowedError,
+  CollectionAlreadyAddedError,
+  resolveHome,
+  registryPath,
+  configPath,
+  collectionsDir,
+  collectionDir,
+  pluginsDir,
+  pluginsRegistryPath,
+  readRegistry,
+  writeRegistry,
+  registerCollection,
+  unregisterCollection,
+  readPluginRegistry,
+  writePluginRegistry,
+  upsertPlugin,
+  deregisterPlugin,
+  listEnabledPlugins,
+  findEnabledPlugin,
+  findPluginRecord,
+  getLogger,
+  resolveLogLevel,
+  LONG_TIMEOUT_MS,
+  invokePlugin,
+  loadSearchProvider,
+  listSearchModes,
+  emitPluginEvent,
+  listCollections,
+  findCollection,
+  findCollectionById,
+  createCollection,
+  removeCollection
+};

package/dist/events-XSIUMRBG.js

@@ -0,0 +1,6 @@
+import {
+  emitPluginEvent
+} from "./chunk-GVSRD5WB.js";
+export {
+  emitPluginEvent
+};