@topik/cli 0.1.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Topik Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+import { boolean, command, positional, run, string } from "@drizzle-team/brocli";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+import { compile, validateResources, watch } from "@topik/core";
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+import { parseAllDocuments } from "yaml";
+//#region src/errors.ts
+var CliError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CliError";
+	}
+};
+//#endregion
+//#region src/validation-output.ts
+function formatValidationFailure(errors, resourceCount, context) {
+	const lines = errors.map((error) => `${error.resource}: ${error.path} ${error.message}`);
+	lines.push("");
+	lines.push(`${errors.length} validation error(s) in ${resourceCount} resources while ${context}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/compile/index.ts
+const formatExtensions = {
+	json: ".json",
+	jsonl: ".jsonl",
+	yaml: ".yaml"
+};
+async function toYaml(value) {
+	if (process.versions.bun) return Bun.YAML.stringify(value);
+	const { stringify } = await import("yaml");
+	return stringify(value);
+}
+function serialize(resource, format) {
+	switch (format) {
+		case "json": return Promise.resolve(JSON.stringify(resource, null, 2) + "\n");
+		case "jsonl": return Promise.resolve(JSON.stringify(resource) + "\n");
+		case "yaml": return toYaml(resource);
+	}
+}
+const compile$1 = command({
+	name: "compile",
+	desc: "Compile wiki content into Topik resource files",
+	options: {
+		dir: positional("dir").desc("Path to the content directory").default("."),
+		outDir: string("out-dir").alias("o").desc("Output directory for compiled resources"),
+		format: string("format").alias("f").desc("Output format").enum("json", "jsonl", "yaml").default("json"),
+		dryRun: boolean("dry-run").desc("Show what would be compiled without writing files").default(false),
+		clean: boolean("clean").desc("Remove existing output before compiling").default(false),
+		validate: boolean("validate").desc("Validate compiled resources against schemas").default(false)
+	},
+	handler: async (options) => {
+		const dir = resolve(options.dir);
+		const format = options.format;
+		const { resources } = await compile({ dir });
+		if (options.validate) {
+			const { valid, errors } = validateResources(resources);
+			if (!valid) throw new CliError(formatValidationFailure(errors, resources.length, "validating compiled output"));
+		}
+		const ext = formatExtensions[format];
+		if (options.dryRun) {
+			for (const resource of resources) console.log(`${resource.type}/${resource.name}${ext}`);
+			console.log(`\n${resources.length} resources (dry run)`);
+			return;
+		}
+		const outDir = options.outDir ? resolve(options.outDir) : join(dir, ".topik", "resources");
+		if (options.clean) await rm(outDir, {
+			recursive: true,
+			force: true
+		});
+		const types = new Set(resources.map((r) => r.type));
+		await Promise.all([...types].map((type) => mkdir(join(outDir, type), { recursive: true })));
+		await Promise.all(resources.map(async (resource) => writeFile(join(outDir, resource.type, `${resource.name}${ext}`), await serialize(resource, format))));
+		console.log(`Compiled ${resources.length} resources to ${outDir}`);
+	}
+});
+//#endregion
+//#region src/dev/index.ts
+const ASSET_EXTENSIONS = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".ico": "image/x-icon",
+	".mp4": "video/mp4",
+	".webm": "video/webm"
+};
+function sendSSE(res, event, data) {
+	res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+function handleResources(watcher, _req, res) {
+	res.writeHead(200, {
+		"Content-Type": "application/json",
+		"Access-Control-Allow-Origin": "*"
+	});
+	res.end(JSON.stringify({ resources: [...watcher.resources.values()] }));
+}
+function handleEvents(watcher, _req, res) {
+	res.writeHead(200, {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive",
+		"Access-Control-Allow-Origin": "*"
+	});
+	sendSSE(res, "sync", { resources: Object.fromEntries(watcher.resources) });
+	const onUpdate = (key, resource) => {
+		sendSSE(res, "update", {
+			key,
+			resource
+		});
+	};
+	watcher.on("update", onUpdate);
+	res.on("close", () => {
+		watcher.off("update", onUpdate);
+	});
+}
+const dev = command({
+	name: "dev",
+	desc: "Start a development server that watches for content changes",
+	options: {
+		dir: positional("dir").desc("Path to the content directory").default("."),
+		port: string("port").alias("p").desc("Port to listen on").default("50001")
+	},
+	handler: async (options) => {
+		const dir = resolve(options.dir);
+		const port = parseInt(options.port, 10);
+		console.log(`Watching ${dir} for changes...`);
+		const watcher = await watch({ dir });
+		console.log(`Compiled ${watcher.resources.size} resources`);
+		watcher.on("error", (error) => {
+			console.error("Compile error:", error.message);
+		});
+		watcher.on("update", (key) => {
+			console.log(`Updated ${key}`);
+		});
+		const server = createServer((req, res) => {
+			if (req.method === "OPTIONS") {
+				res.writeHead(204, {
+					"Access-Control-Allow-Origin": "*",
+					"Access-Control-Allow-Methods": "GET, OPTIONS",
+					"Access-Control-Allow-Headers": "Content-Type"
+				});
+				res.end();
+				return;
+			}
+			const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+			if (req.method === "GET" && url.pathname === "/health") {
+				res.writeHead(200, {
+					"Content-Type": "application/json",
+					"Access-Control-Allow-Origin": "*"
+				});
+				res.end(JSON.stringify({ status: "ok" }));
+				return;
+			}
+			if (req.method === "GET" && url.pathname === "/resources") {
+				handleResources(watcher, req, res);
+				return;
+			}
+			if (req.method === "GET" && url.pathname === "/events") {
+				handleEvents(watcher, req, res);
+				return;
+			}
+			if (req.method === "GET") {
+				const mime = ASSET_EXTENSIONS[extname(url.pathname)];
+				if (mime) {
+					const filePath = resolve(join(dir, url.pathname));
+					if (filePath.startsWith(dir + "/") && existsSync(filePath)) {
+						readFile(filePath).then((data) => {
+							res.writeHead(200, {
+								"Content-Type": mime,
+								"Access-Control-Allow-Origin": "*"
+							});
+							res.end(data);
+						}).catch(() => {
+							res.writeHead(500, { "Access-Control-Allow-Origin": "*" });
+							res.end();
+						});
+						return;
+					}
+				}
+			}
+			res.writeHead(404, {
+				"Content-Type": "text/plain",
+				"Access-Control-Allow-Origin": "*"
+			});
+			res.end("Not Found");
+		});
+		server.listen(port, () => {
+			console.log(`Dev server listening on http://localhost:${port}`);
+		});
+		process.on("SIGINT", async () => {
+			server.close();
+			await watcher.close();
+			process.exit(0);
+		});
+	}
+});
+//#endregion
+//#region src/validate/index.ts
+function parseJson(path, content) {
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new CliError(`Failed to parse JSON resource file ${path}`, { cause: error });
+	}
+}
+function parseJsonl(path, content) {
+	return content.split("\n").map((line, index) => ({
+		line,
+		index: index + 1
+	})).filter(({ line }) => line.trim().length > 0).map(({ line, index }) => {
+		try {
+			return JSON.parse(line);
+		} catch (error) {
+			throw new CliError(`Failed to parse JSONL resource file ${path} at line ${index}`, { cause: error });
+		}
+	});
+}
+function parseYaml(path, content) {
+	try {
+		return parseAllDocuments(content).filter((document) => document.contents !== null).map((document) => {
+			if (document.errors.length > 0) throw document.errors[0];
+			return document.toJS();
+		});
+	} catch (error) {
+		throw new CliError(`Failed to parse YAML resource file ${path}`, { cause: error });
+	}
+}
+async function readResourceFile(path) {
+	const content = await readFile(path, "utf-8");
+	switch (extname(path).toLowerCase()) {
+		case ".json": return [parseJson(path, content)];
+		case ".jsonl": return parseJsonl(path, content);
+		case ".yaml":
+		case ".yml": return parseYaml(path, content);
+		default: throw new CliError(`Unsupported resource file format for ${path}`);
+	}
+}
+async function loadResources(path) {
+	if ((await stat(path).catch((error) => {
+		throw new CliError(`Failed to access ${path}`, { cause: error });
+	})).isFile()) return readResourceFile(path);
+	const resourceFiles = (await readdir(path, {
+		withFileTypes: true,
+		recursive: true
+	})).filter((entry) => {
+		if (!entry.isFile()) return false;
+		const extension = extname(entry.name).toLowerCase();
+		return extension === ".json" || extension === ".jsonl" || extension === ".yaml" || extension === ".yml";
+	});
+	return (await Promise.all(resourceFiles.map((entry) => readResourceFile(join(entry.parentPath, entry.name))))).flat();
+}
+const validate = command({
+	name: "validate",
+	desc: "Validate wiki resource files in JSON, JSONL, or YAML format against schemas",
+	options: { path: positional("path").desc("File or directory to validate").required() },
+	handler: async (options) => {
+		const resources = await loadResources(resolve(options.path));
+		if (resources.length === 0) {
+			console.log("No resource files found.");
+			return;
+		}
+		const { valid, errors } = validateResources(resources);
+		if (valid) console.log(`Validated ${resources.length} resources`);
+		else throw new CliError(formatValidationFailure(errors, resources.length, "validating resources"));
+	}
+});
+//#endregion
+//#region src/cli.ts
+try {
+	await run([
+		compile$1,
+		dev,
+		validate
+	], {
+		name: "topik",
+		description: "Topik CLI"
+	});
+} catch (error) {
+	if (error instanceof CliError) {
+		console.error(error.message);
+		process.exit(1);
+	}
+	throw error;
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@topik/cli",
+  "version": "0.1.0-alpha.2",
+  "description": "Topik CLI",
+  "license": "MIT",
+  "bin": {
+    "topik": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/cli.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@drizzle-team/brocli": "^0.11.0",
+    "yaml": "^2.7.0",
+    "@topik/core": "0.1.0-alpha.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "@types/node": "^24",
+    "@typescript/native-preview": "7.0.0-dev.20260316.1",
+    "typescript": "^5",
+    "vite-plus": "^0.1.12"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}