@kibhq/cli 0.1.0

package/bin/kib.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+import { loadCredentials } from "../src/ui/setup-provider.js";
+
+// Load saved API keys before anything else
+loadCredentials();
+
+import { main } from "../src/index.js";
+
+main();

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@kibhq/cli",
+	"version": "0.1.0",
+	"type": "module",
+	"bin": {
+		"kib": "./bin/kib.ts"
+	},
+	"files": [
+		"bin",
+		"src",
+		"package.json"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/keeganthomp/kib.git",
+		"directory": "packages/cli"
+	},
+	"license": "MIT",
+	"keywords": [
+		"knowledge-base",
+		"wiki",
+		"llm",
+		"compiler",
+		"cli",
+		"rag",
+		"ai"
+	],
+	"scripts": {
+		"dev": "bun run bin/kib.ts",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"@kibhq/core": "workspace:*",
+		"commander": "^14.0.0",
+		"chalk": "^5.4.1",
+		"ora": "^8.2.0"
+	},
+	"devDependencies": {
+		"@types/bun": "latest",
+		"typescript": "^5.8.3"
+	}
+}

package/src/commands/chat.ts

@@ -0,0 +1,123 @@
+import * as readline from "node:readline";
+import type { Message } from "@kibhq/core";
+import {
+	createProvider,
+	loadConfig,
+	NoProviderError,
+	resolveVaultRoot,
+	VaultNotFoundError,
+} from "@kibhq/core";
+import * as log from "../ui/logger.js";
+import { setupProvider } from "../ui/setup-provider.js";
+
+export async function chat() {
+	let root: string;
+	try {
+		root = resolveVaultRoot();
+	} catch (err) {
+		if (err instanceof VaultNotFoundError) {
+			log.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+
+	const config = await loadConfig(root);
+
+	// Create provider
+	let provider;
+	try {
+		provider = await createProvider(config.provider.default, config.provider.model);
+	} catch (err) {
+		if (err instanceof NoProviderError) {
+			provider = await setupProvider(root);
+		} else {
+			log.error((err as Error).message);
+			process.exit(1);
+		}
+	}
+
+	const { queryVault } = await import("@kibhq/core");
+
+	log.header("interactive session (type /help for commands)");
+
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+		prompt: "  you: ",
+	});
+
+	const history: Message[] = [];
+
+	rl.prompt();
+
+	rl.on("line", async (line) => {
+		const input = line.trim();
+
+		if (!input) {
+			rl.prompt();
+			return;
+		}
+
+		// Handle slash commands
+		if (input.startsWith("/")) {
+			const cmd = input.slice(1).toLowerCase();
+			if (cmd === "exit" || cmd === "quit" || cmd === "q") {
+				console.log();
+				log.dim("Session ended.");
+				rl.close();
+				process.exit(0);
+			}
+			if (cmd === "clear") {
+				history.length = 0;
+				log.dim("Conversation cleared.");
+				rl.prompt();
+				return;
+			}
+			if (cmd === "help") {
+				console.log();
+				log.dim("Commands:");
+				log.dim("  /clear   — clear conversation history");
+				log.dim("  /exit    — end the session");
+				log.dim("  /help    — show this help");
+				console.log();
+				rl.prompt();
+				return;
+			}
+			log.warn(`Unknown command: ${input}. Type /help for available commands.`);
+			rl.prompt();
+			return;
+		}
+
+		// Query the vault
+		console.log();
+		process.stdout.write("  kib: ");
+
+		try {
+			const result = await queryVault(root, input, provider, {
+				history,
+				onChunk: (text) => process.stdout.write(text),
+			});
+
+			console.log("\n");
+
+			// Update conversation history
+			history.push({ role: "user", content: input });
+			history.push({ role: "assistant", content: result.answer });
+
+			// Keep history manageable (last 10 exchanges)
+			while (history.length > 20) {
+				history.shift();
+			}
+		} catch (err) {
+			console.log();
+			log.error((err as Error).message);
+		}
+
+		rl.prompt();
+	});
+
+	rl.on("close", () => {
+		process.exit(0);
+	});
+}

