datanotes 0.0.0-stage → 1.1.0

package/dist/api/local.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/local.ts
+var local_exports = {};
+__export(local_exports, {
+  LOCK_STALE_MS: () => LOCK_STALE_MS,
+  localEngine: () => localEngine,
+  vaultSettingsPath: () => vaultSettingsPath
+});
+module.exports = __toCommonJS(local_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var LOCK_STALE_MS = 3e4;
+function vaultSettingsPath(vault) {
+  const plugin = import_node_path.default.join(vault, ".obsidian", "plugins", "datanotes", "data.json");
+  return import_node_fs.default.existsSync(plugin) ? plugin : import_node_path.default.join(vault, ".datanotes", "service.json");
+}
+function readJson(file) {
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function localEngine(vault, opts = {}) {
+  const settings = readJson(opts.settingsFile ?? vaultSettingsPath(vault)) ?? {};
+  const store = typeof settings.storeFolder === "string" && settings.storeFolder ? settings.storeFolder : ".datanotes";
+  const lock = readJson(import_node_path.default.join(vault, store.replace(/\/+$/, ""), "engine.lock"));
+  if (!lock || (opts.now ?? Date.now()) - Date.parse(lock.heartbeat) >= LOCK_STALE_MS) return null;
+  if (lock.host !== import_node_os.default.hostname()) throw new Error(`the vault is held by an engine on ${lock.host}; connect to it by its address`);
+  const token = typeof settings.httpServerToken === "string" ? settings.httpServerToken : "";
+  if (!token) return null;
+  return { url: `http://${opts.host ?? "127.0.0.1"}:${lock.port}`, token, lock };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOCK_STALE_MS,
+  localEngine,
+  vaultSettingsPath
+});

package/dist/api/local.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Find the engine running on a vault of this machine (Node only): its address and the owner's
+ * token, read from the vault's settings and from the lock the engine holds while it runs.
+ */
+/** The lock an engine writes in its store folder (`<vault>/.datanotes/engine.lock`). */
+export interface EngineLock {
+    kind: "service" | "plugin";
+    pid: number;
+    host: string;
+    port: number;
+    startedAt: string;
+    heartbeat: string;
+}
+/** A lock whose heartbeat is older than this belongs to an engine that stopped. */
+export declare const LOCK_STALE_MS = 30000;
+export interface LocalEngine {
+    url: string;
+    token: string;
+    lock: EngineLock;
+}
+/** The settings file of a vault: the Obsidian plugin's when present, else the service's. */
+export declare function vaultSettingsPath(vault: string): string;
+/**
+ * The engine holding `vault`, or null when none runs. Throws when the lock is fresh but held on
+ * another machine (a synced or shared folder): that engine is not reachable from here.
+ */
+export declare function localEngine(vault: string, opts?: {
+    settingsFile?: string;
+    host?: string;
+    now?: number;
+}): LocalEngine | null;

package/dist/api/local.js

@@ -0,0 +1,31 @@
+// src/api/local.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var LOCK_STALE_MS = 3e4;
+function vaultSettingsPath(vault) {
+  const plugin = path.join(vault, ".obsidian", "plugins", "datanotes", "data.json");
+  return fs.existsSync(plugin) ? plugin : path.join(vault, ".datanotes", "service.json");
+}
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function localEngine(vault, opts = {}) {
+  const settings = readJson(opts.settingsFile ?? vaultSettingsPath(vault)) ?? {};
+  const store = typeof settings.storeFolder === "string" && settings.storeFolder ? settings.storeFolder : ".datanotes";
+  const lock = readJson(path.join(vault, store.replace(/\/+$/, ""), "engine.lock"));
+  if (!lock || (opts.now ?? Date.now()) - Date.parse(lock.heartbeat) >= LOCK_STALE_MS) return null;
+  if (lock.host !== os.hostname()) throw new Error(`the vault is held by an engine on ${lock.host}; connect to it by its address`);
+  const token = typeof settings.httpServerToken === "string" ? settings.httpServerToken : "";
+  if (!token) return null;
+  return { url: `http://${opts.host ?? "127.0.0.1"}:${lock.port}`, token, lock };
+}
+export {
+  LOCK_STALE_MS,
+  localEngine,
+  vaultSettingsPath
+};

package/dist/api/requests.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The HTTP request behind each operation of the catalogue (`catalog.ts`): most are
+ * `POST /datanotes/<route>` with a JSON body built from the operation's arguments (renamed where
+ * the route names them differently); the note operations read the vault routes.
+ */
+type Args = Record<string, unknown>;
+export declare class OperationInputError extends Error {
+    readonly name = "OperationInputError";
+}
+export declare const ROUTE_PREFIX = "/datanotes";
+export interface OperationRequest {
+    method: "GET" | "POST";
+    /** Path from the server root, query string included. */
+    path: string;
+    body?: unknown;
+    /** Accept header, when the route answers in more than one format. */
+    accept?: string;
+}
+/** The request for an operation and its arguments; throws OperationInputError on bad arguments. */
+export declare function operationRequest(name: string, args?: Args): OperationRequest;
+/** Operations this module can build a request for (to check the catalogue against). */
+export declare const CALLABLE_OPERATIONS: Set<string>;
+/** The route an operation calls (without the prefix) and the body fields it fixes (e.g. `op` for DDL), or null. */
+export declare function operationRoute(name: string): {
+    path: string;
+    fixed: Args;
+} | null;
+export {};

package/dist/api/results.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What an operation returned, for its caller: the value of a success, or an agent-readable text
+ * for a refusal (what was refused; nothing was written) or an error.
+ */
+/** Agent-readable summary of conflicts / violations / failures in a refused result. */
+export declare function describeRefusal(data: Record<string, unknown>): string;
+/** Agent-readable summary of a refused batch: the failing operation and the rollback. */
+export declare function describeBatch(data: Record<string, unknown>): string;
+export interface OperationResult {
+    ok: boolean;
+    /** The result (JSON, or the text of a note) or, when `ok` is false, the reason. */
+    value: unknown;
+}
+/** The result of an HTTP answer: `json` when the body was JSON, else its `text`. */
+export declare function resultOf(status: number, json: unknown, text: string): OperationResult;

package/dist/api/tokens.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A tokenizer-free estimate of how many tokens a text costs a model: words count about one token
+ * per 4 letters, numbers one per 3 digits, every other symbol (JSON punctuation, quotes, …) one.
+ * Close to real tokenizers on JSON and on Italian/English prose (within ~15%); good for telling
+ * which tools and sessions fill the context, not for billing.
+ */
+export declare function estimateTokens(text: string): number;