kitfly 0.2.1 → 0.2.4

package/src/__tests__/slides-charts-lite-runtime.bun.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "bun:test";
+
+type ChartsLiteHooks = {
+	parseSpec: (text: string) => {
+		kind: string;
+		labels: string[];
+		data: number[];
+		title: string;
+		color: string;
+		height: number;
+	} | null;
+};
+
+async function loadHooks(): Promise<ChartsLiteHooks> {
+	// @ts-expect-error JS plugin helper file
+	await import("../../plugins-dist/slides-charts-lite-runtime.js");
+	const hooks = (globalThis as any).__kitflyChartsLiteTest as ChartsLiteHooks | undefined;
+	if (!hooks) throw new Error("slides-charts-lite test hooks not found on globalThis");
+	return hooks;
+}
+
+test("slides-charts-lite: parses valid chart block", async () => {
+	const hooks = await loadHooks();
+	const spec = hooks.parseSpec(`kind: bar\nlabels: ["Q1","Q2"]\ndata: [10, 20]\nheight: 400`);
+	expect(spec).toEqual({
+		kind: "bar",
+		labels: ["Q1", "Q2"],
+		data: [10, 20],
+		title: "",
+		color: "primary",
+		height: 400,
+	});
+});
+
+test("slides-charts-lite: rejects mismatched labels/data", async () => {
+	const hooks = await loadHooks();
+	const spec = hooks.parseSpec(`kind: line\nlabels: ["A","B"]\ndata: [1]`);
+	expect(spec).toBeNull();
+});
+
+test("slides-charts-lite: rejects unknown kind", async () => {
+	const hooks = await loadHooks();
+	const spec = hooks.parseSpec(`kind: scatter\nlabels: ["A"]\ndata: [1]`);
+	expect(spec).toBeNull();
+});

package/src/cli.ts

@@ -12,6 +12,9 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadSiteConfig } from "./shared.ts";
 
+// Exit cleanly when piped output is closed early (e.g., `kitfly docs show x | less` then quit)
+process.on("SIGPIPE", () => process.exit(0));
+
 // Resolve paths relative to CLI location (works in binary too)
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, "..");
@@ -76,23 +79,27 @@ Usage:
   kitfly servers          List running dev servers
   kitfly stop <port|all>  Stop dev server(s)
   kitfly logs <port>      View daemon server logs
+  kitfly docs [list|show]  Browse embedded documentation
   kitfly version          Show version (use 'version extended' for details)
   kitfly help             Show this help
 
 Dev options:
   --port <n>    Server port [env: KITFLY_DEV_PORT] (default: 3333)
   --host <h>    Server host [env: KITFLY_DEV_HOST] (default: localhost)
+  --profile <p> Active content profile [env: KITFLY_PROFILE]
   --daemon, -d  Run in background, return immediately
   --json        Output JSON (implies --daemon)
   --no-open     Don't open browser
 
 Build options:
   --out <dir>   Output directory [env: KITFLY_BUILD_OUT] (default: dist)
+  --profile <p> Active content profile [env: KITFLY_PROFILE]
   --no-raw      Don't include raw markdown
 
 Bundle options:
   --out <dir>   Output directory [env: KITFLY_BUNDLE_OUT] (default: bundles)
   --name <file> Bundle filename (default: bundle.html)
+  --profile <p> Active content profile [env: KITFLY_PROFILE]
   --no-raw      Don't include raw markdown [env: KITFLY_BUNDLE_RAW]
 
 Stop options:
@@ -204,6 +211,7 @@ async function main() {
 			}
 
 			const host = (flags.host as string) || "localhost";
