yamlover 0.3.0

package/src/server/gitignore.ts

@@ -0,0 +1,81 @@
+/**
+ * gitignore.ts — a predicate telling whether an absolute path is git-ignored.
+ *
+ * It honors `.gitignore` files from the repository root down to the file's
+ * parent (nested `.gitignore`s included), plus an always-ignored `.git`. Built
+ * once per server and handed to the materializer (see `setIgnoreFilter`), it only
+ * filters *undescribed* (stray) entries — schema-described children are always
+ * kept.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import ignore, { type Ignore } from "ignore";
+
+export function buildGitIgnore(dataRoot: string): (absPath: string) => boolean {
+  const gitRoot = findGitRoot(dataRoot) ?? dataRoot;
+  const cache = new Map<string, Ignore | null>(); // dir → its .gitignore matcher
+
+  const matcherFor = (dir: string): Ignore | null => {
+    if (!cache.has(dir)) {
+      let ig: Ignore | null = null;
+      try {
+        const gi = path.join(dir, ".gitignore");
+        if (fs.statSync(gi).isFile()) ig = ignore().add(fs.readFileSync(gi, "utf-8"));
+      } catch {
+        /* no .gitignore here */
+      }
+      cache.set(dir, ig);
+    }
+    return cache.get(dir)!;
+  };
+
+  return (absPath: string): boolean => {
+    const fromRoot = path.relative(gitRoot, absPath);
+    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path.sep)) return true;
+
+    // A directory must be tested with a trailing slash, otherwise a `dir/`
+    // pattern (e.g. `node_modules/`) does not match the bare name.
+    let isDir = false;
+    try {
+      isDir = fs.statSync(absPath).isDirectory();
+    } catch {
+      /* gone */
+    }
+
+    // Test the path against every .gitignore from the repo root down to its
+    // parent directory; each file's patterns are relative to its own location.
+    const rel = path.relative(gitRoot, path.dirname(absPath));
+    const segs = rel === "" ? [] : rel.split(path.sep);
+    let dir = gitRoot;
+    const dirs = [gitRoot];
+    for (const s of segs) {
+      dir = path.join(dir, s);
+      dirs.push(dir);
+    }
+    for (const d of dirs) {
+      const ig = matcherFor(d);
+      if (!ig) continue;
+      const relToDir = path.relative(d, absPath);
+      if (!relToDir) continue;
+      if (ig.ignores(relToDir) || (isDir && ig.ignores(relToDir + "/"))) return true;
+    }
+    return false;
+  };
+}
+
+function findGitRoot(start: string): string | null {
+  let dir = path.resolve(start);
+  // If start is a file, begin at its directory.
+  try {
+    if (!fs.statSync(dir).isDirectory()) dir = path.dirname(dir);
+  } catch {
+    return null;
+  }
+  for (;;) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}

package/src/server/node-kind.ts

@@ -0,0 +1,48 @@
+// Node-KIND classification — how a Store node is presented (the `type:` the client routes on). Kept
+// in its own module (no http/fs/gitignore deps) so it can be unit-tested under `node --test` against
+// a Store, independently of the HTTP layer (engine-api.ts), which only Vite can load (node:sqlite).
+import type { NodeRow, Store } from "../../../engine/ts/src/index.ts";
+
+// One ordered container, classified for display: a pure-keyed mapping is `object`, a pure-keyless
+// one `array`; a mapping mixing keyed + keyless OWNED entries is `mix`; a scalar/blob that ALSO
+// carries OWNED fields is `omni` (the `!!mix`/`!!omni` shapes); plain scalars/blobs are
+// `scalar`/`binary`.
+export type Kind = "object" | "array" | "scalar" | "binary" | "omni" | "mix";
+
+/** A node's OWNED entries — the ones it authors, that constitute its content: containment children
+ *  and forward `*` refs. A `~` back-edge (a REVERSE member, e.g. tag membership) is an upstream
+ *  relation the node does NOT own, so it is excluded — it must not change the node's type. */
+export function ownedEntries(s: Store, p: string): ReturnType<Store["entries"]> {
+  return s.entries(p).filter((e) => e.kind !== "back");
+}
+
+/** A node's display {@link Kind}. A scalar/blob carrying OWNED fields is `omni`; a mapping that
+ *  mixes keyed and keyless OWNED entries is `mix`; otherwise object|array|scalar|binary. The
+ *  `is_array` flag marks a pure-keyless container. Reverse (`~`) members never count — a tagged PDF
+ *  is still a `binary`, not an `omni` (they are upstream relations, not owned content). */
+export function displayKind(s: Store, p: string, row: NodeRow): Kind {
+  const ents = ownedEntries(s, p);
+  if (row.type === "blob") return ents.length ? "omni" : "binary";
+  if (row.type === "scalar") return ents.length ? "omni" : "scalar";
+  if (!ents.length) return row.is_array ? "array" : "object"; // empty container
+  if (row.is_array) return "array";
+  return ents.some((e) => e.label === null) ? "mix" : "object";
+}
+
+// Internal kind → the JSON-Schema-style `type:` name shown in the header/TOC and the schema view.
+// The YAML-tag shapes `!!mix`/`!!omni` get full-word schema names (cf. !!seq→array, !!map→object):
+// `mix` → "mixed", `omni` → "variant". Scalars resolve to their JSON-ish primitive type.
+export function typeName(s: Store, p: string, row: NodeRow): string {
+  const k = displayKind(s, p, row);
+  if (k === "scalar") return scalarType(row.value);
+  if (k === "mix") return "mixed";
+  if (k === "omni") return "variant";
+  return k; // object | array | binary
+}
+
+export function scalarType(v: unknown): string {
+  if (v === null) return "null";
+  if (typeof v === "boolean") return "boolean";
+  if (typeof v === "number") return Number.isInteger(v) ? "integer" : "number";
+  return "string";
+}

