@kibhq/core 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,68 @@
+# @kibhq/core
+
+Core engine for [kib](https://github.com/keeganthomp/kib) — the headless knowledge compiler.
+
+This package provides the vault operations, LLM providers, ingest extractors, compile engine, BM25 search, and RAG query engine that power the `kib` CLI.
+
+## Install
+
+```bash
+npm i @kibhq/core
+```
+
+> Most users should install the CLI instead: `npm i -g @kibhq/cli`
+
+## What's inside
+
+| Module | Description |
+|--------|-------------|
+| **Vault** | Filesystem operations, manifest tracking, config management |
+| **Ingest** | Extractors for web pages, PDFs, YouTube, GitHub repos, and local files |
+| **Compile** | LLM-powered compilation from raw sources into structured wiki articles |
+| **Search** | BM25 full-text search with English stemming |
+| **Query** | RAG engine — retrieves relevant articles and generates cited answers |
+| **Lint** | 5 health-check rules (orphan articles, broken links, stale sources, etc.) |
+| **Skills** | Skill loader and runner for extensible vault operations |
+| **Providers** | LLM adapters for Anthropic Claude, OpenAI, and Ollama |
+
+## Usage
+
+```typescript
+import {
+  resolveVaultRoot,
+  loadManifest,
+  loadConfig,
+  SearchIndex,
+  queryVault,
+  ingestSource,
+  compileVault,
+  createProvider,
+} from "@kibhq/core";
+
+// Find the vault
+const root = resolveVaultRoot();
+const config = await loadConfig(root);
+const manifest = await loadManifest(root);
+
+// Search
+const index = new SearchIndex();
+await index.build(root, "all");
+const results = index.search("attention mechanisms", { limit: 10 });
+
+// RAG query
+const provider = await createProvider(config.provider.default, config.provider.model);
+const answer = await queryVault(root, "how does self-attention work?", provider);
+console.log(answer.answer);
+```
+
+## LLM Providers
+
+| Provider | Env Variable | Default Model |
+|----------|-------------|---------------|
+| Anthropic | `ANTHROPIC_API_KEY` | claude-sonnet-4-20250514 |
+| OpenAI | `OPENAI_API_KEY` | gpt-4o |
+| Ollama | (auto-detect localhost:11434) | llama3 |
+
+## License
+
+MIT

package/package.json

@@ -1,12 +1,14 @@
 {
 	"name": "@kibhq/core",
-	"version": "0.1.0",
+	"version": "0.3.0",
+	"description": "Core engine for kib — vault operations, LLM providers, ingest, compile, search, and query",
 	"type": "module",
 	"exports": {
 		".": "./src/index.ts"
 	},
 	"files": [
 		"src",
+		"README.md",
 		"package.json"
 	],
 	"repository": {
@@ -15,6 +17,16 @@
 		"directory": "packages/core"
 	},
 	"license": "MIT",
+	"keywords": [
+		"knowledge-base",
+		"wiki",
+		"llm",
+		"compiler",
+		"rag",
+		"ai",
+		"search",
+		"bm25"
+	],
 	"publishConfig": {
 		"access": "public"
 	},

package/src/compile/backlinks.ts

@@ -1,6 +1,4 @@
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { WIKI_DIR } from "../constants.js";
 import { listWiki } from "../vault.js";
 import { extractWikilinks, parseFrontmatter } from "./diff.js";
 
@@ -76,5 +74,5 @@ export function generateGraphMd(graph: LinkGraph): string {
 		lines.push("(no connections yet)");
 	}
 
-	return lines.join("\n") + "\n";
+	return `${lines.join("\n")}\n`;
 }

package/src/compile/compiler.test.ts

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ingestSource } from "../ingest/ingest.js";
 import type { CompletionParams, CompletionResult, LLMProvider, StreamChunk } from "../types.js";
-import { initVault, listWiki, loadManifest, readWiki } from "../vault.js";
+import { initVault, loadManifest, readWiki } from "../vault.js";
 import { compileVault } from "./compiler.js";
 
 let tempDir: string;
