@levnikolaevich/hex-line-mcp 1.3.1 → 1.3.3

package/lib/read.mjs

@@ -6,10 +6,11 @@
  */
 
 import { statSync } from "node:fs";
-import { fnv1a, lineTag, rangeChecksum } from "./hash.mjs";
-import { validatePath } from "./security.mjs";
+import { fnv1a, lineTag, rangeChecksum } from "@levnikolaevich/hex-common/text-protocol/hash";
+import { validatePath, normalizePath } from "./security.mjs";
 import { getGraphDB, fileAnnotations, getRelativePath } from "./graph-enrich.mjs";
 import { relativeTime, listDirectory, readText, MAX_OUTPUT_CHARS } from "./format.mjs";
+import { rememberSnapshot } from "./revisions.mjs";
 
 const DEFAULT_LIMIT = 2000;
 
@@ -21,6 +22,7 @@ const DEFAULT_LIMIT = 2000;
  * @returns {string} formatted output
  */
 export function readFile(filePath, opts = {}) {
+    filePath = normalizePath(filePath);
     const real = validatePath(filePath);
     const stat = statSync(real);
 
@@ -30,8 +32,8 @@ export function readFile(filePath, opts = {}) {
         return `Directory: ${filePath}\n\n\`\`\`\n${text}\n\`\`\``;
     }
 
-    const content = readText(real);
-    const lines = content.split("\n");
+    const snapshot = rememberSnapshot(real, readText(real), { mtimeMs: stat.mtimeMs, size: stat.size });
+    const lines = snapshot.lines;
     const total = lines.length;
 
     // Determine ranges to read
@@ -119,7 +121,8 @@ export function readFile(filePath, opts = {}) {
         }
     }
 