+			const profile = (flags.profile as string | undefined) ?? process.env.KITFLY_PROFILE;
 
 			// Warn if binding to all interfaces
 			if (host === "0.0.0.0" || host === "::") {
@@ -271,7 +279,7 @@ async function main() {
 
 			if (daemon) {
 				// Daemon mode: spawn detached process using shell redirection
-				const { mkdir, writeFile } = await import("node:fs/promises");
+				const { mkdir, writeFile, open: fsOpen } = await import("node:fs/promises");
 				const logsDir = join(getKitflyHome(), "logs");
 				await mkdir(logsDir, { recursive: true });
 
@@ -283,18 +291,53 @@ async function main() {
 
 				// Build command with shell redirection for logging
 				// Pass --log-format structured so dev.ts enables structured request logging
-				// Use nohup to prevent SIGHUP on terminal close
-				const shellCmd = `nohup bun run "${devScript}" "${folder}" --port ${port} --host "${host}" --no-open --log-format structured > "${logPath}" 2>&1 &`;
-
-				const proc = Bun.spawn(["sh", "-c", shellCmd], {
-					cwd: process.cwd(),
-					stdout: "ignore",
-					stderr: "ignore",
-					stdin: "ignore",
-				});
-
-				// Wait for shell to spawn the background process
-				await proc.exited;
+				const profileArg = profile ? ` --profile "${profile}"` : "";
+
+				// Open log file as a write handle to pass as stdout/stderr for the child
+				const logFd = await fsOpen(logPath, "a");
+
+				let proc: ReturnType<typeof Bun.spawn>;
+				if (process.platform === "win32") {
+					// On Windows, use Bun.spawn with detached:true and stdio redirected to log file.
+					// nohup and sh -c are not available; Bun's detached mode achieves the same.
+					const args = [
+						"bun",
+						"run",
+						devScript,
+						folder,
+						"--port",
+						String(port),
+						"--host",
+						host,
+						...(profile ? ["--profile", profile] : []),
+						"--no-open",
+						"--log-format",
+						"structured",
+					];
+					proc = Bun.spawn(args, {
+						cwd: process.cwd(),
+						stdout: logFd.fd,
+						stderr: logFd.fd,
+						stdin: "ignore",
+						detached: true,
+					});
+					proc.unref();
+					await logFd.close();
+					// Give Windows a moment to spawn the child before proc.exited resolves
+					await new Promise((resolve) => setTimeout(resolve, 200));
+				} else {
+					// Unix: nohup via sh -c keeps the process alive after terminal close
+					await logFd.close();
+					const shellCmd = `nohup bun run "${devScript}" "${folder}" --port ${port} --host "${host}"${profileArg} --no-open --log-format structured > "${logPath}" 2>&1 &`;
+					proc = Bun.spawn(["sh", "-c", shellCmd], {
+						cwd: process.cwd(),
+						stdout: "ignore",
+						stderr: "ignore",
+						stdin: "ignore",
+					});
+					// Wait for shell to spawn the background process
+					await proc.exited;
+				}
 
 				// Give server a moment to start
 				await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -348,7 +391,7 @@ async function main() {
 			} else {
 				// Foreground mode: run directly
 				const { dev } = await import("../scripts/dev.ts");
-				await dev({ folder, port, host, open });
+				await dev({ folder, port, host, open, profile });
 			}
 			break;
 		}
@@ -357,8 +400,9 @@ async function main() {
 			const folder = positional[0] || ".";
 			const out = (flags.out as string) || "dist";
 			const raw = flags.raw !== false; // --no-raw disables raw markdown
+			const profile = (flags.profile as string | undefined) ?? process.env.KITFLY_PROFILE;
 			const { build } = await import("../scripts/build.ts");
-			await build({ folder, out, raw });
+			await build({ folder, out, raw, profile });
 			break;
 		}
 
@@ -367,8 +411,9 @@ async function main() {
 			const out = (flags.out as string) || "bundles";
 			const name = (flags.name as string) || "bundle.html";
 			const raw = flags.raw !== false; // --no-raw disables raw markdown
+			const profile = (flags.profile as string | undefined) ?? process.env.KITFLY_PROFILE;
 			const { bundleSite } = await import("../scripts/bundle.ts");
-			await bundleSite({ folder, out, name, raw });
+			await bundleSite({ folder, out, name, raw, profile });
 			break;
 		}
 
@@ -531,12 +576,47 @@ async function main() {
 			const follow = flags.follow === true || flags.f === true;
 
 			if (follow) {
-				// tail -f equivalent using Bun.spawn
-				const proc = Bun.spawn(["tail", "-f", logFile], {
-					stdout: "inherit",
-					stderr: "inherit",
-				});
-				await proc.exited;
+				if (process.platform !== "win32") {
+					// Unix: tail -f is available and efficient
+					const proc = Bun.spawn(["tail", "-f", logFile], {
+						stdout: "inherit",
+						stderr: "inherit",
+					});
+					await proc.exited;
+				} else {
+					// Windows: tail -f is not available; poll the file for new content
+					const { watch } = await import("node:fs");
+					const { open: fsOpen } = await import("node:fs/promises");
+					let fd: import("node:fs/promises").FileHandle;
+					try {
+						fd = await fsOpen(logFile, "r");
+					} catch {
+						console.error(`No log file found for port ${logPort}`);
+						console.error(`  Expected: ${logFile}`);
+						process.exit(1);
+					}
+					// Print existing content first
+					const existing = await fd.readFile("utf-8");
+					if (existing.length > 0) process.stdout.write(existing);
+					let offset = Buffer.byteLength(existing, "utf-8");
+					// Watch for changes and stream new bytes
+					const watcher = watch(logFile, async () => {
+						const buf = Buffer.alloc(65536);
+						const { bytesRead } = await fd.read(buf, 0, buf.length, offset);
+						if (bytesRead > 0) {
+							offset += bytesRead;
+							process.stdout.write(buf.subarray(0, bytesRead));
+						}
+					});
+					// Keep running until Ctrl+C
+					await new Promise<void>((resolve) => {
+						process.on("SIGINT", () => {
+							watcher.close();
+							void fd.close();
+							resolve();
+						});
+					});
+				}
 			} else {
 				const { readFile } = await import("node:fs/promises");
 				try {
@@ -555,6 +635,28 @@ async function main() {
 			break;
 		}
 
+		case "docs": {
+			const sub = positional[0];
+			const { docsList, docsShow } = await import("./commands/docs.ts");
+			if (!sub || sub === "list") {
+				docsList();
+			} else if (sub === "show") {
+				const slug = positional[1];
+				if (!slug) {
+					console.error("Error: Slug required.\n");
+					console.error("Usage: kitfly docs show <slug>");
+					console.error("       kitfly docs list");
+					process.exit(1);
+				}
+				docsShow(slug);
+			} else {
+				console.error(`Unknown docs subcommand: "${sub}"\n`);
+				console.error("Usage: kitfly docs [list|show <slug>]");
+				process.exit(1);
+			}
+			break;
+		}
+
 		case "version":
 		case "-v":
 		case "--version": {

package/src/commands/docs.ts

@@ -0,0 +1,71 @@
+/**
+ * kitfly docs — browse embedded documentation from the CLI.
+ *
+ * Subcommands:
+ *   kitfly docs [list]       List available doc slugs with titles
+ *   kitfly docs show <slug>  Output raw markdown to stdout
+ */
+
+import { EMBEDDED_DOCS } from "../generated/embedded-docs.ts";
+
+// Build a Map from the generated tuple array for O(1) lookup
+const docsMap = new Map<string, { title: string; content: string }>();
+for (const [slug, title, content] of EMBEDDED_DOCS) {
+	docsMap.set(slug, { title, content });
+}
+
+export function docsList(): void {
+	if (docsMap.size === 0) {
+		console.log("No embedded documentation available.");
+		return;
+	}
+
+	const slugs = [...docsMap.keys()].sort();
+	const maxSlug = Math.max(...slugs.map((s) => s.length));
+
+	console.log(`Embedded documentation (${slugs.length} topics):\n`);
+
+	for (const slug of slugs) {
+		const entry = docsMap.get(slug);
+		if (entry) console.log(`  ${slug.padEnd(maxSlug + 2)}${entry.title}`);
+	}
+
+	console.log(`\nUsage: kitfly docs show <slug>`);
+}
+
+export function docsShow(slug: string): void {
+	const entry = docsMap.get(slug);
+
+	if (!entry) {
+		const suggestions = findSimilar(slug, [...docsMap.keys()], 3);
+		console.error(`Not found: "${slug}"`);
+		if (suggestions.length > 0) {
+			console.error(`Did you mean: ${suggestions.join(", ")}?`);
+		}
+		console.error(`\nUse 'kitfly docs list' to see available topics.`);
+		process.exit(1);
+	}
+
+	console.log(entry.content);
+}
+
+/**
+ * Find similar slugs by prefix or substring match.
+ * Returns up to `max` results, prioritizing prefix matches.
+ */
+export function findSimilar(query: string, slugs: string[], max: number): string[] {
+	const q = query.toLowerCase();
+	const prefixMatches: string[] = [];
+	const substringMatches: string[] = [];
+
+	for (const slug of slugs) {
+		const s = slug.toLowerCase();
+		if (s.startsWith(q) || q.startsWith(s)) {
+			prefixMatches.push(slug);
+		} else if (s.includes(q) || q.includes(s)) {
+			substringMatches.push(slug);
+		}
+	}
+
+	return [...prefixMatches, ...substringMatches].slice(0, max);
+}

package/src/commands/init.ts

@@ -4,7 +4,7 @@
  * Usage:
  *   kitfly init <name> [--template <type>] [--no-git]
  *
- * Templates: minimal, handbook (more coming)
+ * Templates: minimal, handbook, brief (more coming)
  */
 
 import { readdir, stat } from "node:fs/promises";