@waniwani/kit 0.1.6 → 0.1.8

package/cli/log.mjs

@@ -1,178 +0,0 @@
-/** Build output formatting. Errors point at a file and say how to fix it. */
-
-/** ESC by char code: a raw control byte in source is invisible and fragile. */
-const ESC = String.fromCharCode(27);
-
-const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
-const wrap = (code) => (text) => (useColor ? `${ESC}[${code}m${text}${ESC}[0m` : text);
-
-export const red = wrap("31");
-export const green = wrap("32");
-export const yellow = wrap("33");
-export const dim = wrap("2");
-export const bold = wrap("1");
-
-/**
- * The wordmark, at half the height of the art `waniwani login` prints.
- *
- * Same letterforms: the tall version is six rows of full blocks with a box-glyph
- * drop shadow, and each row here folds two of those together — `▀` where only
- * the upper row had ink, `▄` where only the lower did, `█` where both. Three
- * rows instead of six, at the same width, and nothing about the shapes changes.
- *
- * One colour per row rather than per glyph: a vertical ramp needs three escape
- * sequences instead of two hundred, and reads the same.
- */
-const LOGO = [
-	"██     ██ ▄█▀▀▀█▄ ███▄   ██  ██  ██     ██ ▄█▀▀▀█▄ ███▄   ██  ██",
-	"██ ▄█▄ ██ ██▀▀▀██ ██ ▀█▄ ██  ██  ██ ▄█▄ ██ ██▀▀▀██ ██ ▀█▄ ██  ██",
-	" ▀▀▀ ▀▀▀  ▀▀   ▀▀ ▀▀   ▀▀▀▀  ▀▀   ▀▀▀ ▀▀▀  ▀▀   ▀▀ ▀▀   ▀▀▀▀  ▀▀",
-];
-
-const LOGO_WIDTH = 65;
-
-/** The brand accent, `#04d916`. */
-const ACCENT = [4, 217, 22];
-
-/** How far the first and last rows are mixed toward white and black. */
-const LIGHTEN = 0.42;
-const DARKEN = 0.35;
-
-/**
- * The ramp stop for one row: a tint of the accent at the top, the accent itself
- * in the middle, a shade of it at the bottom — so the wordmark reads as one
- * object lit from above.
- *
- * Interpolated from the row count rather than written out, so the art and the
- * ramp cannot drift apart when either changes.
- */
-function rampStop(index, rows) {
-	// -1 on the first row, 0 in the middle, +1 on the last.
-	const position = rows === 1 ? 0 : (index / (rows - 1)) * 2 - 1;
-	if (position <= 0) {
-		const mix = LIGHTEN * -position;
-		return ACCENT.map((channel) => Math.round(channel + (255 - channel) * mix));
-	}
-	return ACCENT.map((channel) => Math.round(channel * (1 - DARKEN * position)));
-}
-
-/** 24-bit colour is used only where the terminal says it has it. */
-const truecolor = ["truecolor", "24bit"].includes(process.env.COLORTERM ?? "");
-
-/** The six levels each channel can take in the xterm 256-colour cube. */
-const CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
-
-/** The nearest cube entry, for a terminal that does not announce 24-bit colour. */
-function cube([r, g, b]) {
-	const nearest = (channel) =>
-		CUBE_LEVELS.reduce(
-			(best, _, index) =>
-				Math.abs(CUBE_LEVELS[index] - channel) < Math.abs(CUBE_LEVELS[best] - channel) ? index : best,
-			0,
-		);
-	return 16 + 36 * nearest(r) + 6 * nearest(g) + nearest(b);
-}
-
-/** The foreground escape for one row of the ramp. */
-function ramp(index, rows) {
-	const rgb = rampStop(index, rows);
-	if (!truecolor) {
-		return `${ESC}[38;5;${cube(rgb)}m`;
-	}
-	return `${ESC}[38;2;${rgb.join(";")}m`;
-}
-
-/**
- * Print the banner a command opens with.
- *
- * The art needs 65 columns and a terminal that wants colour. A narrower one, a
- * pipe, a CI log or `NO_COLOR` gets the wordmark on one line instead — the same
- * information, and nothing that turns into wrapped garbage in a build log.
- */
-export function banner(version) {
-	// `||`, not `??`: a pty whose window size was never set reports 0 columns,
-	// which is unknown rather than narrow.
-	const columns = process.stdout.columns || 80;
-	if (!useColor || columns < LOGO_WIDTH) {
-		// The wordmark still carries the accent — it is the same banner, narrowed.
-		const mark = useColor ? `${ramp(0, 1)}${ESC}[1mwaniwani${ESC}[0m` : "waniwani";
-		console.log(`\n${mark} ${dim(`v${version}`)}`);
-		return;
-	}
-	console.log("");
-	for (const [index, line] of LOGO.entries()) {
-		console.log(`${ramp(index, LOGO.length)}${line}${ESC}[0m`);
-	}
-	console.log(dim(`v${version}`.padStart(LOGO_WIDTH)));
-	console.log("");
-}
-
-/**
- * One URL a command hands the developer, in the shape every command uses for
- * them. The label is padded so a list of endpoints aligns whether the framework
- * printed the line or this CLI did.
- */
-export function endpoint(label, url) {
-	return `  ${dim(label.padEnd(8))} ${green(url)}`;
-}
-
-function printGroup(entries, marker, color) {
-	const byFile = new Map();
-	for (const entry of entries) {
-		const list = byFile.get(entry.where) ?? [];
-		list.push(entry);
-		byFile.set(entry.where, list);
-	}
-
-	for (const [where, list] of byFile) {
-		console.log(`  ${bold(where)}`);
-		for (const entry of list) {
-			console.log(`  ${color(marker)} ${entry.message}`);
-			if (entry.hint) {
-				console.log(`    ${dim(entry.hint)}`);
-			}
-		}
-		console.log("");
-	}
-}
-
-export function printReport(app, report) {
-	if (!report.ok) {
-		console.log(`\n${red("✗")} ${bold("Build check failed")}\n`);
-		printGroup(report.errors, "└", red);
-		if (report.warnings.length > 0) {
-			printGroup(report.warnings, "└", yellow);
-		}
-		return;
-	}
-
-	const counts = [
-		[app.widgets.length, "widget"],
-		[app.tools.length, "tool"],
-		[app.flows.length, "flow"],
-		[app.endpoints.length, "endpoint"],
-	]
-		.filter(([count]) => count > 0)
-		.map(([count, label]) => `${count} ${label}${count === 1 ? "" : "s"}`);
-
-	console.log(`${green("✓")} ${bold("Build check passed")} ${dim(`— ${counts.join(", ")}`)}`);
-
-	for (const widget of app.widgets) {
-		console.log(`  ${dim("widget")} ${widget.name}`);
-	}
-	for (const tool of app.tools) {
-		console.log(`  ${dim("tool  ")} ${tool.name}`);
-	}
-	for (const flow of app.flows) {
-		console.log(`  ${dim("flow  ")} ${flow.name}`);
-	}
-	// The path, not the filename: what a widget writes into a `fetch()` is the
-	// thing worth checking against this line.
-	for (const endpoint of app.endpoints) {
-		console.log(`  ${dim("api   ")} ${endpoint.path}`);
-	}
-	if (report.warnings.length > 0) {
-		console.log("");
-		printGroup(report.warnings, "└", yellow);
-	}
-}