@@ -27,7 +27,7 @@ function createMockProvider(responses: string[]): LLMProvider {
 	let callIndex = 0;
 	return {
 		name: "mock",
-		async complete(params: CompletionParams): Promise<CompletionResult> {
+		async complete(_params: CompletionParams): Promise<CompletionResult> {
 			const content = responses[callIndex] ?? "[]";
 			callIndex++;
 			return {

package/src/compile/compiler.ts

@@ -1,12 +1,10 @@
-import { readFile } from "node:fs/promises";
-import { join, relative } from "node:path";
-import { GRAPH_FILE, INDEX_FILE, WIKI_DIR } from "../constants.js";
+import { join } from "node:path";
+import { GRAPH_FILE, INDEX_FILE } from "../constants.js";
 import { hash } from "../hash.js";
 import { countWords } from "../ingest/normalize.js";
 import type { CompileResult, LLMProvider, Manifest, VaultConfig } from "../types.js";
 import {
 	deleteFile,
-	listWiki,
 	loadManifest,
 	readIndex,
 	readRaw,

package/src/compile/index-manager.test.ts

@@ -139,7 +139,7 @@ describe("generateIndexMd", () => {
 		);
 
 		const index = await generateIndexMd(root);
-		const conceptsIdx = index.indexOf("## Concepts");
+		const _conceptsIdx = index.indexOf("## Concepts");
 		const alphaIdx = index.indexOf("Alpha Concept");
 		const midIdx = index.indexOf("Mid Concept");
 		const zebraIdx = index.indexOf("Zebra Concept");

package/src/compile/index-manager.ts

@@ -113,7 +113,7 @@ export async function generateIndexMd(root: string): Promise<string> {
 		}
 	}
 
-	return lines.join("\n") + "\n";
+	return `${lines.join("\n")}\n`;
 }
 
 /**

package/src/ingest/extractors/github.ts

@@ -30,7 +30,13 @@ export function createGithubExtractor(): Extractor {
 					`Failed to fetch repo info: ${repoResponse.status} ${repoResponse.statusText}`,
 				);
 			}
-			const repoData = (await repoResponse.json()) as any;
+			const repoData = (await repoResponse.json()) as {
+				full_name?: string;
+				description?: string;
+				stargazers_count?: number;
+				language?: string;
+				default_branch?: string;
+			};
 
 			// Fetch README
 			let readme = "";
@@ -51,9 +57,11 @@ export function createGithubExtractor(): Extractor {
 				const ref = branch ?? repoData.default_branch ?? "main";
 				const treeResponse = await fetch(`${apiBase}/git/trees/${ref}`, { headers });
 				if (treeResponse.ok) {
-					const treeData = (await treeResponse.json()) as any;
+					const treeData = (await treeResponse.json()) as {
+						tree?: { type: string; path: string }[];
+					};
 					const files = (treeData.tree ?? [])
-						.map((f: any) => `${f.type === "tree" ? "📁" : "📄"} ${f.path}`)
+						.map((f) => `${f.type === "tree" ? "📁" : "📄"} ${f.path}`)
 						.slice(0, 50); // Cap at 50 entries
 					fileTree = files.join("\n");
 				}

package/src/ingest/extractors/pdf.ts

@@ -2,14 +2,39 @@ import { readFile } from "node:fs/promises";
 import { basename, extname } from "node:path";
 import type { ExtractOptions, Extractor, ExtractResult } from "./interface.js";
 
+type PdfParseFn = (buffer: Buffer) => Promise<{
+	text: string;
+	numpages: number;
+	info?: { Title?: string; Author?: string };
+	date?: string;
+}>;
+
 // Lazy-load pdf-parse (it's heavy)
-let pdfParse: any = null;
+let pdfParse: PdfParseFn | null = null;
 
-async function getPdfParse() {
+async function getPdfParse(): Promise<PdfParseFn> {
 	if (!pdfParse) {
-		const mod = await import("pdf-parse");
-		// pdf-parse exports default as the function in some builds
-		pdfParse = mod.default ?? mod;
+		const { PDFParse } = await import("pdf-parse");
+		pdfParse = async (buffer: Buffer) => {
+			const parser = new PDFParse({ data: buffer });
+
+			try {
+				const textResult = await parser.getText();
+				const infoResult = await parser.getInfo();
+
+				return {
+					text: textResult.text,
+					numpages: textResult.total,
+					info: {
+						Title: getOptionalString(infoResult.info?.Title),
+						Author: getOptionalString(infoResult.info?.Author),
+					},
+					date: formatPdfDate(infoResult.getDateNode().CreationDate),
+				};
+			} finally {
+				await parser.destroy();
+			}
+		};
 	}
 	return pdfParse;
 }
@@ -50,7 +75,7 @@ export function createPdfExtractor(): Extractor {
 				formatFilename(input);
 
 			const author = data.info?.Author ?? undefined;
-			const date = data.info?.CreationDate ? parsePdfDate(data.info.CreationDate) : undefined;
+			const date = data.date;
 
 			// Clean up the extracted text into readable markdown
 			const content = formatPdfText(data.text, title);
@@ -119,12 +144,15 @@ function formatPdfText(text: string, title: string): string {
 }
 
 /**
- * Parse PDF date format (D:20240315120000+00'00') to ISO date string.
+ * Normalize parsed PDF dates to YYYY-MM-DD.
  */
-function parsePdfDate(dateStr: string): string | undefined {
-	const match = dateStr.match(/D:(\d{4})(\d{2})(\d{2})/);
-	if (match) {
-		return `${match[1]}-${match[2]}-${match[3]}`;
+function formatPdfDate(date: Date | null | undefined): string | undefined {
+	if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+		return undefined;
 	}
-	return undefined;
+	return date.toISOString().slice(0, 10);
+}
+
+function getOptionalString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
 }

package/src/ingest/extractors/youtube.ts

@@ -82,7 +82,10 @@ async function fetchVideoPage(videoId: string): Promise<VideoPageData> {
 			`https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v=${videoId}&format=json`,
 		);
 		if (response.ok) {
-			const data = (await response.json()) as any;
+			const data = (await response.json()) as {
+				title?: string;
+				author_name?: string;
+			};
 			return {
 				title: data.title ?? null,
 				description: null, // oembed doesn't include description
@@ -139,9 +142,7 @@ async function fetchTranscript(videoId: string): Promise<string> {
 function parseTranscriptXml(xml: string): string {
 	const lines: string[] = [];
 	const textRegex = /<text[^>]*>([\s\S]*?)<\/text>/g;
-	let match: RegExpExecArray | null;
-
-	while ((match = textRegex.exec(xml)) !== null) {
+	for (let match = textRegex.exec(xml); match !== null; match = textRegex.exec(xml)) {
 		const text = match[1]!
 			.replace(/&amp;/g, "&")
 			.replace(/&lt;/g, "<")

package/src/ingest/ingest.ts

@@ -1,4 +1,3 @@
-import { basename, extname, resolve } from "node:path";
 import { hash } from "../hash.js";
 import type { IngestResult, Manifest, SourceEntry, SourceType } from "../types.js";
 import { loadManifest, saveManifest, writeRaw } from "../vault.js";
@@ -161,7 +160,7 @@ function categoryForType(sourceType: SourceType): string {
 
 function findExistingSource(
 	manifest: Manifest,
-	uri: string,
+	_uri: string,
 	contentHash: string,
 ): { id: string; path: string } | null {
 	for (const [id, source] of Object.entries(manifest.sources)) {

package/src/lint/lint.test.ts

@@ -3,7 +3,6 @@ import { writeFile as fsWriteFile, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ingestSource } from "../ingest/ingest.js";
-import type { Manifest } from "../types.js";
 import { initVault, loadManifest, saveManifest, writeWiki } from "../vault.js";
 import { lintVault } from "./lint.js";
 
@@ -61,7 +60,7 @@ describe("lint engine", () => {
 
 		// Update manifest to include articles with backlinks
 		const manifest = await loadManifest(root);
-		manifest.articles["alpha"] = {
+		manifest.articles.alpha = {
 			hash: "a",
 			createdAt: new Date().toISOString(),
 			lastUpdated: new Date().toISOString(),
@@ -73,7 +72,7 @@ describe("lint engine", () => {
 			wordCount: 10,
 			category: "concept",
 		};
-		manifest.articles["beta"] = {
+		manifest.articles.beta = {
 			hash: "b",
 			createdAt: new Date().toISOString(),
 			lastUpdated: new Date().toISOString(),
@@ -103,7 +102,7 @@ describe("lint engine", () => {
 
 		// Add to manifest with no backlinks
 		const manifest = await loadManifest(root);
-		manifest.articles["orphan"] = {
+		manifest.articles.orphan = {
 			hash: "o",
 			createdAt: new Date().toISOString(),
 			lastUpdated: new Date().toISOString(),
@@ -137,7 +136,7 @@ describe("lint engine", () => {
 		);
 
 		const manifest = await loadManifest(root);
-		manifest.articles["test"] = {
+		manifest.articles.test = {
 			hash: "t",
 			createdAt: new Date().toISOString(),
 			lastUpdated: new Date().toISOString(),

package/src/lint/lint.ts

@@ -1,4 +1,4 @@
-import type { LintDiagnostic, Manifest } from "../types.js";
+import type { LintDiagnostic } from "../types.js";
 import { loadManifest } from "../vault.js";
 import { ALL_RULES } from "./rules.js";
 

package/src/lint/rules.ts

@@ -10,7 +10,7 @@ type LintRuleFn = (root: string, manifest: Manifest) => Promise<LintDiagnostic[]
 /**
  * Find articles with no backlinks from other articles (orphans).
  */
-export const orphanRule: LintRuleFn = async (root, manifest) => {
+export const orphanRule: LintRuleFn = async (_root, manifest) => {
 	const diagnostics: LintDiagnostic[] = [];
 
 	for (const [slug, article] of Object.entries(manifest.articles)) {
@@ -132,7 +132,7 @@ export const frontmatterRule: LintRuleFn = async (root) => {
  */
 export const missingRule: LintRuleFn = async (root, manifest) => {
 	const diagnostics: LintDiagnostic[] = [];
-	const wikiDir = `${root}/${WIKI_DIR}`;
+	const _wikiDir = `${root}/${WIKI_DIR}`;
 	const files = await listWiki(root);
 	const articleFiles = files.filter((f) => !f.endsWith("INDEX.md") && !f.endsWith("GRAPH.md"));
 

package/src/providers/anthropic.ts

@@ -1,12 +1,32 @@
 import type { CompletionParams, CompletionResult, LLMProvider, StreamChunk } from "../types.js";
 
+interface ContentBlock {
+	type: string;
+	text?: string;
+}
+
 // Lazy-loaded SDK
-let AnthropicClass: any = null;
+let AnthropicClass: (new () => AnthropicClient) | null = null;
+
+interface AnthropicClient {
+	messages: {
+		create(params: Record<string, unknown>): Promise<{
+			content: ContentBlock[];
+			usage: { input_tokens: number; output_tokens: number };
+			stop_reason: string;
+		}>;
+		stream(params: Record<string, unknown>): AsyncIterable<{
+			type: string;
+			delta: { type: string; text: string };
+			usage?: { input_tokens: number; output_tokens: number };
+		}>;
+	};
+}
 
-async function getClient() {
+async function getClient(): Promise<AnthropicClient> {
 	if (!AnthropicClass) {
 		const mod = await import("@anthropic-ai/sdk");
-		AnthropicClass = mod.default;
+		AnthropicClass = mod.default as unknown as new () => AnthropicClient;
 	}
 	return new AnthropicClass();
 }
@@ -29,8 +49,8 @@ export function createAnthropicProvider(model: string): LLMProvider {
 			});
 
 			const content = response.content
-				.filter((b: any) => b.type === "text")
-				.map((b: any) => b.text)
+				.filter((b) => b.type === "text")
+				.map((b) => b.text ?? "")
 				.join("");
 
 			return {
@@ -99,8 +119,8 @@ export function createAnthropicProvider(model: string): LLMProvider {
 			});
 
 			return response.content
-				.filter((b: any) => b.type === "text")
-				.map((b: any) => b.text)
+				.filter((b) => b.type === "text")
+				.map((b) => b.text ?? "")
 				.join("");
 		},
 	};

package/src/providers/ollama.ts

@@ -30,7 +30,11 @@ export function createOllamaProvider(model: string): LLMProvider {
 				throw new Error(`Ollama request failed: ${response.status} ${response.statusText}`);
 			}
 
-			const data = (await response.json()) as any;
+			const data = (await response.json()) as {
+				message?: { content: string };
+				prompt_eval_count?: number;
+				eval_count?: number;
+			};
 			return {
 				content: data.message?.content ?? "",
 				usage: {
@@ -81,7 +85,12 @@ export function createOllamaProvider(model: string): LLMProvider {
 
 				for (const line of lines) {
 					if (!line.trim()) continue;
-					const data = JSON.parse(line) as any;
+					const data = JSON.parse(line) as {
+						message?: { content: string };
+						done?: boolean;
+						prompt_eval_count?: number;
+						eval_count?: number;
+					};
 					if (data.message?.content) {
 						yield { type: "text", text: data.message.content };
 					}

package/src/providers/openai.ts

@@ -1,12 +1,27 @@
 import type { CompletionParams, CompletionResult, LLMProvider, StreamChunk } from "../types.js";
 
+interface OpenAIClient {
+	chat: {
+		completions: {
+			create(params: Record<string, unknown>): Promise<{
+				choices: {
+					message?: { content: string };
+					finish_reason: string;
+					delta?: { content?: string };
+				}[];
+				usage?: { prompt_tokens: number; completion_tokens: number };
+			}>;
+		};
+	};
+}
+
 // Lazy-loaded SDK
-let OpenAIClass: any = null;
+let OpenAIClass: (new () => OpenAIClient) | null = null;
 
-async function getClient() {
+async function getClient(): Promise<OpenAIClient> {
 	if (!OpenAIClass) {
 		const mod = await import("openai");
-		OpenAIClass = mod.default;
+		OpenAIClass = mod.default as unknown as new () => OpenAIClient;
 	}
 	return new OpenAIClass();
 }

package/src/query/query.test.ts

@@ -3,7 +3,13 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { SearchIndex } from "../search/engine.js";
-import type { CompletionParams, CompletionResult, LLMProvider, StreamChunk } from "../types.js";
+import type {
+	CompletionParams,
+	CompletionResult,
+	LLMProvider,
+	Message,
+	StreamChunk,
+} from "../types.js";
 import { initVault, writeWiki } from "../vault.js";
 import { queryVault } from "./query.js";
 
@@ -133,7 +139,7 @@ describe("queryVault", () => {
 		await index.save(root);
 
 		// Track what gets sent to the provider
-		let receivedMessages: any[] = [];
+		let receivedMessages: Message[] = [];
 		const provider: LLMProvider = {
 			name: "mock",
 			async complete(params: CompletionParams): Promise<CompletionResult> {

package/src/query/query.ts

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { parseFrontmatter } from "../compile/diff.js";
 import { SearchIndex } from "../search/engine.js";
 import type { CompletionResult, LLMProvider, Message } from "../types.js";
-import { listWiki, readIndex } from "../vault.js";
+import { readIndex } from "../vault.js";
 
 export interface QueryOptions {
 	/** Maximum articles to include as context */

package/src/schemas.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { DEFAULT_CATEGORIES, DEFAULTS, MANIFEST_VERSION, RAW_CATEGORIES } from "./constants.js";
+import { DEFAULT_CATEGORIES, DEFAULTS, MANIFEST_VERSION } from "./constants.js";
 
 // ─── Source Types ────────────────────────────────────────────────
 

package/src/search/engine.ts

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parseFrontmatter } from "../compile/diff.js";
-import { CACHE_DIR, VAULT_DIR, WIKI_DIR } from "../constants.js";
+import { CACHE_DIR, VAULT_DIR } from "../constants.js";
 import type { SearchResult } from "../types.js";
 import { listRaw, listWiki } from "../vault.js";
 
@@ -133,18 +133,18 @@ function tokenize(text: string): string[] {
 function stem(word: string): string {
 	if (word.length < 4) return word;
 	// Order matters: try longest suffixes first
-	if (word.endsWith("ization")) return word.slice(0, -7) + "ize";
-	if (word.endsWith("ational")) return word.slice(0, -7) + "ate";
-	if (word.endsWith("iveness")) return word.slice(0, -7) + "ive";
-	if (word.endsWith("fulness")) return word.slice(0, -7) + "ful";
-	if (word.endsWith("ousli")) return word.slice(0, -5) + "ous";
-	if (word.endsWith("ation")) return word.slice(0, -5) + "ate";
+	if (word.endsWith("ization")) return `${word.slice(0, -7)}ize`;
+	if (word.endsWith("ational")) return `${word.slice(0, -7)}ate`;
+	if (word.endsWith("iveness")) return `${word.slice(0, -7)}ive`;
+	if (word.endsWith("fulness")) return `${word.slice(0, -7)}ful`;
+	if (word.endsWith("ousli")) return `${word.slice(0, -5)}ous`;
+	if (word.endsWith("ation")) return `${word.slice(0, -5)}ate`;
 	if (word.endsWith("ness")) return word.slice(0, -4);
 	if (word.endsWith("ment")) return word.slice(0, -4);
-	if (word.endsWith("ting")) return word.slice(0, -3) + "e";
+	if (word.endsWith("ting")) return `${word.slice(0, -3)}e`;
 	if (word.endsWith("ing") && word.length > 5) return word.slice(0, -3);
-	if (word.endsWith("ies") && word.length > 4) return word.slice(0, -3) + "y";
-	if (word.endsWith("ied")) return word.slice(0, -3) + "y";
+	if (word.endsWith("ies") && word.length > 4) return `${word.slice(0, -3)}y`;
+	if (word.endsWith("ied")) return `${word.slice(0, -3)}y`;
 	if (word.endsWith("ous")) return word.slice(0, -3);
 	if (word.endsWith("ful")) return word.slice(0, -3);
 	if (word.endsWith("ers")) return word.slice(0, -3);

package/src/skills/runner.ts

@@ -10,15 +10,7 @@ import type {
 	SkillDefinition,
 	VaultConfig,
 } from "../types.js";
-import {
-	listRaw,
-	listWiki,
-	loadConfig,
-	loadManifest,
-	readIndex,
-	readWiki,
-	writeWiki,
-} from "../vault.js";
+import { listRaw, listWiki, loadConfig, loadManifest, readIndex, writeWiki } from "../vault.js";
 
 export interface RunSkillOptions {
 	/** Additional CLI args */

package/src/skills/skills.test.ts

@@ -2,7 +2,13 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CompletionParams, CompletionResult, LLMProvider, StreamChunk } from "../types.js";
+import type {
+	CompletionResult,
+	LLMProvider,
+	SkillContext,
+	SkillDefinition,
+	StreamChunk,
+} from "../types.js";
 import { initVault, writeWiki } from "../vault.js";
 import { findSkill, loadSkills } from "./loader.js";
 import { runSkill } from "./runner.js";
@@ -119,16 +125,16 @@ describe("skill runner", () => {
 			description: "Test skill context",
 			input: "wiki" as const,
 			output: "report" as const,
-			async run(ctx: any) {
+			async run(ctx: SkillContext) {
 				const articles = await ctx.vault.readWiki();
 				const index = await ctx.vault.readIndex();
 				return {
 					content: `Found ${articles.length} articles. Index length: ${index.length}`,
 				};
 			},
-		};
+		} satisfies SkillDefinition;
 
-		const result = await runSkill(root, testSkill as any);
+		const result = await runSkill(root, testSkill);
 		expect(result.content).toContain("Found 2 articles");
 	});
 });

package/src/vault.ts

@@ -152,7 +152,7 @@ export async function loadConfig(root: string): Promise<VaultConfig> {
 export async function saveConfig(root: string, config: VaultConfig): Promise<void> {
 	const path = join(root, VAULT_DIR, CONFIG_FILE);
 	const tmp = `${path}.tmp`;
-	await writeFile(tmp, TOML.stringify(config as any), "utf-8");
+	await writeFile(tmp, TOML.stringify(config as unknown as TOML.JsonMap), "utf-8");
 	await rename(tmp, path);
 }