-    let result = `${header}${graphLine}\n\n\`\`\`\n${parts.join("\n")}\n\`\`\``;
+    let result =
+        `${header}${graphLine}\nrevision: ${snapshot.revision}\nfile: ${snapshot.fileChecksum}\n\n\`\`\`\n${parts.join("\n")}\n\`\`\``;
 
     // Auto-hint for large files read from start without offset
     if (total > 200 && (!opts.offset || opts.offset <= 1) && !cappedAtLine) {

package/lib/revisions.mjs

@@ -0,0 +1,238 @@
+/**
+ * Revision journal for hex-line-mcp.
+ *
+ * Keeps short-lived file snapshots in memory so read/edit/verify can reuse
+ * line hashes, file checksums, and changed ranges without re-reading the file
+ * on every same-file operation.
+ */
+
+import { statSync } from "node:fs";
+import { diffLines } from "diff";
+import { fnv1a, lineTag, rangeChecksum } from "@levnikolaevich/hex-common/text-protocol/hash";
+import { readText } from "./format.mjs";
+
+const MAX_FILES = 200;
+const MAX_REVISIONS_PER_FILE = 5;
+const TTL_MS = 5 * 60 * 1000;
+
+const latestByFile = new Map();
+const revisionsById = new Map();
+const fileRevisionIds = new Map();
+let revisionSeq = 0;
+
+function touchFile(filePath) {
+    const latest = latestByFile.get(filePath);
+    if (!latest) return;
+    latestByFile.delete(filePath);
+    latestByFile.set(filePath, latest);
+}
+
+function pruneExpired(now = Date.now()) {
+    for (const [revision, snapshot] of revisionsById) {
+        if (now - snapshot.createdAt <= TTL_MS) continue;
+        revisionsById.delete(revision);
+        const ids = fileRevisionIds.get(snapshot.path);
+        if (!ids) continue;
+        const next = ids.filter(id => id !== revision);
+        if (next.length > 0) fileRevisionIds.set(snapshot.path, next);
+        else fileRevisionIds.delete(snapshot.path);
+        const latest = latestByFile.get(snapshot.path);
+        if (latest?.revision === revision) latestByFile.delete(snapshot.path);
+    }
+    while (latestByFile.size > MAX_FILES) {
+        const oldestPath = latestByFile.keys().next().value;
+        const ids = fileRevisionIds.get(oldestPath) || [];
+        for (const id of ids) revisionsById.delete(id);
+        fileRevisionIds.delete(oldestPath);
+        latestByFile.delete(oldestPath);
+    }
+}
+
+function rememberRevisionId(filePath, revision) {
+    const ids = fileRevisionIds.get(filePath) || [];
+    ids.push(revision);
+    while (ids.length > MAX_REVISIONS_PER_FILE) {
+        const removed = ids.shift();
+        revisionsById.delete(removed);
+    }
+    fileRevisionIds.set(filePath, ids);
+}
+
+function buildUniqueTagIndex(lineHashes) {
+    const index = new Map();
+    const duplicates = new Set();
+    for (let i = 0; i < lineHashes.length; i++) {
+        const tag = lineTag(lineHashes[i]);
+        if (duplicates.has(tag)) continue;
+        if (index.has(tag)) {
+            index.delete(tag);
+            duplicates.add(tag);
+            continue;
+        }
+        index.set(tag, i);
+    }
+    return index;
+}
+
+function computeFileChecksum(lineHashes) {
+    return rangeChecksum(lineHashes, 1, lineHashes.length);
+}
+
+function diffLineCount(value) {
+    if (!value) return 0;
+    return value.split("\n").length - 1;
+}
+
+function coalesceRanges(ranges) {
+    if (!ranges.length) return [];
+    const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+    const merged = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+        const prev = merged[merged.length - 1];
+        const curr = sorted[i];
+        if (curr.start <= prev.end + 1) {
+            prev.end = Math.max(prev.end, curr.end);
+            prev.kind = prev.kind === curr.kind ? prev.kind : "mixed";
+            continue;
+        }
+        merged.push({ ...curr });
+    }
+    return merged;
+}
+
+export function computeChangedRanges(oldLines, newLines) {
+    const oldText = oldLines.join("\n") + "\n";
+    const newText = newLines.join("\n") + "\n";
+    const parts = diffLines(oldText, newText);
+    const ranges = [];
+    let oldNum = 1;
+    let newNum = 1;
+
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const count = diffLineCount(part.value);
+
+        if (part.removed) {
+            const next = parts[i + 1];
+            if (next?.added) {
+                const addedCount = diffLineCount(next.value);
+                ranges.push({
+                    start: newNum,
+                    end: addedCount > 0 ? newNum + addedCount - 1 : newNum,
+                    kind: "replace",
+                });
+                oldNum += count;
+                newNum += addedCount;
+                i++;
+                continue;
+            }
+            ranges.push({ start: newNum, end: newNum, kind: "delete" });
+            oldNum += count;
+            continue;
+        }
+
+        if (part.added) {
+            ranges.push({
+                start: newNum,
+                end: count > 0 ? newNum + count - 1 : newNum,
+                kind: "insert",
+            });
+            newNum += count;
+            continue;
+        }
+
+        oldNum += count;
+        newNum += count;
+    }
+
+    return coalesceRanges(ranges);
+}
+
+export function describeChangedRanges(ranges) {
+    if (!ranges?.length) return "none";
+    return ranges.map(r => `${r.start}-${r.end}${r.kind ? `(${r.kind})` : ""}`).join(", ");
+}
+
+function createSnapshot(filePath, content, mtimeMs, size, prevSnapshot = null) {
+    const lines = content.split("\n");
+    const lineHashes = lines.map(line => fnv1a(line));
+    const fileChecksum = computeFileChecksum(lineHashes);
+    const revision = `rev-${++revisionSeq}-${fileChecksum.split(":")[1]}`;
+    return {
+        revision,
+        path: filePath,
+        content,
+        lines,
+        lineHashes,
+        fileChecksum,
+        uniqueTagIndex: buildUniqueTagIndex(lineHashes),
+        changedRangesFromPrev: prevSnapshot ? computeChangedRanges(prevSnapshot.lines, lines) : [],
+        prevRevision: prevSnapshot?.revision || null,
+        mtimeMs,
+        size,
+        createdAt: Date.now(),
+    };
+}
+
+export function rememberSnapshot(filePath, content, meta = {}) {
+    pruneExpired();
+    const latest = latestByFile.get(filePath);
+    const mtimeMs = meta.mtimeMs ?? latest?.mtimeMs ?? Date.now();
+    const size = meta.size ?? Buffer.byteLength(content, "utf8");
+
+    if (latest && latest.content === content && latest.mtimeMs === mtimeMs && latest.size === size) {
+        touchFile(filePath);
+        return latest;
+    }
+
+    const snapshot = createSnapshot(filePath, content, mtimeMs, size, latest || null);
+    latestByFile.set(filePath, snapshot);
+    revisionsById.set(snapshot.revision, snapshot);
+    rememberRevisionId(filePath, snapshot.revision);
+    touchFile(filePath);
+    pruneExpired();
+    return snapshot;
+}
+
+export function readSnapshot(filePath) {
+    pruneExpired();
+    const stat = statSync(filePath);
+    const latest = latestByFile.get(filePath);
+    if (latest && latest.mtimeMs === stat.mtimeMs && latest.size === stat.size) {
+        touchFile(filePath);
+        return latest;
+    }
+    const content = readText(filePath);
+    return rememberSnapshot(filePath, content, { mtimeMs: stat.mtimeMs, size: stat.size });
+}
+
+export function getLatestSnapshot(filePath) {
+    pruneExpired();
+    const latest = latestByFile.get(filePath);
+    if (!latest) return null;
+    touchFile(filePath);
+    return latest;
+}
+
+export function getSnapshotByRevision(revision) {
+    pruneExpired();
+    return revisionsById.get(revision) || null;
+}
+
+export function overlapsChangedRanges(ranges, startLine, endLine) {
+    return (ranges || []).some((range) => range.start <= endLine && startLine <= range.end);
+}
+
+export function buildRangeChecksum(snapshot, startLine, endLine) {
+    const startIdx = startLine - 1;
+    const endIdx = endLine - 1;
+    if (startIdx < 0 || endIdx >= snapshot.lineHashes.length || startIdx > endIdx) return null;
+    return rangeChecksum(snapshot.lineHashes.slice(startIdx, endIdx + 1), startLine, endLine);
+}
+
+export function _resetRevisionCache() {
+    latestByFile.clear();
+    revisionsById.clear();
+    fileRevisionIds.clear();
+    revisionSeq = 0;
+}