package/cli/scan.mjs

@@ -1,112 +0,0 @@
-/**
- * Discover an app by walking its folders. Convention, not configuration.
- *
- *   waniwani.config.ts
- *   tools/<name>.ts
- *   widgets/<name>/{widget.ts,ui.tsx}
- *   flows/<name>.ts
- *   api/<path>.ts
- *
- * There is no CSS in that list. Styling is Tailwind, from the distribution
- * template's `src/index.css` — its `@theme` tokens and its `dark` variant — and
- * a widget writes utility classes in `ui.tsx`. Stray `styles.css` files are
- * collected only so the build check can tell an author they are dead.
- */
-
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { basename, extname, join } from "node:path";
-
-const CODE_EXT = new Set([".ts", ".tsx", ".mts"]);
-
-function listFiles(dir) {
-	if (!existsSync(dir)) return [];
-	return readdirSync(dir)
-		.filter((entry) => !entry.startsWith(".") && !entry.startsWith("_"))
-		.map((entry) => join(dir, entry))
-		.filter((path) => statSync(path).isFile());
-}
-
-function listDirs(dir) {
-	if (!existsSync(dir)) return [];
-	return readdirSync(dir)
-		.filter((entry) => !entry.startsWith(".") && !entry.startsWith("_"))
-		.map((entry) => join(dir, entry))
-		.filter((path) => statSync(path).isDirectory());
-}
-
-function stripExt(path) {
-	return basename(path, extname(path));
-}
-
-/**
- * Every code file under `dir`, depth first, as `{ file, segments }` where
- * `segments` is its path below `dir` with the extension gone.
- *
- * `api/` is the one convention folder that nests: an HTTP path has more than
- * one segment, and the only place it can come from without a registry is the
- * filesystem.
- */
-function listTree(dir, trail = []) {
-	if (!existsSync(dir)) return [];
-
-	return readdirSync(dir)
-		.filter((entry) => !entry.startsWith(".") && !entry.startsWith("_"))
-		.flatMap((entry) => {
-			const path = join(dir, entry);
-			if (statSync(path).isDirectory()) {
-				return listTree(path, [...trail, entry]);
-			}
-			if (!CODE_EXT.has(extname(path))) return [];
-			return [{ file: path, segments: [...trail, stripExt(path)] }];
-		});
-}
-
-/**
- * The URL an endpoint file is served at: its position under the app root,
- * `/api` included, since that is the folder's name.
- *
- * `index` names the directory itself, so `api/cal/index.ts` answers `/api/cal`
- * — the one place a filename is not taken verbatim, and the convention every
- * web framework already uses.
- */
-function endpointPath(segments) {
-	const parts = segments.at(-1) === "index" ? segments.slice(0, -1) : segments;
-	return `/api/${parts.join("/")}`.replace(/\/$/, "") || "/api";
-}
-
-export function scanApp(root) {
-	const configFile = [join(root, "waniwani.config.ts"), join(root, "waniwani.config.js")].find(
-		existsSync,
-	);
-
-	const tools = listFiles(join(root, "tools"))
-		.filter((file) => CODE_EXT.has(extname(file)))
-		.map((file) => ({ name: stripExt(file), file }));
-
-	const widgets = listDirs(join(root, "widgets")).map((dir) => {
-		const name = basename(dir);
-		const contract = [join(dir, "widget.ts"), join(dir, "widget.tsx")].find(existsSync);
-		const ui = [join(dir, "ui.tsx"), join(dir, "ui.jsx")].find(existsSync);
-		return { name, dir, contract, ui };
-	});
-
-	const flows = listFiles(join(root, "flows"))
-		.filter((file) => CODE_EXT.has(extname(file)))
-		.map((file) => ({ name: stripExt(file), file }));
-
-	const endpoints = listTree(join(root, "api")).map(({ file, segments }) => ({
-		path: endpointPath(segments),
-		segments,
-		file,
-	}));
-
-	// The two paths an author is most likely to expect the kit to pick up. It
-	// imports neither, so a file at either one is styling that never reaches the
-	// browser — the kind of silent no-op the build check exists to name.
-	const strayStyles = [
-		join(root, "styles.css"),
-		...widgets.map((widget) => join(widget.dir, "styles.css")),
-	].filter(existsSync);
-
-	return { root, configFile, tools, widgets, flows, endpoints, strayStyles };
-}

