@grainulation/silo 1.0.0 → 1.0.1

package/lib/server.js

@@ -9,26 +9,36 @@
  *   silo serve [--port 9095] [--root /path/to/repo]
  */
 
-import { createServer } from 'node:http';
-import { readFileSync, existsSync, readdirSync, writeFileSync, statSync } from 'node:fs';
-import { join, resolve, extname, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
+import { createServer } from "node:http";
+import {
+  readFileSync,
+  existsSync,
+  readdirSync,
+  writeFileSync,
+  statSync,
+} from "node:fs";
+import { join, resolve, extname, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 
 // ── Crash handlers ──
-process.on('uncaughtException', (err) => {
-  process.stderr.write(`[${new Date().toISOString()}] FATAL: ${err.stack || err}\n`);
+process.on("uncaughtException", (err) => {
+  process.stderr.write(
+    `[${new Date().toISOString()}] FATAL: ${err.stack || err}\n`,
+  );
   process.exit(1);
 });
-process.on('unhandledRejection', (reason) => {
-  process.stderr.write(`[${new Date().toISOString()}] WARN unhandledRejection: ${reason}\n`);
+process.on("unhandledRejection", (reason) => {
+  process.stderr.write(
+    `[${new Date().toISOString()}] WARN unhandledRejection: ${reason}\n`,
+  );
 });
 
-const PUBLIC_DIR = join(__dirname, '..', 'public');
-const PACKS_DIR = join(__dirname, '..', 'packs');
+const PUBLIC_DIR = join(__dirname, "..", "public");
+const PACKS_DIR = join(__dirname, "..", "packs");
 
 // ── CLI args ──────────────────────────────────────────────────────────────────
 
@@ -38,38 +48,67 @@ function arg(name, fallback) {
   return i !== -1 && args[i + 1] ? args[i + 1] : fallback;
 }
 
-const PORT = parseInt(arg('port', '9095'), 10);
-const ROOT = resolve(arg('root', process.cwd()));
-const CORS_ORIGIN = arg('cors', null);
+const PORT = parseInt(arg("port", "9095"), 10);
+const ROOT = resolve(arg("root", process.cwd()));
+const CORS_ORIGIN = arg("cors", null);
 
 // ── Verbose logging ──────────────────────────────────────────────────────────
 
-const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+const verbose =
+  process.argv.includes("--verbose") || process.argv.includes("-v");
 function vlog(...a) {
   if (!verbose) return;
   const ts = new Date().toISOString();
-  process.stderr.write(`[${ts}] silo: ${a.join(' ')}\n`);
+  process.stderr.write(`[${ts}] silo: ${a.join(" ")}\n`);
 }
 
 // ── Routes manifest ──────────────────────────────────────────────────────────
 
 const ROUTES = [
-  { method: 'GET', path: '/health', description: 'Health check endpoint' },
-  { method: 'GET', path: '/events', description: 'SSE event stream for live updates' },
-  { method: 'GET', path: '/api/packs', description: 'List all available knowledge packs' },
-  { method: 'GET', path: '/api/packs/:name', description: 'Get pack details and claims by name' },
-  { method: 'POST', path: '/api/import', description: 'Import a pack into a target claims file' },
-  { method: 'GET', path: '/api/search', description: 'Search claims by ?q, ?type, ?evidence, ?limit' },
-  { method: 'POST', path: '/api/refresh', description: 'Reload packs from disk' },
-  { method: 'GET', path: '/api/docs', description: 'This API documentation page' },
+  { method: "GET", path: "/health", description: "Health check endpoint" },
+  {
+    method: "GET",
+    path: "/events",
+    description: "SSE event stream for live updates",
+  },
+  {
+    method: "GET",
+    path: "/api/packs",
+    description: "List all available knowledge packs",
+  },
+  {
+    method: "GET",
+    path: "/api/packs/:name",
+    description: "Get pack details and claims by name",
+  },
+  {
+    method: "POST",
+    path: "/api/import",
+    description: "Import a pack into a target claims file",
+  },
+  {
+    method: "GET",
+    path: "/api/search",
+    description: "Search claims by ?q, ?type, ?evidence, ?limit",
+  },
+  {
+    method: "POST",
+    path: "/api/refresh",
+    description: "Reload packs from disk",
+  },
+  {
+    method: "GET",
+    path: "/api/docs",
+    description: "This API documentation page",
+  },
 ];
 
 // ── Load existing CJS modules via createRequire ──────────────────────────────
 
-const { Store } = require('./store.js');
-const { Search } = require('./search.js');
-const { Packs } = require('./packs.js');
-const { ImportExport } = require('./import-export.js');
+const { Store } = require("./store.js");
+const { Search } = require("./search.js");
+const { Packs } = require("./packs.js");
+const { ImportExport } = require("./import-export.js");
 
 const store = new Store();
 const search = new Search(store);
@@ -88,7 +127,11 @@ const sseClients = new Set();
 function broadcast(event) {
   const data = `data: ${JSON.stringify(event)}\n\n`;
   for (const res of sseClients) {
-    try { res.write(data); } catch { sseClients.delete(res); }
+    try {
+      res.write(data);
+    } catch {
+      sseClients.delete(res);
+    }
   }
 }
 
@@ -100,24 +143,24 @@ function loadPacks() {
 
 function refreshState() {
   state.packs = loadPacks();
-  broadcast({ type: 'state', data: state });
+  broadcast({ type: "state", data: state });
 }
 
 // ── MIME types ────────────────────────────────────────────────────────────────
 
 const MIME = {
-  '.html': 'text/html; charset=utf-8',
-  '.css': 'text/css; charset=utf-8',
-  '.js': 'application/javascript; charset=utf-8',
-  '.json': 'application/json; charset=utf-8',
-  '.svg': 'image/svg+xml',
-  '.png': 'image/png',
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
 };
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function jsonResponse(res, code, data) {
-  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.writeHead(code, { "Content-Type": "application/json; charset=utf-8" });
   res.end(JSON.stringify(data));
 }
 
@@ -125,12 +168,23 @@ function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
     let size = 0;
-    req.on('data', c => { size += c.length; if (size > 1048576) { resolve(null); req.destroy(); return; } chunks.push(c); });
-    req.on('end', () => {
-      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
-      catch { resolve(null); }
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > 1048576) {
+        resolve(null);
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
     });
-    req.on('error', () => resolve(null));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        resolve(null);
+      }
+    });
+    req.on("error", () => resolve(null));
   });
 }
 
@@ -141,71 +195,89 @@ const server = createServer(async (req, res) => {
 
   // CORS (only when --cors is passed)
   if (CORS_ORIGIN) {
-    res.setHeader('Access-Control-Allow-Origin', CORS_ORIGIN);
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    res.setHeader("Access-Control-Allow-Origin", CORS_ORIGIN);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
   }
 
-  if (req.method === 'OPTIONS' && CORS_ORIGIN) {
+  if (req.method === "OPTIONS" && CORS_ORIGIN) {
     res.writeHead(204);
     res.end();
     return;
   }
 
-  vlog('request', req.method, url.pathname);
+  vlog("request", req.method, url.pathname);
 
   // ── API: docs ──
-  if (req.method === 'GET' && url.pathname === '/api/docs') {
+  if (req.method === "GET" && url.pathname === "/api/docs") {
     const html = `<!DOCTYPE html><html><head><title>silo API</title>
 <style>body{font-family:system-ui;background:#0a0e1a;color:#e8ecf1;max-width:800px;margin:40px auto;padding:0 20px}
 table{width:100%;border-collapse:collapse}th,td{padding:8px 12px;border-bottom:1px solid #1e293b;text-align:left}
 th{color:#9ca3af}code{background:#1e293b;padding:2px 6px;border-radius:4px;font-size:13px}</style></head>
 <body><h1>silo API</h1><p>${ROUTES.length} endpoints</p>
 <table><tr><th>Method</th><th>Path</th><th>Description</th></tr>
-${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</code></td><td>'+r.description+'</td></tr>').join('')}
+${ROUTES.map((r) => "<tr><td><code>" + r.method + "</code></td><td><code>" + r.path + "</code></td><td>" + r.description + "</td></tr>").join("")}
 </table></body></html>`;
-    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.writeHead(200, { "Content-Type": "text/html" });
     res.end(html);
     return;
   }
 
   // ── Health check ──
-  if (req.method === 'GET' && url.pathname === '/health') {
-    jsonResponse(res, 200, { status: 'ok', uptime: process.uptime(), packs: state.packs.length });
+  if (req.method === "GET" && url.pathname === "/health") {
+    jsonResponse(res, 200, {
+      status: "ok",
+      uptime: process.uptime(),
+      packs: state.packs.length,
+    });
     return;
   }
 
   // ── SSE endpoint ──
-  if (req.method === 'GET' && url.pathname === '/events') {
+  if (req.method === "GET" && url.pathname === "/events") {
     res.writeHead(200, {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
     });
-    res.write(`data: ${JSON.stringify({ type: 'state', data: state })}\n\n`);
+    res.write(`data: ${JSON.stringify({ type: "state", data: state })}\n\n`);
     const heartbeat = setInterval(() => {
-      try { res.write(': heartbeat\n\n'); } catch { clearInterval(heartbeat); }
+      try {
+        res.write(": heartbeat\n\n");
+      } catch {
+        clearInterval(heartbeat);
+      }
     }, 15000);
     sseClients.add(res);
-    vlog('sse', `client connected (${sseClients.size} total)`);
-    req.on('close', () => { clearInterval(heartbeat); sseClients.delete(res); vlog('sse', `client disconnected (${sseClients.size} total)`); });
+    vlog("sse", `client connected (${sseClients.size} total)`);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      sseClients.delete(res);
+      vlog("sse", `client disconnected (${sseClients.size} total)`);
+    });
     return;
   }
 
   // ── API: list packs ──
-  if (req.method === 'GET' && url.pathname === '/api/packs') {
+  if (req.method === "GET" && url.pathname === "/api/packs") {
     const packList = loadPacks();
     jsonResponse(res, 200, { packs: packList });
     return;
   }
 
   // ── API: get pack details ──
-  if (req.method === 'GET' && url.pathname.startsWith('/api/packs/')) {
-    const name = decodeURIComponent(url.pathname.slice('/api/packs/'.length));
-    if (!name) { jsonResponse(res, 400, { error: 'missing pack name' }); return; }
+  if (req.method === "GET" && url.pathname.startsWith("/api/packs/")) {
+    const name = decodeURIComponent(url.pathname.slice("/api/packs/".length));
+    if (!name) {
+      jsonResponse(res, 400, { error: "missing pack name" });
+      return;
+    }
 
     const pack = packs.get(name);
-    if (!pack) { jsonResponse(res, 404, { error: `pack "${name}" not found` }); return; }
+    if (!pack) {
+      jsonResponse(res, 404, { error: `pack "${name}" not found` });
+      return;
+    }
 
     jsonResponse(res, 200, {
       id: name,
@@ -219,25 +291,27 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── API: import pack ──
-  if (req.method === 'POST' && url.pathname === '/api/import') {
+  if (req.method === "POST" && url.pathname === "/api/import") {
     try {
       const body = await readBody(req);
       const { pack: packName, targetDir } = body;
       if (!packName || !targetDir) {
-        jsonResponse(res, 400, { error: 'missing pack or targetDir' });
+        jsonResponse(res, 400, { error: "missing pack or targetDir" });
         return;
       }
 
       const absTarget = resolve(targetDir);
       if (!absTarget.startsWith(ROOT)) {
-        jsonResponse(res, 400, { error: 'target directory must be within the project root' });
+        jsonResponse(res, 400, {
+          error: "target directory must be within the project root",
+        });
         return;
       }
 
-      const targetPath = resolve(absTarget, 'claims.json');
+      const targetPath = resolve(absTarget, "claims.json");
       // Ensure the target file exists
       if (!existsSync(targetPath)) {
-        writeFileSync(targetPath, '[]', 'utf-8');
+        writeFileSync(targetPath, "[]", "utf-8");
       }
 
       const result = io.pull(packName, targetPath);
@@ -255,11 +329,11 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── API: search ──
-  if (req.method === 'GET' && url.pathname === '/api/search') {
-    const q = url.searchParams.get('q') || '';
-    const type = url.searchParams.get('type') || undefined;
-    const evidence = url.searchParams.get('evidence') || undefined;
-    const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+  if (req.method === "GET" && url.pathname === "/api/search") {
+    const q = url.searchParams.get("q") || "";
+    const type = url.searchParams.get("type") || undefined;
+    const evidence = url.searchParams.get("evidence") || undefined;
+    const limit = parseInt(url.searchParams.get("limit") || "20", 10);
 
     if (!q) {
       jsonResponse(res, 200, { query: q, results: [] });
@@ -276,26 +350,34 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
     // Also search directly in packs/ directory
     if (existsSync(PACKS_DIR)) {
       for (const file of readdirSync(PACKS_DIR)) {
-        if (!file.endsWith('.json')) continue;
+        if (!file.endsWith(".json")) continue;
         try {
-          const data = JSON.parse(readFileSync(join(PACKS_DIR, file), 'utf-8'));
-          const packName = data.name || file.replace('.json', '');
+          const data = JSON.parse(readFileSync(join(PACKS_DIR, file), "utf-8"));
+          const packName = data.name || file.replace(".json", "");
           for (const claim of data.claims || []) {
             if (type && claim.type !== type) continue;
             if (evidence && claim.evidence !== evidence) continue;
             const searchable = [
-              claim.content || claim.text || '',
-              claim.type || '',
-              claim.topic || '',
-              (claim.tags || []).join(' '),
-            ].join(' ').toLowerCase();
-
-            const tokens = q.toLowerCase().split(/\s+/).filter(t => t.length > 1);
+              claim.content || claim.text || "",
+              claim.type || "",
+              claim.topic || "",
+              (claim.tags || []).join(" "),
+            ]
+              .join(" ")
+              .toLowerCase();
+
+            const tokens = q
+              .toLowerCase()
+              .split(/\s+/)
+              .filter((t) => t.length > 1);
             let score = 0;
             for (const token of tokens) {
               if (searchable.includes(token)) {
                 score += 1;
-                if (searchable.includes(` ${token} `) || searchable.startsWith(`${token} `)) {
+                if (
+                  searchable.includes(` ${token} `) ||
+                  searchable.startsWith(`${token} `)
+                ) {
                   score += 0.5;
                 }
               }
@@ -304,7 +386,9 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
               results.push({ claim, collection: `pack:${packName}`, score });
             }
           }
-        } catch { /* skip malformed */ }
+        } catch {
+          /* skip malformed */
+        }
       }
     }
 
@@ -326,54 +410,61 @@ ${ROUTES.map(r => '<tr><td><code>'+r.method+'</code></td><td><code>'+r.path+'</c
   }
 
   // ── API: refresh ──
-  if (req.method === 'POST' && url.pathname === '/api/refresh') {
+  if (req.method === "POST" && url.pathname === "/api/refresh") {
     refreshState();
     jsonResponse(res, 200, state);
     return;
   }
 
   // ── Static files ──
-  let filePath = url.pathname === '/' ? '/index.html' : url.pathname;
-  const resolved = resolve(PUBLIC_DIR, '.' + filePath);
+  let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
+  const resolved = resolve(PUBLIC_DIR, "." + filePath);
   if (!resolved.startsWith(PUBLIC_DIR)) {
     res.writeHead(403);
-    res.end('forbidden');
+    res.end("forbidden");
     return;
   }
 
   if (existsSync(resolved) && statSync(resolved).isFile()) {
     const ext = extname(resolved);
-    const mime = MIME[ext] || 'application/octet-stream';
+    const mime = MIME[ext] || "application/octet-stream";
     try {
       const content = readFileSync(resolved);
-      res.writeHead(200, { 'Content-Type': mime });
+      res.writeHead(200, { "Content-Type": mime });
       res.end(content);
     } catch {
       res.writeHead(500);
-      res.end('read error');
+      res.end("read error");
     }
     return;
   }
 
   // ── 404 ──
-  res.writeHead(404, { 'Content-Type': 'text/plain' });
-  res.end('not found');
+  res.writeHead(404, { "Content-Type": "text/plain" });
+  res.end("not found");
 });
 
 // ── File watching (fingerprint-based polling) ─────────────────────────────────
 
-let lastFingerprint = '';
+let lastFingerprint = "";
 function computeFingerprint() {
   const parts = [];
   try {
     if (existsSync(PACKS_DIR)) {
       for (const file of readdirSync(PACKS_DIR)) {
-        if (!file.endsWith('.json')) continue;
-        try { const s = statSync(join(PACKS_DIR, file)); parts.push(file + ':' + s.mtimeMs); } catch { /* skip */ }
+        if (!file.endsWith(".json")) continue;
+        try {
+          const s = statSync(join(PACKS_DIR, file));
+          parts.push(file + ":" + s.mtimeMs);
+        } catch {
+          /* skip */
+        }
       }
     }
-  } catch { /* skip */ }
-  return parts.join('|');
+  } catch {
+    /* skip */
+  }
+  return parts.join("|");
 }
 
 function startWatcher() {
@@ -383,7 +474,7 @@ function startWatcher() {
     if (fp !== lastFingerprint) {
       lastFingerprint = fp;
       refreshState();
-      vlog('watcher', 'packs changed, state refreshed');
+      vlog("watcher", "packs changed, state refreshed");
     }
   }, 5000);
 }
@@ -391,23 +482,27 @@ function startWatcher() {
 // ── Graceful shutdown ─────────────────────────────────────────────────────────
 const shutdown = (signal) => {
   console.log(`\nsilo: ${signal} received, shutting down...`);
-  for (const res of sseClients) { try { res.end(); } catch {} }
+  for (const res of sseClients) {
+    try {
+      res.end();
+    } catch {}
+  }
   sseClients.clear();
   server.close(() => process.exit(0));
   setTimeout(() => process.exit(1), 5000);
 };
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-process.on('SIGINT', () => shutdown('SIGINT'));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
 
 // ── Start ─────────────────────────────────────────────────────────────────────
 
 refreshState();
 startWatcher();
 
-server.on('error', (err) => {
-  if (err.code === 'EADDRINUSE') {
+server.on("error", (err) => {
+  if (err.code === "EADDRINUSE") {
     console.error(`silo: port ${PORT} is already in use. Try --port <other>.`);
-  } else if (err.code === 'EACCES') {
+  } else if (err.code === "EACCES") {
     console.error(`silo: port ${PORT} requires elevated privileges.`);
   } else {
     console.error(`silo: server error: ${err.message}`);
@@ -415,8 +510,8 @@ server.on('error', (err) => {
   process.exit(1);
 });
 
-server.listen(PORT, '127.0.0.1', () => {
-  vlog('listen', `port=${PORT}`, `root=${ROOT}`);
+server.listen(PORT, "127.0.0.1", () => {
+  vlog("listen", `port=${PORT}`, `root=${ROOT}`);
   console.log(`silo: serving on http://localhost:${PORT}`);
   console.log(`  packs: ${state.packs.length} available`);
   console.log(`  root:  ${ROOT}`);

package/lib/store.js

@@ -5,24 +5,29 @@
  * No database, no dependencies — just the filesystem.
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
 
-const DEFAULT_SILO_DIR = path.join(require('node:os').homedir(), '.silo');
+const DEFAULT_SILO_DIR = path.join(require("node:os").homedir(), ".silo");
 
 class Store {
   constructor(siloDir = DEFAULT_SILO_DIR) {
     this.root = siloDir;
-    this.claimsDir = path.join(siloDir, 'claims');
-    this.templatesDir = path.join(siloDir, 'templates');
-    this.packsDir = path.join(siloDir, 'packs');
-    this.indexPath = path.join(siloDir, 'index.json');
+    this.claimsDir = path.join(siloDir, "claims");
+    this.templatesDir = path.join(siloDir, "templates");
+    this.packsDir = path.join(siloDir, "packs");
+    this.indexPath = path.join(siloDir, "index.json");
   }
 
   /** Ensure the silo directory structure exists. */
   init() {
-    for (const dir of [this.root, this.claimsDir, this.templatesDir, this.packsDir]) {
+    for (const dir of [
+      this.root,
+      this.claimsDir,
+      this.templatesDir,
+      this.packsDir,
+    ]) {
       if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
       }
@@ -44,7 +49,7 @@ class Store {
     const entry = {
       id,
       name,
-      type: 'claims',
+      type: "claims",
       claimCount: claims.length,
       hash: this._hash(JSON.stringify(claims)),
       storedAt: new Date().toISOString(),
@@ -77,12 +82,20 @@ class Store {
     this.init();
     const results = [];
     const index = this._readJSON(this.indexPath);
-    for (const entry of (index.collections || [])) {
+    for (const entry of index.collections || []) {
       const data = this.getClaims(entry.id);
       if (!data) {
-        results.push({ id: entry.id, ok: false, warning: 'Collection file missing' });
+        results.push({
+          id: entry.id,
+          ok: false,
+          warning: "Collection file missing",
+        });
       } else {
-        results.push({ id: entry.id, ok: !data._integrityWarning, warning: data._integrityWarning || null });
+        results.push({
+          id: entry.id,
+          ok: !data._integrityWarning,
+          warning: data._integrityWarning || null,
+        });
       }
     }
     return results;
@@ -111,21 +124,24 @@ class Store {
   // --- Internal helpers ---
 
   _readJSON(filePath) {
-    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
   }
 
   _writeJSON(filePath, data) {
-    const tmp = filePath + '.tmp.' + process.pid;
-    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    const tmp = filePath + ".tmp." + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", "utf-8");
     fs.renameSync(tmp, filePath);
   }
 
   _hash(str) {
-    return crypto.createHash('sha256').update(str).digest('hex');
+    return crypto.createHash("sha256").update(str).digest("hex");
   }
 
   _slugify(str) {
-    return str.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    return str
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
   }
 
   _addToIndex(entry) {