package/src/commands/compile.ts

@@ -0,0 +1,117 @@
+import {
+	createProvider,
+	loadConfig,
+	NoProviderError,
+	resolveVaultRoot,
+	VaultNotFoundError,
+} from "@kibhq/core";
+import * as log from "../ui/logger.js";
+import { setupProvider } from "../ui/setup-provider.js";
+import { createSpinner } from "../ui/spinner.js";
+
+interface CompileOpts {
+	force?: boolean;
+	dryRun?: boolean;
+	source?: string;
+	max?: number;
+}
+
+export async function compile(opts: CompileOpts) {
+	let root: string;
+	try {
+		root = resolveVaultRoot();
+	} catch (err) {
+		if (err instanceof VaultNotFoundError) {
+			log.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+
+	const config = await loadConfig(root);
+
+	log.header("compiling wiki");
+
+	// Create LLM provider
+	let provider;
+	const providerSpinner = createSpinner("Connecting to LLM provider...");
+	providerSpinner.start();
+	try {
+		provider = await createProvider(config.provider.default, config.provider.model);
+		providerSpinner.succeed(`Connected to ${provider.name}`);
+	} catch (err) {
+		providerSpinner.stop();
+		if (err instanceof NoProviderError) {
+			provider = await setupProvider(root);
+		} else {
+			log.error((err as Error).message);
+			process.exit(1);
+		}
+	}
+
+	// Lazy import compile engine
+	const { compileVault } = await import("@kibhq/core");
+
+	const compileSpinner = createSpinner("Compiling sources...");
+	compileSpinner.start();
+
+	try {
+		const result = await compileVault(root, provider, config, {
+			force: opts.force,
+			dryRun: opts.dryRun,
+			sourceFilter: opts.source,
+			maxSources: opts.max,
+			onProgress: (msg) => {
+				compileSpinner.text = `  ${msg}`;
+			},
+		});
+
+		if (result.sourcesCompiled === 0) {
+			compileSpinner.info("No sources pending compilation");
+			log.blank();
+			log.dim("Use --force to recompile all sources");
+			log.blank();
+			return;
+		}
+
+		compileSpinner.succeed(
+			`Compiled ${result.sourcesCompiled} source${result.sourcesCompiled === 1 ? "" : "s"}`,
+		);
+
+		log.blank();
+		if (result.articlesCreated > 0) {
+			log.success(
+				`${result.articlesCreated} article${result.articlesCreated === 1 ? "" : "s"} created`,
+			);
+		}
+		if (result.articlesUpdated > 0) {
+			log.success(
+				`${result.articlesUpdated} article${result.articlesUpdated === 1 ? "" : "s"} updated`,
+			);
+		}
+		if (result.articlesDeleted > 0) {
+			log.info(
+				`${result.articlesDeleted} article${result.articlesDeleted === 1 ? "" : "s"} deleted`,
+			);
+		}
+
+		if (opts.dryRun) {
+			log.blank();
+			log.dim("(dry run — no files were written)");
+
+			if (result.operations.length > 0) {
+				log.blank();
+				for (const op of result.operations) {
+					const symbol = op.op === "create" ? "+" : op.op === "update" ? "~" : "-";
+					log.info(`${symbol} ${op.path}`);
+				}
+			}
+		}
+
+		log.blank();
+	} catch (err) {
+		compileSpinner.fail("Compilation failed");
+		log.error((err as Error).message);
+		process.exit(1);
+	}
+}

package/src/commands/config.ts

@@ -0,0 +1,90 @@
+import { loadConfig, resolveVaultRoot, saveConfig, VaultNotFoundError } from "@kibhq/core";
+import * as log from "../ui/logger.js";
+
+export async function config(key?: string, value?: string, opts?: { list?: boolean }) {
+	let root: string;
+	try {
+		root = resolveVaultRoot();
+	} catch (err) {
+		if (err instanceof VaultNotFoundError) {
+			log.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+
+	const cfg = await loadConfig(root);
+
+	// List all config
+	if (opts?.list || (!key && !value)) {
+		log.header("configuration");
+		printConfig(cfg, "");
+		return;
+	}
+
+	// Get a value
+	if (key && !value) {
+		const val = getNestedValue(cfg, key);
+		if (val === undefined) {
+			log.error(`Unknown config key: ${key}`);
+			process.exit(1);
+		}
+		console.log(val);
+		return;
+	}
+
+	// Set a value
+	if (key && value) {
+		const updated = setNestedValue(cfg, key, parseValue(value));
+		if (!updated) {
+			log.error(`Unknown config key: ${key}`);
+			process.exit(1);
+		}
+		await saveConfig(root, cfg);
+		log.success(`Set ${key} = ${value}`);
+	}
+}
+
+function getNestedValue(obj: any, path: string): unknown {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current == null || typeof current !== "object") return undefined;
+		current = current[part];
+	}
+	return current;
+}
+
+function setNestedValue(obj: any, path: string, value: unknown): boolean {
+	const parts = path.split(".");
+	let current = obj;
+	for (let i = 0; i < parts.length - 1; i++) {
+		if (current == null || typeof current !== "object") return false;
+		current = current[parts[i]!];
+	}
+	const lastKey = parts[parts.length - 1]!;
+	if (current == null || typeof current !== "object" || !(lastKey in current)) {
+		return false;
+	}
+	current[lastKey] = value;
+	return true;
+}
+
+function parseValue(val: string): unknown {
+	if (val === "true") return true;
+	if (val === "false") return false;
+	const num = Number(val);
+	if (!Number.isNaN(num) && val.trim() !== "") return num;
+	return val;
+}
+
+function printConfig(obj: any, prefix: string) {
+	for (const [key, val] of Object.entries(obj)) {
+		const fullKey = prefix ? `${prefix}.${key}` : key;
+		if (val != null && typeof val === "object" && !Array.isArray(val)) {
+			printConfig(val, fullKey);
+		} else {
+			log.keyValue(fullKey, String(val));
+		}
+	}
+}

package/src/commands/export.ts

@@ -0,0 +1,199 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { listWiki, resolveVaultRoot, VaultNotFoundError, WIKI_DIR } from "@kibhq/core";
+import * as log from "../ui/logger.js";
+import { createSpinner } from "../ui/spinner.js";
+
+interface ExportOpts {
+	format: string;
+	output?: string;
+}
+
+export async function exportVault(opts: ExportOpts) {
+	let root: string;
+	try {
+		root = resolveVaultRoot();
+	} catch (err) {
+		if (err instanceof VaultNotFoundError) {
+			log.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+
+	const format = opts.format ?? "markdown";
+	const outputDir = opts.output ?? join(root, "export");
+
+	log.header(`exporting wiki as ${format}`);
+
+	const spinner = createSpinner("Exporting...");
+	spinner.start();
+
+	try {
+		switch (format) {
+			case "markdown":
+				await exportMarkdown(root, outputDir);
+				break;
+			case "html":
+				await exportHtml(root, outputDir);
+				break;
+			default:
+				spinner.fail(`Unsupported format: ${format}`);
+				log.dim("Supported formats: markdown, html");
+				process.exit(1);
+		}
+
+		spinner.succeed(`Exported to ${outputDir}`);
+		log.blank();
+	} catch (err) {
+		spinner.fail("Export failed");
+		log.error((err as Error).message);
+		process.exit(1);
+	}
+}
+
+/**
+ * Export as clean markdown bundle (strip frontmatter, resolve links).
+ */
+async function exportMarkdown(root: string, outputDir: string) {
+	const wikiDir = join(root, WIKI_DIR);
+	const files = await listWiki(root);
+
+	for (const filePath of files) {
+		const content = await readFile(filePath, "utf-8");
+		const relPath = relative(wikiDir, filePath);
+		const outPath = join(outputDir, relPath);
+
+		await mkdir(join(outPath, ".."), { recursive: true });
+
+		// Strip frontmatter
+		const cleaned = content.replace(/^---[\s\S]*?---\s*\n/, "");
+		// Resolve [[wikilinks]] to standard markdown links
+		const resolved = cleaned.replace(
+			/\[\[([^\]]+)\]\]/g,
+			(_, slug: string) => `[${slug}](${slug}.md)`,
+		);
+
+		await writeFile(outPath, resolved, "utf-8");
+	}
+}
+
+/**
+ * Export as a simple HTML static site.
+ */
+async function exportHtml(root: string, outputDir: string) {
+	const wikiDir = join(root, WIKI_DIR);
+	const files = await listWiki(root);
+	const { parseFrontmatter } = await import("@kibhq/core");
+
+	await mkdir(outputDir, { recursive: true });
+
+	const articles: { title: string; relPath: string; htmlPath: string }[] = [];
+
+	for (const filePath of files) {
+		const content = await readFile(filePath, "utf-8");
+		const relPath = relative(wikiDir, filePath);
+		const { frontmatter, body } = parseFrontmatter(content);
+		const title = (frontmatter.title as string) ?? relPath.replace(/\.md$/, "");
+		const htmlPath = relPath.replace(/\.md$/, ".html");
+
+		// Simple markdown → HTML (headings, paragraphs, bold, italic, code, links)
+		const html = simpleMarkdownToHtml(body);
+
+		const page = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; max-width: 720px; margin: 2rem auto; padding: 0 1rem; line-height: 1.6; color: #1a1a1a; }
+    a { color: #0066cc; }
+    code { background: #f4f4f4; padding: 0.2em 0.4em; border-radius: 3px; font-size: 0.9em; }
+    pre { background: #f4f4f4; padding: 1rem; border-radius: 6px; overflow-x: auto; }
+    pre code { background: none; padding: 0; }
+    nav { margin-bottom: 2rem; padding-bottom: 1rem; border-bottom: 1px solid #eee; }
+    nav a { margin-right: 1rem; }
+  </style>
+</head>
+<body>
+  <nav><a href="index.html">Index</a></nav>
+  <h1>${escapeHtml(title)}</h1>
+  ${html}
+</body>
+</html>`;
+
+		const outPath = join(outputDir, htmlPath);
+		await mkdir(join(outPath, ".."), { recursive: true });
+		await writeFile(outPath, page, "utf-8");
+
+		articles.push({ title, relPath, htmlPath });
+	}
+
+	// Generate index.html
+	const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Knowledge Base</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; max-width: 720px; margin: 2rem auto; padding: 0 1rem; line-height: 1.6; color: #1a1a1a; }
+    a { color: #0066cc; }
+    ul { list-style: none; padding: 0; }
+    li { margin: 0.5rem 0; }
+  </style>
+</head>
+<body>
+  <h1>Knowledge Base</h1>
+  <p>${articles.length} articles</p>
+  <ul>
+    ${articles
+			.sort((a, b) => a.title.localeCompare(b.title))
+			.map((a) => `<li><a href="${a.htmlPath}">${escapeHtml(a.title)}</a></li>`)
+			.join("\n    ")}
+  </ul>
+</body>
+</html>`;
+
+	await writeFile(join(outputDir, "index.html"), indexHtml, "utf-8");
+}
+
+function simpleMarkdownToHtml(md: string): string {
+	return (
+		md
+			// Code blocks
+			.replace(/```(\w*)\n([\s\S]*?)```/g, "<pre><code>$2</code></pre>")
+			// Headers
+			.replace(/^### (.+)$/gm, "<h3>$1</h3>")
+			.replace(/^## (.+)$/gm, "<h2>$1</h2>")
+			.replace(/^# (.+)$/gm, "<h1>$1</h1>")
+			// Bold
+			.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+			// Italic
+			.replace(/\*(.+?)\*/g, "<em>$1</em>")
+			// Inline code
+			.replace(/`([^`]+)`/g, "<code>$1</code>")
+			// Wikilinks → HTML links
+			.replace(/\[\[([^\]]+)\]\]/g, '<a href="$1.html">$1</a>')
+			// Standard links
+			.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
+			// Lists
+			.replace(/^- (.+)$/gm, "<li>$1</li>")
+			// Paragraphs
+			.replace(/\n\n/g, "</p><p>")
+			.replace(/^/, "<p>")
+			.replace(/$/, "</p>")
+			// Clean up list items
+			.replace(/<p><li>/g, "<ul><li>")
+			.replace(/<\/li><\/p>/g, "</li></ul>")
+	);
+}
+
+function escapeHtml(str: string): string {
+	return str
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;");
+}

package/src/commands/ingest.ts

@@ -0,0 +1,68 @@
+import { resolveVaultRoot, VaultNotFoundError } from "@kibhq/core";
+import * as log from "../ui/logger.js";
+import { createSpinner } from "../ui/spinner.js";
+
+interface IngestOpts {
+	category?: string;
+	tags?: string;
+	batch?: boolean;
+}
+
+export async function ingest(sources: string[], opts: IngestOpts) {
+	let root: string;
+	try {
+		root = resolveVaultRoot();
+	} catch (err) {
+		if (err instanceof VaultNotFoundError) {
+			log.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+
+	// Lazy import — don't load ingest machinery for other commands
+	const { ingestSource } = await import("@kibhq/core");
+
+	log.header("ingesting sources");
+
+	const tags = opts.tags?.split(",").map((t) => t.trim());
+	let ingested = 0;
+	let skipped = 0;
+
+	for (const source of sources) {
+		const spinner = createSpinner(`Ingesting ${source}`);
+		spinner.start();
+
+		try {
+			const result = await ingestSource(root, source, {
+				category: opts.category,
+				tags,
+			});
+
+			if (result.skipped) {
+				spinner.warn(`Skipped: ${result.skipReason}`);
+				skipped++;
+			} else {
+				spinner.succeed(
+					`${result.title} → ${result.path} (${result.wordCount.toLocaleString()} words)`,
+				);
+				ingested++;
+			}
+		} catch (err) {
+			spinner.fail(`Failed: ${source}`);
+			log.error((err as Error).message);
+		}
+	}
+
+	log.blank();
+	if (ingested > 0) {
+		log.success(
+			`Ingested ${ingested} source${ingested === 1 ? "" : "s"}${skipped > 0 ? `, skipped ${skipped}` : ""}`,
+		);
+		log.blank();
+		log.dim("run kib compile to update the wiki");
+	} else if (skipped > 0) {
+		log.dim(`All ${skipped} source${skipped === 1 ? "" : "s"} already ingested`);
+	}
+	log.blank();
+}

package/src/commands/init.ts

@@ -0,0 +1,54 @@
+import { resolve } from "node:path";
+import { detectProvider, initVault, VaultExistsError } from "@kibhq/core";
+import * as log from "../ui/logger.js";
+
+interface InitOpts {
+	name?: string;
+	provider?: string;
+	force?: boolean;
+}
+
+export async function init(opts: InitOpts) {
+	const cwd = resolve(process.cwd());
+
+	log.header("initializing vault");
+
+	try {
+		// Detect provider
+		const detected = detectProvider();
+		const provider = opts.provider ?? detected.name;
+		const model = detected.model;
+
+		const { root, manifest } = await initVault(cwd, {
+			name: opts.name,
+			provider,
+			model,
+			force: opts.force,
+		});
+
+		log.success("Created .kb/manifest.json");
+		log.success("Created .kb/config.toml");
+		log.success("Created raw/");
+		log.success("Created wiki/");
+		log.success("Created inbox/");
+
+		const providerLabel =
+			provider === "anthropic"
+				? `anthropic (ANTHROPIC_API_KEY)`
+				: provider === "openai"
+					? `openai (OPENAI_API_KEY)`
+					: `ollama (localhost:11434)`;
+
+		log.success(`Detected provider: ${providerLabel}`);
+		log.success(`Model: ${model}`);
+		log.blank();
+		log.dim(`vault ready — start with kib ingest <source>`);
+		log.blank();
+	} catch (err) {
+		if (err instanceof VaultExistsError) {
+			log.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+}