package/cli/template.mjs

@@ -1,190 +0,0 @@
-/**
- * Resolve the distribution template.
- *
- * The template is a separate public repo, consumed as-is. Nothing is forked
- * into this package: the generator downloads the repo at a pinned commit,
- * caches it, and copies the plumbing out of it. What ships to customers is the
- * same tree anyone can read on GitHub, clone, and deploy by hand.
- *
- * Sources:
- *   github:OWNER/REPO#REF   a GitHub repo at a branch, tag, or SHA (default)
- *   /path/to/checkout       a local clone, for working on the template itself
- *
- * Override per command with `--template <source>` or `WANIWANI_TEMPLATE`.
- */
-
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-
-/**
- * A commit, not a branch.
- *
- * A published version of this package is frozen, and what it generates has to
- * be frozen with it. While the default was `beta`, the ref was re-resolved on
- * the customer's machine at every command, so a push to that branch changed the
- * output of every installed copy, and the assertions that catch a layout move
- * (`REQUIRED` and `assertSeam` in `./codegen.mjs`) fired in a customer's
- * terminal. Pinning a commit moves that failure into this repo's CI, where
- * `scripts/template-contract.mjs` builds a real app against the pin before a
- * release goes out.
- *
- * Bumping it is a one-line diff, and `scripts/bump-deps.mjs` proposes it. The
- * commit is on the template's `beta` branch: the generator is written against
- * that branch's layout (`vite.config.ts`, `src/server.ts`, `src/views/`), and
- * `main` is still the older `server/` + `web/` + `api/` split, which it cannot
- * absorb. An annotated tag can replace the SHA here whenever the template grows
- * one, with no change to the resolver.
- *
- * This commit is `beta`'s head, and it reads `search` and `tracking` off
- * `src/waniwani.ts` — the two fields `generateServerApp` emits from the app's
- * `defineApp({ ... })`. That pairing is the reason to bump the two together:
- * moving the pin here without the generator emitting those fields compiles to
- * TS2339, and the contract is what catches it.
- *
- * Working on the template itself does not need a release: pass `--template` or
- * set `WANIWANI_TEMPLATE` to a branch ref or a local checkout.
- */
-export const DEFAULT_TEMPLATE =
-	"github:WaniWani-AI/mcp-distribution-template#c0d00e72a3733a5f42389731fe6bbaf7e0e07863";
-
-const CACHE_ROOT = join(homedir(), ".cache", "waniwani", "templates");
-
-/** `github:owner/repo#ref` -> its parts. */
-function parseGithub(source) {
-	const match = /^github:([^/]+)\/([^#]+)(?:#(.+))?$/.exec(source);
-	if (!match) return null;
-	return { owner: match[1], repo: match[2], ref: match[3] ?? "main" };
-}
-
-/** A full commit SHA, which is already the thing a ref has to be resolved to. */
-function isSha(ref) {
-	return /^[0-9a-f]{40}$/i.test(ref);
-}
-
-/**
- * Resolve a ref to a commit SHA, so a cache entry is content-addressed and two
- * builds of the same ref cannot silently differ.
- */
-async function resolveSha({ owner, repo, ref }) {
-	// The pinned default is a commit, and asking the API to resolve a commit to
-	// itself is a round trip that can rate-limit, fail, or go down. A cached
-	// pin then needs no network at all, which is the point of pinning.
-	if (isSha(ref)) return ref.toLowerCase();
-
-	let response;
-	try {
-		response = await fetch(`https://api.github.com/repos/${owner}/${repo}/commits/${ref}`, {
-			headers: { Accept: "application/vnd.github.sha" },
-		});
-	} catch (cause) {
-		// Unreachable network. A cached template is a reasonable answer.
-		throw Object.assign(new Error(`cannot reach GitHub: ${cause.message}`), { offline: true });
-	}
-
-	// A bad ref is the caller's mistake, not a network problem — falling back
-	// to a cached template here would hide the typo.
-	if (!response.ok) {
-		throw new Error(
-			`GitHub returned ${response.status} for ${owner}/${repo}@${ref}` +
-				(response.status === 404 ? " — check the repo name and ref, or that it is public" : ""),
-		);
-	}
-	return (await response.text()).trim();
-}
-
-async function download({ owner, repo, sha }, destination) {
-	const response = await fetch(
-		`https://codeload.github.com/${owner}/${repo}/tar.gz/${sha}`,
-	);
-	if (!response.ok) {
-		throw new Error(`could not download ${owner}/${repo}@${sha}: ${response.status}`);
-	}
-
-	const archive = join(tmpdir(), `waniwani-template-${sha}.tar.gz`);
-	writeFileSync(archive, Buffer.from(await response.arrayBuffer()));
-
-	// Extract into a staging directory first, so an interrupted run cannot
-	// leave a half-populated cache entry that later builds would trust.
-	const staging = `${destination}.partial`;
-	rmSync(staging, { recursive: true, force: true });
-	mkdirSync(staging, { recursive: true });
-
-	const result = spawnSync("tar", ["-xzf", archive, "-C", staging, "--strip-components=1"]);
-	rmSync(archive, { force: true });
-	if (result.status !== 0) {
-		rmSync(staging, { recursive: true, force: true });
-		throw new Error(`could not extract the template archive: ${result.stderr?.toString().trim()}`);
-	}
-
-	rmSync(destination, { recursive: true, force: true });
-	spawnSync("mv", [staging, destination]);
-}
-
-/** The newest cache entry for a repo, used when the network is unavailable. */
-function newestCached(owner, repo) {
-	if (!existsSync(CACHE_ROOT)) return null;
-	const prefix = `${owner}-${repo}-`;
-	const entries = readdirSync(CACHE_ROOT)
-		.filter((name) => name.startsWith(prefix))
-		.map((name) => ({ name, mtime: statSync(join(CACHE_ROOT, name)).mtimeMs }))
-		.sort((a, b) => b.mtime - a.mtime);
-	return entries[0] ? join(CACHE_ROOT, entries[0].name) : null;
-}
-
-/**
- * @param source `github:owner/repo#ref` or a local path
- * @returns `{ dir, source, ref, sha, cached, local }`
- */
-export async function resolveTemplate(source = DEFAULT_TEMPLATE) {
-	const github = parseGithub(source);
-
-	if (!github) {
-		const dir = resolve(source);
-		if (!existsSync(dir)) {
-			throw new Error(`template not found: ${dir}`);
-		}
-		return { dir, source, local: true };
-	}
-
-	const { owner, repo, ref } = github;
-	mkdirSync(CACHE_ROOT, { recursive: true });
-
-	let sha;
-	try {
-		sha = await resolveSha(github);
-	} catch (error) {
-		const fallback = error.offline && newestCached(owner, repo);
-		if (!fallback) throw error;
-		return {
-			dir: fallback,
-			source,
-			ref,
-			sha: fallback.split("-").pop(),
-			cached: true,
-			offline: true,
-		};
-	}
-
-	const dir = join(CACHE_ROOT, `${owner}-${repo}-${sha}`);
-	const cached = existsSync(dir);
-	if (!cached) {
-		await download({ owner, repo, sha }, dir);
-	}
-
-	return { dir, source, ref, sha, cached };
-}
-
-/** One-line description of what a build used, for logs and provenance files. */
-export function describeTemplate(template) {
-	if (template.local) return `${template.dir} (local)`;
-	const state = template.offline ? "offline, cached" : template.cached ? "cached" : "downloaded";
-	// A pinned source already carries the commit, so printing the source verbatim
-	// would repeat all 40 characters of it next to the short form. Collapse to
-	// the repo, and say that the commit came from a pin rather than a branch.
-	const github = parseGithub(template.source);
-	const pinned = github && isSha(github.ref);
-	const origin = pinned ? `github:${github.owner}/${github.repo}` : template.source;
-	return `${origin} @ ${template.sha?.slice(0, 7)} (${pinned ? `pinned, ${state}` : state})`;
-}