@grapgrap/aeira 1.0.0

package/README.en.md

@@ -0,0 +1,92 @@
+# aeira
+
+A CLI tool that structures markdown wikilink relationships without app dependency.
+
+[English](README.en.md) [한국어](README.md)
+
+## Why
+
+Wikilinks (`[[]]`) in markdown documents express relationships between documents.
+But as wikilinks accumulate, the full picture of those relationships remains invisible. Which documents reference which, and how many steps connect two documents -- you cannot know without tracing them yourself.
+
+aeira builds these relationships into a directed graph, navigable from the command line.
+
+## Commands
+
+aeira operates through four commands.
+
+### init
+
+Register a document collection by specifying a source path.
+
+```sh
+aeira init ./my-docs
+```
+
+### sync
+
+Parse wikilinks to build and update the graph. Only changed documents are processed incrementally.
+
+```sh
+aeira sync                  # use cwd as source
+aeira sync -s ./my-docs     # specify source path
+```
+
+### search
+
+Search documents by keyword and display outgoing links alongside each result.
+
+```sh
+aeira search "keyword"
+aeira search -s ./my-docs "keyword"
+```
+
+### graph
+
+Three primitives for navigating the graph.
+
+```sh
+# List 1-hop neighbors
+aeira graph neighbors node-name
+
+# Find all paths between two nodes
+aeira graph path from-node to-node
+
+# Show entire graph
+aeira graph all
+
+# Specify source path
+aeira graph neighbors -s ./my-docs node-name
+```
+
+All query commands support JSON output with the `--json` flag.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js >= 22
+- [ir](https://github.com/vlwkaos/ir) -- `brew install vlwkaos/tap/ir`
+
+### Installation
+
+```sh
+npm install -g aeira
+```
+
+### First Use
+
+Build the graph by specifying a source path.
+
+```sh
+aeira init ./my-docs
+cd ./my-docs
+aeira sync
+```
+
+After sync, you can navigate the graph.
+
+```sh
+aeira graph neighbors some-document
+aeira search "query"
+```

package/README.md

@@ -0,0 +1,92 @@
+# aeira
+
+마크다운 위키링크의 관계를 앱 종속 없이 구조화하는 CLI 도구.
+
+[English](README.en.md) [한국어](README.md)
+
+## 왜 만들었는가
+
+마크다운 문서에서 위키링크(`[[]]`)는 문서 간 관계를 표현한다.
+하지만 위키링크가 늘어나도 관계의 전체 그림은 보이지 않는다. 어떤 문서가 어떤 문서를 참조하는지, 두 문서가 몇 단계를 거쳐 연결되는지는 직접 따라가 보기 전에는 알 수 없다.
+
+aeira는 이 관계를 방향 그래프로 구축하여 커맨드라인에서 탐색할 수 있게 한다.
+
+## 명령어
+
+aeira는 네 가지 명령으로 동작한다.
+
+### init
+
+source 경로를 지정하여 문서 컬렉션을 등록한다.
+
+```sh
+aeira init ./my-docs
+```
+
+### sync
+
+위키링크를 파싱하여 그래프를 구축하고 갱신한다. 변경된 문서만 증분 처리한다.
+
+```sh
+aeira sync                  # cwd를 source로 사용
+aeira sync -s ./my-docs     # source 경로 지정
+```
+
+### search
+
+키워드로 문서를 검색하고, 각 결과의 outgoing links를 함께 표시한다.
+
+```sh
+aeira search "키워드"
+aeira search -s ./my-docs "키워드"
+```
+
+### graph
+
+그래프를 탐색하는 세 가지 프리미티브를 제공한다.
+
+```sh
+# 1-hop 이웃 조회
+aeira graph neighbors node-name
+
+# 두 노드 간 경로 탐색
+aeira graph path from-node to-node
+
+# 전체 그래프 출력
+aeira graph all
+
+# source 경로 지정
+aeira graph neighbors -s ./my-docs node-name
+```
+
+모든 조회 명령은 `--json` 플래그로 JSON 출력을 지원한다.
+
+## 시작하기
+
+### 사전 요구
+
+- Node.js >= 22
+- [ir](https://github.com/vlwkaos/ir) -- `brew install vlwkaos/tap/ir`
+
+### 설치
+
+```sh
+npm install -g aeira
+```
+
+### 첫 사용
+
+source 경로를 지정하여 그래프를 구축한다.
+
+```sh
+aeira init ./my-docs
+cd ./my-docs
+aeira sync
+```
+
+sync 이후 그래프를 탐색할 수 있다.
+
+```sh
+aeira graph neighbors some-document
+aeira search "검색어"
+```

package/dist/cli.js

@@ -0,0 +1,583 @@
+import { defineCommand, runMain } from "citty";
+import { existsSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { z } from "zod/v4";
+import { homedir } from "node:os";
+import Database from "better-sqlite3";
+//#region src/ir.ts
+function isNotFound(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+const searchResultRow = z.object({
+	path: z.string(),
+	title: z.string(),
+	score: z.number(),
+	snippet: z.string().nullable().optional()
+});
+function searchCollection(collection, query) {
+	try {
+		const output = execFileSync("ir", [
+			"search",
+			query,
+			"-c",
+			collection,
+			"--json"
+		], { encoding: "utf-8" });
+		return z.array(searchResultRow).parse(JSON.parse(output));
+	} catch (error) {
+		if (isNotFound(error)) throw new Error("ir이 설치되어 있지 않습니다. brew install vlwkaos/tap/ir로 설치하세요.", { cause: error });
+		throw error;
+	}
+}
+function updateCollection(collection) {
+	try {
+		execFileSync("ir", ["update", collection], { stdio: "inherit" });
+	} catch (error) {
+		if (isNotFound(error)) throw new Error("ir이 설치되어 있지 않습니다. brew install vlwkaos/tap/ir로 설치하세요.", { cause: error });
+		throw error;
+	}
+}
+function initCollection(collection, sourcePath) {
+	try {
+		execFileSync("ir", [
+			"collection",
+			"add",
+			collection,
+			sourcePath
+		], { stdio: "inherit" });
+	} catch (error) {
+		if (isNotFound(error)) throw new Error("ir이 설치되어 있지 않습니다. brew install vlwkaos/tap/ir로 설치하세요.", { cause: error });
+		throw error;
+	}
+	updateCollection(collection);
+}
+z.object({ hash: z.string() });
+const edgeRow = z.object({
+	source_path: z.string(),
+	target_path: z.string()
+});
+const documentContentRow = z.object({
+	path: z.string(),
+	content: z.string(),
+	hash: z.string()
+});
+const pathRow = z.object({ path: z.string() });
+//#endregion
+//#region src/store/utils.ts
+const DEFAULT_IR_CONFIG_DIR = join(homedir(), ".config", "ir");
+function getCollectionDbPath(collectionName, irConfigDir = DEFAULT_IR_CONFIG_DIR) {
+	return join(irConfigDir, "collections", `${collectionName}.sqlite`);
+}
+function parsePaths(rows) {
+	return z.array(pathRow).parse(rows).map((row) => row.path);
+}
+//#endregion
+//#region src/store/store.ts
+function ensureSchema(database) {
+	database.exec(`
+    CREATE TABLE IF NOT EXISTS aeira_edges (
+      source_path TEXT NOT NULL,
+      target_path TEXT NOT NULL,
+      PRIMARY KEY (source_path, target_path)
+    );
+    CREATE TABLE IF NOT EXISTS aeira_sync_state (
+      source_path TEXT PRIMARY KEY,
+      hash TEXT NOT NULL
+    );
+  `);
+}
+function createStore(database) {
+	ensureSchema(database);
+	const insertEdge = database.prepare("INSERT INTO aeira_edges (source_path, target_path) VALUES (?, ?)");
+	const insertSyncState = database.prepare("INSERT INTO aeira_sync_state (source_path, hash) VALUES (?, ?)");
+	const selectAllEdges = database.prepare("SELECT source_path, target_path FROM aeira_edges");
+	const selectActiveDocuments = database.prepare("SELECT path FROM documents WHERE active = 1");
+	const selectAddedDocuments = database.prepare(`
+    SELECT d.path FROM documents d
+    LEFT JOIN aeira_sync_state s ON d.path = s.source_path
+    WHERE d.active = 1 AND s.source_path IS NULL
+  `);
+	const selectChangedDocuments = database.prepare(`
+    SELECT d.path FROM documents d
+    JOIN aeira_sync_state s ON d.path = s.source_path
+    WHERE d.active = 1 AND d.hash != s.hash
+  `);
+	const selectRemovedDocuments = database.prepare(`
+    SELECT s.source_path as path FROM aeira_sync_state s
+    LEFT JOIN documents d ON s.source_path = d.path AND d.active = 1
+    WHERE d.id IS NULL
+  `);
+	const readDocumentContent = database.prepare("SELECT d.path, c.doc as content, d.hash FROM documents d JOIN content c ON d.hash = c.hash WHERE d.active = 1 AND d.path = ?");
+	const deleteEdgesBySource = database.prepare("DELETE FROM aeira_edges WHERE source_path = ?");
+	const deleteSyncStateBySource = database.prepare("DELETE FROM aeira_sync_state WHERE source_path = ?");
+	return {
+		loadEdges() {
+			const rows = z.array(edgeRow).parse(selectAllEdges.all());
+			const activeDocumentPaths = new Set(z.array(pathRow).parse(selectActiveDocuments.all()).map((row) => row.path));
+			const nodes = new Set(activeDocumentPaths);
+			const dangling = /* @__PURE__ */ new Set();
+			const outgoing = /* @__PURE__ */ new Map();
+			const incoming = /* @__PURE__ */ new Map();
+			for (const { source_path, target_path } of rows) {
+				nodes.add(source_path);
+				nodes.add(target_path);
+				if (!activeDocumentPaths.has(target_path)) dangling.add(target_path);
+				let targets = outgoing.get(source_path);
+				if (!targets) {
+					targets = /* @__PURE__ */ new Set();
+					outgoing.set(source_path, targets);
+				}
+				targets.add(target_path);
+				let sources = incoming.get(target_path);
+				if (!sources) {
+					sources = /* @__PURE__ */ new Set();
+					incoming.set(target_path, sources);
+				}
+				sources.add(source_path);
+			}
+			return {
+				nodes,
+				dangling,
+				outgoing,
+				incoming
+			};
+		},
+		getChangedDocuments() {
+			return {
+				added: parsePaths(selectAddedDocuments.all()),
+				changed: parsePaths(selectChangedDocuments.all()),
+				removed: parsePaths(selectRemovedDocuments.all())
+			};
+		},
+		getActiveDocumentPaths() {
+			return parsePaths(selectActiveDocuments.all());
+		},
+		readDocumentContents(paths) {
+			const results = [];
+			for (const path of paths) {
+				const raw = readDocumentContent.get(path);
+				if (raw) results.push(documentContentRow.parse(raw));
+			}
+			return results;
+		},
+		purgeDocuments(sourcePaths) {
+			database.transaction(() => {
+				for (const path of sourcePaths) {
+					deleteEdgesBySource.run(path);
+					deleteSyncStateBySource.run(path);
+				}
+			})();
+		},
+		syncDocuments(entries) {
+			database.transaction(() => {
+				for (const entry of entries) {
+					for (const targetPath of entry.targetPaths) insertEdge.run(entry.sourcePath, targetPath);
+					insertSyncState.run(entry.sourcePath, entry.hash);
+				}
+			})();
+		}
+	};
+}
+//#endregion
+//#region src/store/readonly-store.ts
+function createReadonlyStore(database) {
+	const selectAllEdges = database.prepare("SELECT source_path, target_path FROM aeira_edges");
+	const selectActiveDocuments = database.prepare("SELECT path FROM documents WHERE active = 1");
+	return { loadEdges() {
+		const rows = z.array(edgeRow).parse(selectAllEdges.all());
+		const activeDocumentPaths = new Set(z.array(pathRow).parse(selectActiveDocuments.all()).map((row) => row.path));
+		const nodes = new Set(activeDocumentPaths);
+		const dangling = /* @__PURE__ */ new Set();
+		const outgoing = /* @__PURE__ */ new Map();
+		const incoming = /* @__PURE__ */ new Map();
+		for (const { source_path, target_path } of rows) {
+			nodes.add(source_path);
+			nodes.add(target_path);
+			if (!activeDocumentPaths.has(target_path)) dangling.add(target_path);
+			let targets = outgoing.get(source_path);
+			if (!targets) {
+				targets = /* @__PURE__ */ new Set();
+				outgoing.set(source_path, targets);
+			}
+			targets.add(target_path);
+			let sources = incoming.get(target_path);
+			if (!sources) {
+				sources = /* @__PURE__ */ new Set();
+				incoming.set(target_path, sources);
+			}
+			sources.add(source_path);
+		}
+		return {
+			nodes,
+			dangling,
+			outgoing,
+			incoming
+		};
+	} };
+}
+//#endregion
+//#region src/commands/init.ts
+const init = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize ir collection for source"
+	},
+	args: { source: {
+		type: "positional",
+		description: "source directory path",
+		required: true
+	} },
+	run({ args }) {
+		const sourcePath = resolve(args.source);
+		const collection = basename(sourcePath);
+		if (existsSync(getCollectionDbPath(collection))) {
+			console.log(`Already initialized: ${collection}`);
+			return;
+		}
+		initCollection(collection, sourcePath);
+		console.log(`Initialized: ${collection}`);
+	}
+});
+//#endregion
+//#region src/graph/graph.ts
+function buildNameIndex(paths) {
+	const index = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const stem = basename(path, ".md");
+		if (!index.has(stem)) index.set(stem, path);
+	}
+	return index;
+}
+//#endregion
+//#region src/graph/query.ts
+function neighbors(graph, node, direction = "both") {
+	const outgoing = direction !== "incoming" ? graph.outgoing.get(node) : void 0;
+	const incoming = direction !== "outgoing" ? graph.incoming.get(node) : void 0;
+	return [...new Set([...outgoing ?? [], ...incoming ?? []])].toSorted();
+}
+function findPaths(graph, from, to, maxPaths = 20) {
+	const results = [];
+	function traverse(current, path, visited) {
+		if (results.length >= maxPaths) return;
+		if (current === to) {
+			results.push([...path]);
+			return;
+		}
+		const targets = graph.outgoing.get(current);
+		if (!targets) return;
+		for (const next of targets) {
+			if (visited.has(next)) continue;
+			visited.add(next);
+			path.push(next);
+			traverse(next, path, visited);
+			path.pop();
+			visited.delete(next);
+		}
+	}
+	traverse(from, [from], new Set([from]));
+	return results;
+}
+function snapshot(graph) {
+	const nodes = [...graph.nodes].toSorted();
+	let edges = [];
+	for (const [source, targets] of graph.outgoing) for (const target of targets) edges.push([source, target]);
+	edges = edges.toSorted((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+	return {
+		nodes,
+		edges
+	};
+}
+//#endregion
+//#region src/wikilink.ts
+function parseWikiLinks(text) {
+	const cleaned = stripExcludedRegions(text);
+	const pattern = /(?<!!)\[\[([^[\]|]+)(?:\|([^[\]]+))?\]\]/g;
+	const links = [];
+	let match;
+	while ((match = pattern.exec(cleaned)) !== null) {
+		const target = match[1].trim();
+		const alias = match[2]?.trim();
+		if (!target || target.includes("#") || target.includes("/")) continue;
+		links.push(alias ? {
+			target,
+			alias
+		} : { target });
+	}
+	return links;
+}
+function stripExcludedRegions(text) {
+	return text.replace(/^---\n[\s\S]*?\n---\n?/, "").replace(/^(`{3,})[^\n]*\n[\s\S]*?\n\1\s*$/gm, "").replace(/^(~{3,})[^\n]*\n[\s\S]*?\n\1\s*$/gm, "").replace(/(\n\n)((?:(?:    |\t)[^\n]*(?:\n|$))+)/g, "$1").replace(/<!--[\s\S]*?-->/g, "").replace(/``(.+?)``/g, "").replace(/`([^`]+)`/g, "");
+}
+//#endregion
+//#region src/commands/sync.ts
+const sync = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Sync wikilink graph from source"
+	},
+	args: { source: {
+		type: "string",
+		description: "source directory path",
+		alias: "s",
+		default: process.cwd()
+	} },
+	run({ args }) {
+		const sourcePath = resolve(args.source);
+		const collection = basename(sourcePath);
+		const dbPath = getCollectionDbPath(collection);
+		if (!existsSync(dbPath)) initCollection(collection, sourcePath);
+		else updateCollection(collection);
+		const db = new Database(dbPath);
+		try {
+			const store = createStore(db);
+			const changes = store.getChangedDocuments();
+			if (changes.added.length + changes.changed.length + changes.removed.length === 0) {
+				console.log("No changes detected.");
+				return;
+			}
+			const nameIndex = buildNameIndex(store.getActiveDocumentPaths());
+			store.purgeDocuments([...changes.removed, ...changes.changed]);
+			const affected = [...changes.changed, ...changes.added];
+			const entries = store.readDocumentContents(affected).map((doc) => {
+				const links = parseWikiLinks(doc.content);
+				const targetPaths = [...new Set(links.map((link) => nameIndex.get(link.target) ?? link.target))];
+				return {
+					sourcePath: doc.path,
+					targetPaths,
+					hash: doc.hash
+				};
+			});
+			store.syncDocuments(entries);
+			console.log(`Synced: +${changes.added.length} ~${changes.changed.length} -${changes.removed.length}`);
+		} finally {
+			db.close();
+		}
+	}
+});
+//#endregion
+//#region src/commands/search.ts
+const search = defineCommand({
+	meta: {
+		name: "search",
+		description: "Search documents via ir"
+	},
+	args: {
+		query: {
+			type: "positional",
+			description: "search query",
+			required: true
+		},
+		source: {
+			type: "string",
+			description: "source directory path",
+			alias: "s",
+			default: process.cwd()
+		},
+		json: {
+			type: "boolean",
+			description: "output as JSON",
+			default: false
+		}
+	},
+	run({ args }) {
+		const collection = basename(resolve(args.source));
+		const dbPath = getCollectionDbPath(collection);
+		if (!existsSync(dbPath)) {
+			console.error(`Collection not found: ${collection}. Run 'aeira sync' first.`);
+			process.exit(1);
+		}
+		const results = searchCollection(collection, args.query);
+		if (results.length === 0) {
+			console.log("No results found.");
+			return;
+		}
+		const database = new Database(dbPath, { readonly: true });
+		try {
+			const graph = createReadonlyStore(database).loadEdges();
+			if (args.json) {
+				const output = results.map((result) => ({
+					path: result.path,
+					title: result.title,
+					score: result.score,
+					snippet: result.snippet ?? void 0,
+					links: neighbors(graph, result.path, "outgoing")
+				}));
+				console.log(JSON.stringify(output, null, 2));
+			} else for (let index = 0; index < results.length; index++) {
+				const result = results[index];
+				const links = neighbors(graph, result.path, "outgoing");
+				console.log(`[${result.score.toFixed(2)}] ${result.path}`);
+				for (const link of links) console.log(`  → ${link}`);
+				if (index < results.length - 1) console.log();
+			}
+		} finally {
+			database.close();
+		}
+	}
+});
+//#endregion
+//#region src/commands/graph.ts
+function openGraph(source) {
+	const collection = basename(resolve(source));
+	const dbPath = getCollectionDbPath(collection);
+	if (!existsSync(dbPath)) {
+		console.error(`Collection not found: ${collection}. Run 'aeira sync' first.`);
+		process.exit(1);
+	}
+	const database = new Database(dbPath, { readonly: true });
+	return {
+		database,
+		graph: createReadonlyStore(database).loadEdges()
+	};
+}
+const validDirections = new Set([
+	"outgoing",
+	"incoming",
+	"both"
+]);
+//#endregion
+//#region src/cli.ts
+runMain(defineCommand({
+	meta: {
+		name: "aeira",
+		version: "0.0.0",
+		description: "위키링크 기반 문서 관계 그래프 도구"
+	},
+	subCommands: {
+		init,
+		sync,
+		search,
+		graph: defineCommand({
+			meta: {
+				name: "graph",
+				description: "Query wikilink graph"
+			},
+			subCommands: {
+				neighbors: defineCommand({
+					meta: {
+						name: "neighbors",
+						description: "List 1-hop neighbors of a node"
+					},
+					args: {
+						node: {
+							type: "positional",
+							description: "target node",
+							required: true
+						},
+						source: {
+							type: "string",
+							description: "source directory path",
+							alias: "s",
+							default: process.cwd()
+						},
+						direction: {
+							type: "string",
+							description: "outgoing | incoming | both",
+							default: "both"
+						},
+						json: {
+							type: "boolean",
+							description: "output as JSON",
+							default: false
+						}
+					},
+					run({ args }) {
+						if (!validDirections.has(args.direction)) {
+							console.error(`Invalid direction: ${args.direction}. Must be outgoing, incoming, or both.`);
+							process.exit(1);
+						}
+						const { database, graph } = openGraph(args.source);
+						try {
+							const result = neighbors(graph, args.node, args.direction);
+							if (args.json) console.log(JSON.stringify(result, null, 2));
+							else for (const node of result) console.log(node);
+						} finally {
+							database.close();
+						}
+					}
+				}),
+				path: defineCommand({
+					meta: {
+						name: "path",
+						description: "Find all paths between two nodes"
+					},
+					args: {
+						from: {
+							type: "positional",
+							description: "start node",
+							required: true
+						},
+						to: {
+							type: "positional",
+							description: "end node",
+							required: true
+						},
+						source: {
+							type: "string",
+							description: "source directory path",
+							alias: "s",
+							default: process.cwd()
+						},
+						"max-paths": {
+							type: "string",
+							description: "max number of paths",
+							default: "20"
+						},
+						json: {
+							type: "boolean",
+							description: "output as JSON",
+							default: false
+						}
+					},
+					run({ args }) {
+						const { database, graph } = openGraph(args.source);
+						try {
+							const maxPaths = Number.parseInt(args["max-paths"], 10);
+							const result = findPaths(graph, args.from, args.to, maxPaths);
+							if (args.json) console.log(JSON.stringify(result, null, 2));
+							else for (const pathNodes of result) console.log(pathNodes.join(" → "));
+						} finally {
+							database.close();
+						}
+					}
+				}),
+				all: defineCommand({
+					meta: {
+						name: "all",
+						description: "Show entire graph"
+					},
+					args: {
+						source: {
+							type: "string",
+							description: "source directory path",
+							alias: "s",
+							default: process.cwd()
+						},
+						json: {
+							type: "boolean",
+							description: "output as JSON",
+							default: false
+						}
+					},
+					run({ args }) {
+						const { database, graph } = openGraph(args.source);
+						try {
+							const result = snapshot(graph);
+							if (args.json) console.log(JSON.stringify(result, null, 2));
+							else {
+								const nodesInEdges = new Set(result.edges.flatMap(([source, target]) => [source, target]));
+								for (const [source, target] of result.edges) console.log(`${source} → ${target}`);
+								for (const node of result.nodes) if (!nodesInEdges.has(node)) console.log(node);
+							}
+						} finally {
+							database.close();
+						}
+					}
+				})
+			}
+		})
+	}
+}));
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@grapgrap/aeira",
+  "version": "1.0.0",
+  "description": "위키링크 기반 문서 관계 그래프 도구",
+  "license": "MIT",
+  "bin": "./dist/cli.js",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsdown",
+    "type-check": "tsc --noEmit",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "lint": "oxlint",
+    "fmt": "oxfmt --write .",
+    "fmt:check": "oxfmt --check .",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.9.1",
+    "citty": "^0.2.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.15.2",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.59.0",
+    "tsdown": "^0.12.5",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "oxlint --deny-warnings",
+      "oxfmt --write"
+    ]
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "yarn@4.13.0"
+}