package/lib/search.mjs

@@ -10,10 +10,13 @@
 
 import { spawn } from "node:child_process";
 import { resolve } from "node:path";
-import { fnv1a, lineTag, rangeChecksum } from "./hash.mjs";
+import { fnv1a, lineTag, rangeChecksum } from "@levnikolaevich/hex-common/text-protocol/hash";
 import { getGraphDB, matchAnnotation, getRelativePath } from "./graph-enrich.mjs";
 import { normalizePath } from "./security.mjs";
 
+let rgBin = "rg";
+try { rgBin = (await import("@vscode/ripgrep")).rgPath; } catch { /* system rg */ }
+
 const DEFAULT_LIMIT = 100;
 const MAX_OUTPUT = 10 * 1024 * 1024; // 10 MB
 const TIMEOUT = 30000; // 30s
@@ -31,7 +34,7 @@ function spawnRg(args) {
         let killed = false;
         let stderrBuf = "";
 
-        const child = spawn("rg", args, { timeout: TIMEOUT });
+        const child = spawn(rgBin, args, { timeout: TIMEOUT });
 
         child.stdout.on("data", (chunk) => {
             totalBytes += chunk.length;
@@ -46,11 +49,7 @@ function spawnRg(args) {
         child.stderr.on("data", (chunk) => { stderrBuf += chunk.toString("utf-8"); });
 
         child.on("error", (err) => {
-            if (err.code === "ENOENT") {
-                reject(new Error("ripgrep (rg) not found. Install: https://github.com/BurntSushi/ripgrep#installation"));
-            } else {
-                reject(new Error(`rg spawn error: ${err.message}`));
-            }
+            reject(new Error(`rg spawn error: ${err.message}`));
         });
 
         child.on("close", (code) => {

package/lib/security.mjs

@@ -18,9 +18,9 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
  */
 export function normalizePath(p) {
     if (process.platform === "win32" && /^\/[a-zA-Z]\//.test(p)) {
-        return p[1] + ":" + p.slice(2);
+        p = p[1] + ":" + p.slice(2);
     }
-    return p;
+    return p.replace(/\\/g, "/");
 }
 
 /**
@@ -80,7 +80,7 @@ export function validatePath(filePath) {
         }
     }
 
-    return real;
+    return real.replace(/\\/g, "/");
 }
 
 /**
@@ -108,5 +108,5 @@ export function validateWritePath(filePath) {
         }
     }
 
-    return abs;
+    return abs.replace(/\\/g, "/");
 }

package/lib/setup.mjs

@@ -168,31 +168,18 @@ function installOutputStyle() {
     mkdirSync(dirname(target), { recursive: true });
     writeFileSync(target, readFileSync(source, "utf-8"), "utf-8");
 
-    // Set hex-line at user (global) level
+    // Set hex-line only if no explicit style is already active
     const userSettings = resolve(homedir(), ".claude/settings.json");
     const config = readJson(userSettings) || {};
     const prev = config.outputStyle;
-    config.outputStyle = "hex-line";
-    writeJson(userSettings, config);
-
-    // Remove outputStyle from local/project scopes so global is not overridden
-    const overrides = [
-        resolve(process.cwd(), ".claude/settings.local.json"),
-        resolve(process.cwd(), ".claude/settings.json"),
-    ];
-    const cleared = [];
-    for (const p of overrides) {
-        const c = readJson(p);
-        if (c && c.outputStyle) {
-            cleared.push(`${c.outputStyle} (${p.includes("local") ? "local" : "project"})`);
-            delete c.outputStyle;
-            writeJson(p, c);
-        }
+    if (!prev) {
+        config.outputStyle = "hex-line";
+        writeJson(userSettings, config);
     }
 
-    let msg = "Output style 'hex-line' installed and activated globally";
-    if (prev && prev !== "hex-line") msg += ` (was '${prev}')`;
-    if (cleared.length) msg += `. Removed overrides: ${cleared.join(", ")}`;
+    const msg = prev
+        ? `Output style file installed. Existing style '${prev}' preserved (not overridden)`
+        : "Output style 'hex-line' installed and activated globally";
     return msg;
 }
 

package/lib/update-check.mjs

@@ -1,56 +1 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-const CACHE_FILE = join(tmpdir(), "hex-line-mcp-update.json");
-const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
-const TIMEOUT = 3000;
-
-async function readCache() {
-    try {
-        return JSON.parse(await readFile(CACHE_FILE, "utf-8"));
-    } catch { return null; }
-}
-
-async function writeCache(entry) {
-    await writeFile(CACHE_FILE, JSON.stringify(entry)).catch(() => {});
-}
-
-async function fetchLatest(packageName) {
-    try {
-        const ctrl = new AbortController();
-        const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
-        const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, { signal: ctrl.signal });
-        clearTimeout(timer);
-        if (!res.ok) return null;
-        const data = await res.json();
-        return data.version ?? null;
-    } catch { return null; }
-}
-
-function compareVersions(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
-    for (let i = 0; i < 3; i++) {
-        if ((pa[i] || 0) < (pb[i] || 0)) return -1;
-        if ((pa[i] || 0) > (pb[i] || 0)) return 1;
-    }
-    return 0;
-}
-
-export async function checkForUpdates(packageName, currentVersion) {
-    const cached = await readCache();
-    if (cached && Date.now() - cached.timestamp < CHECK_INTERVAL) {
-        if (cached.latest && compareVersions(currentVersion, cached.latest) < 0) {
-            process.stderr.write(`${packageName} update: ${currentVersion} → ${cached.latest}. Run: npm install -g ${packageName}\n`);
-        }
-        return;
-    }
-    const latest = await fetchLatest(packageName);
-    if (latest) {
-        await writeCache({ timestamp: Date.now(), latest });
-        if (compareVersions(currentVersion, latest) < 0) {
-            process.stderr.write(`${packageName} update: ${currentVersion} → ${latest}. Run: npm install -g ${packageName}\n`);
-        }
-    }
-}
+export * from "@levnikolaevich/hex-common/runtime/update-check";

package/lib/verify.mjs

@@ -3,24 +3,29 @@
  * Validates range checksums from prior reads.
  */
 
-import { fnv1a, rangeChecksum, parseChecksum } from "./hash.mjs";
-import { validatePath } from "./security.mjs";
-import { readText } from "./format.mjs";
+import { parseChecksum } from "@levnikolaevich/hex-common/text-protocol/hash";
+import { validatePath, normalizePath } from "./security.mjs";
+import {
+    buildRangeChecksum,
+    computeChangedRanges,
+    describeChangedRanges,
+    getSnapshotByRevision,
+    readSnapshot,
+} from "./revisions.mjs";
 
 /**
  * Verify checksums against current file state.
  *
  * @param {string} filePath
  * @param {string[]} checksums - array of "start-end:8hex" strings
+ * @param {object} opts
  * @returns {string} verification result
  */
-export function verifyChecksums(filePath, checksums) {
+export function verifyChecksums(filePath, checksums, opts = {}) {
+    filePath = normalizePath(filePath);
     const real = validatePath(filePath);
-    const content = readText(real);
-    const lines = content.split("\n");
-
-    // Pre-compute all line hashes
-    const lineHashes = lines.map((l) => fnv1a(l));
+    const current = readSnapshot(real);
+    const baseSnapshot = opts.baseRevision ? getSnapshotByRevision(opts.baseRevision) : null;
 
     const results = [];
     let allValid = true;
@@ -28,26 +33,37 @@ export function verifyChecksums(filePath, checksums) {
     for (const cs of checksums) {
         const parsed = parseChecksum(cs);
 
-        if (parsed.start < 1 || parsed.end > lines.length) {
-            results.push(`${cs}: INVALID (range ${parsed.start}-${parsed.end} exceeds file length ${lines.length})`);
+        if (parsed.start < 1 || parsed.end > current.lines.length) {
+            results.push(`${cs}: INVALID (range ${parsed.start}-${parsed.end} exceeds file length ${current.lines.length})`);
             allValid = false;
             continue;
         }
 
-        const currentHashes = lineHashes.slice(parsed.start - 1, parsed.end);
-        const current = rangeChecksum(currentHashes, parsed.start, parsed.end);
-        const currentHex = current.split(":")[1];
+        const actual = buildRangeChecksum(current, parsed.start, parsed.end);
+        const currentHex = actual.split(":")[1];
 
         if (currentHex === parsed.hex) {
             results.push(`${cs}: valid`);
         } else {
-            results.push(`${cs}: STALE → current: ${current}`);
+            const staleBits = [`${cs}: STALE → current: ${actual}`];
+            if (baseSnapshot?.path === real) {
+                const changedRanges = computeChangedRanges(baseSnapshot.lines, current.lines);
+                staleBits.push(`revision: ${current.revision}`);
+                staleBits.push(`changed_ranges: ${describeChangedRanges(changedRanges)}`);
+            } else if (opts.baseRevision) {
+                staleBits.push(`revision: ${current.revision}`);
+                staleBits.push(`changed_ranges: unavailable (base revision evicted)`);
+            }
+            results.push(staleBits.join("\n"));
             allValid = false;
         }
     }
 
     if (allValid && checksums.length > 0) {
-        return `All ${checksums.length} checksum(s) valid for ${filePath}`;
+        let msg = `All ${checksums.length} checksum(s) valid for ${filePath}`;
+        msg += `\nrevision: ${current.revision}`;
+        msg += `\nfile: ${current.fileChecksum}`;
+        return msg;
     }
 
     return results.join("\n");

package/output-style.md

@@ -6,25 +6,40 @@ keep-coding-instructions: true
 
 # MCP Tool Preferences
 
-**MANDATORY:** NEVER use built-in Read, Edit, Write, Grep. Use hex-line MCP equivalents:
+**PREFER** hex-line MCP for code files — hash-annotated reads enable safe edits:
 
 | Instead of | Use | Why |
 |-----------|-----|-----|
-| Read | `mcp__hex-line__read_file` | Hash-annotated, edit-ready |
-| Edit | `mcp__hex-line__edit_file` | Hash-verified anchors |
+| Read | `mcp__hex-line__read_file` | Hash-annotated, revision-aware |
+| Edit | `mcp__hex-line__edit_file` | Hash-verified anchors + conservative auto-rebase |
 | Write | `mcp__hex-line__write_file` | Consistent workflow |
 | Grep | `mcp__hex-line__grep_search` | Hash-annotated matches |
+| Edit (text rename) | `mcp__hex-line__bulk_replace` | Multi-file text rename/refactor |
 
 ## Efficient File Reading
 
-For code files >100 lines, ALWAYS:
+For UNFAMILIAR code files >100 lines, PREFER:
 1. `outline` first (10-20 lines of structure)
 2. `read_file` with offset/limit for the specific section you need
 
-NEVER read a large file in full — outline+targeted read saves 75% tokens.
+Avoid reading a large file in full — outline+targeted read saves 75% tokens.
 
 Bash OK for: npm/node/git/docker/curl, pipes, compound commands.
-**Exceptions** (use built-in Read): images, PDFs, Jupyter notebooks.
+**Built-in OK for:** images, PDFs, notebooks, Glob (always), `.claude/settings.json` and `.claude/settings.local.json`.
+
+## Edit Workflow
+
+Prefer:
+1. collect all known hunks for one file
+2. send one `edit_file` call with batched edits
+3. carry `revision` from `read_file` into `base_revision` on follow-up edits
+4. use `replace_between` for large block rewrites
+5. use `verify` before rereading a file after staleness
+
+Avoid:
+- chained same-file `edit_file` calls when all edits are already known
+- full-file rewrites for local changes
+- using `bulk_replace` for structural block rewrites
 
 # Explanatory Style
 

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@levnikolaevich/hex-line-mcp",
-  "version": "1.3.1",
+  "version": "1.3.3",
+  "mcpName": "io.github.levnikolaevich/hex-line-mcp",
   "type": "module",
   "description": "Hash-verified file editing MCP + token efficiency hook for AI coding agents. 11 tools: read, edit, write, grep, outline, verify, directory_tree, file_info, setup_hooks, changes, bulk_replace.",
   "main": "server.mjs",
@@ -10,7 +11,7 @@
   "files": [
     "server.mjs",
     "hook.mjs",
-    "benchmark.mjs",
+    "benchmark/",
     "lib/",
     "README.md",
     "output-style.md"
@@ -20,15 +21,26 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "node --test test/*.mjs",
+    "benchmark": "node benchmark/index.mjs",
+    "benchmark:diagnostic": "node benchmark/index.mjs --diagnostics",
+    "benchmark:diagnostic:graph": "node benchmark/index.mjs --diagnostics --with-graph",
     "check": "node --check server.mjs && node --check hook.mjs"
   },
+  "_dep_notes": {
+    "web-tree-sitter": "Pinned ^0.25.0: v0.26 ABI incompatible with tree-sitter-wasms 0.1.x (built with tree-sitter-cli 0.20.8). Language.load() silently fails.",
+    "zod": "Pinned ^3.25.0: zod 4 breaks zod-to-json-schema (used by MCP SDK internally). Tool parameter descriptions not sent to clients. Revisit when MCP SDK switches to z.toJSONSchema().",
+    "better-sqlite3": "Optional. Used only by lib/graph-enrich.mjs for readonly access to hex-graph .codegraph/index.db. Graceful fallback if absent."
+  },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.0",
+    "@levnikolaevich/hex-common": "file:../hex-common",
+    "@modelcontextprotocol/sdk": "^1.27.0",
     "diff": "^8.0.3",
     "ignore": "^7.0.5",
-    "tree-sitter-wasms": "^0.1.0",
-    "web-tree-sitter": "^0.25.0",
-    "zod": "^3.24.0"
+    "zod": "^3.25.0",
+    "@vscode/ripgrep": "^1.15.9"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.0.0"
   },
   "author": "Lev Nikolaevich <https://github.com/levnikolaevich>",
   "license": "MIT",