package/src/server/tasks.ts

@@ -0,0 +1,83 @@
+// tasks.ts — the server's LONG-RUNNING TASK registry. Anything slow (the initial index, the
+// background hasher, a watcher reconcile, …) registers here and reports progress; every state
+// change is emitted (engine-api pushes it to the UI over the existing /api/events SSE stream
+// as a `{type:"task", task}` frame) and GET /api/tasks snapshots in-flight tasks for a freshly
+// loaded page. Generic on purpose: a future slow operation is just `registry.start(label)`.
+
+export interface TaskProgress {
+  done: number;
+  total?: number; // absent ⇒ indeterminate (the UI shows an activity bar, not a percent)
+  message?: string; // human-readable detail (current path, "writing index…", …)
+}
+
+export interface TaskInfo {
+  id: string;
+  label: string;
+  state: "running" | "done" | "error";
+  progress: TaskProgress;
+  startedAt: number; // epoch ms
+  finishedAt?: number;
+  error?: string;
+}
+
+export interface TaskHandle {
+  readonly id: string;
+  /** Report progress. Throttled (state changes are not) so a per-file caller cannot flood SSE. */
+  progress(done: number, total?: number, message?: string): void;
+  done(): void;
+  fail(err: unknown): void;
+}
+
+const PROGRESS_EMIT_MS = 150; // at most one progress frame per task per this interval
+const KEEP_FINISHED_MS = 5_000; // finished tasks stay listed briefly so completion is visible
+
+export class TaskRegistry {
+  private seq = 0;
+  private readonly tasks = new Map<string, TaskInfo>();
+  private readonly lastEmit = new Map<string, number>();
+
+  constructor(private readonly emit: (t: TaskInfo) => void) {}
+
+  start(label: string): TaskHandle {
+    const id = "t" + ++this.seq;
+    const info: TaskInfo = { id, label, state: "running", progress: { done: 0 }, startedAt: Date.now() };
+    this.tasks.set(id, info);
+    this.send(info, true);
+    const finish = (state: "done" | "error", error?: string): void => {
+      if (info.state !== "running") return; // done/fail are one-shot
+      info.state = state;
+      info.finishedAt = Date.now();
+      if (error !== undefined) info.error = error;
+      this.send(info, true);
+    };
+    return {
+      id,
+      progress: (done, total, message) => {
+        if (info.state !== "running") return;
+        info.progress = { done, ...(total !== undefined && { total }), ...(message !== undefined && { message }) };
+        this.send(info, false);
+      },
+      done: () => finish("done"),
+      fail: (err) => finish("error", String((err as Error)?.message ?? err)),
+    };
+  }
+
+  /** Running tasks + ones finished within the last few seconds (pruning the rest). */
+  list(): TaskInfo[] {
+    const now = Date.now();
+    for (const [id, t] of this.tasks) {
+      if (t.state !== "running" && now - (t.finishedAt ?? 0) > KEEP_FINISHED_MS) {
+        this.tasks.delete(id);
+        this.lastEmit.delete(id);
+      }
+    }
+    return [...this.tasks.values()].map((t) => ({ ...t, progress: { ...t.progress } }));
+  }
+
+  private send(t: TaskInfo, always: boolean): void {
+    const now = Date.now();
+    if (!always && now - (this.lastEmit.get(t.id) ?? 0) < PROGRESS_EMIT_MS) return;
+    this.lastEmit.set(t.id, now);
+    this.emit({ ...t, progress: { ...t.progress } });
+  }
+}