boss-css 0.0.6 → 0.0.7

package/dist/ai/server.cjs

@@ -0,0 +1,433 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_text = require('../api/file/text.cjs');
+const require_ai_skills = require('./skills.cjs');
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/ai/server.ts
+var server_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	name: () => name,
+	onBoot: () => onBoot,
+	onMetaData: () => onMetaData,
+	onSession: () => onSession
+});
+const name = "ai";
+const STATIC_DOC = `### Syntax
+- Use <$$ ...> for Boss props in JSX.
+- Use $$.\$({ ... }) to mark prop objects for compile/runtime.
+- Classname tokens look like color:red or hover:color:red (mostly 1:1 with CSS props).
+
+### Tokens
+- Prefer token keys (color="primary") over $$.token.* when available.
+- Token overrides can be passed via the tokens prop at runtime.
+- Prefer token shorthands for shadows (boxShadow="md") when available.
+
+### Selectors
+- Use pseudos for state (hover, focus, etc.).
+- Use @at for breakpoints and media queries.
+- Use child for nested selectors.
+- Prefer shorthand keys (mobile:...) over at:mobile:...
+- Prefer the device breakpoint for mobile + small screens when available.
+
+### Values
+- Prefer unitless numbers (padding:12) and use _ for space-separated values (padding:10_20).
+- Prefer arrays for shorthands (padding={[0, 10]}).
+- For custom shadows, use arrays (boxShadow={[1, 1, 0, '#fff']}).
+
+### Globals
+- Use $$.css() for global CSS and arbitrary selectors (body, [data-*], etc.).
+
+### Bosswind
+- When Bosswind is enabled, prefer shorthands (flex vs display:flex).
+
+### Strategies
+- inline-first: default for mixed static/dynamic props.
+- classname-first: smaller inline styles; use function values for dynamics.
+- runtime-only: client CSS injection only.
+ - compile pruning: keep props static when you want runtime-free output.
+`;
+const EVENT_NAMES = [
+	"onBoot",
+	"onReady",
+	"onParse",
+	"onPropTree",
+	"onProp",
+	"onCompileProp",
+	"onInit",
+	"onBrowserObjectStart",
+	"onSession",
+	"onMetaData"
+];
+const metaStore = /* @__PURE__ */ new Map();
+let metaStoreApi = null;
+let llmsFile = null;
+let llmsFilePath = null;
+const getAiConfig = (api) => {
+	return api.ai ?? api.userConfig?.ai ?? {};
+};
+const getBaseDir = (api, session) => {
+	if (session?.baseDir) return session.baseDir;
+	if (typeof api.baseDir === "string") return api.baseDir;
+	return process.cwd();
+};
+const formatLines = (lines) => {
+	const filtered = lines.filter(Boolean);
+	if (!filtered.length) return "- (none)";
+	return filtered.map((line) => `- ${line}`).join("\n");
+};
+const renderSection = (title, body) => {
+	const trimmed = body.trim();
+	if (!trimmed) return `## ${title}\n\n- (none)`;
+	return `## ${title}\n\n${trimmed}`;
+};
+const renderSectionBlock = (id, body) => {
+	return `<!-- boss:ai:${id}:start -->\n${body.trim()}\n<!-- boss:ai:${id}:end -->`;
+};
+const updateSectionBlocks = (input, sections) => {
+	let text = input;
+	if (!/<!-- boss:ai:/.test(text)) {
+		text = text.trim();
+		if (!text.length) text = "# Boss CSS AI\n";
+		else text += "\n\n";
+	}
+	for (const [id, body] of Object.entries(sections)) {
+		const block = renderSectionBlock(id, body);
+		const pattern = /* @__PURE__ */ new RegExp(`<!-- boss:ai:${id}:start -->[\\s\\S]*?<!-- boss:ai:${id}:end -->`);
+		if (pattern.test(text)) text = text.replace(pattern, block);
+		else text += `\n\n${block}`;
+	}
+	return text.trim() + "\n";
+};
+const readFileSafe = async (filePath) => {
+	try {
+		return await node_fs_promises.default.readFile(filePath, "utf8");
+	} catch {
+		return "";
+	}
+};
+const writeFileIfChanged = async (filePath, content) => {
+	if (await readFileSafe(filePath) === content) return;
+	await node_fs_promises.default.mkdir(node_path.default.dirname(filePath), { recursive: true });
+	await node_fs_promises.default.writeFile(filePath, content, "utf8");
+};
+const isValidSkillName = (value) => /^[\p{Ll}\p{Nd}]+(?:-[\p{Ll}\p{Nd}]+)*$/u.test(value) && value.length <= 64;
+const yamlValue = (value) => JSON.stringify(value);
+const unquoteYamlValue = (value) => {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+};
+const renderSkill = (skill) => {
+	const lines = [
+		"---",
+		`name: ${skill.name}`,
+		`description: ${yamlValue(skill.description)}`
+	];
+	if (skill.license) lines.push(`license: ${yamlValue(skill.license)}`);
+	if (skill.compatibility) lines.push(`compatibility: ${yamlValue(skill.compatibility)}`);
+	if (skill.allowedTools) lines.push(`allowed-tools: ${yamlValue(skill.allowedTools)}`);
+	if (skill.metadata && Object.keys(skill.metadata).length) {
+		lines.push("metadata:");
+		for (const [key, value] of Object.entries(skill.metadata)) lines.push(`  ${key}: ${yamlValue(value)}`);
+	}
+	lines.push("---", skill.body.trim(), "");
+	return lines.join("\n");
+};
+const resolvePackageVersion = async (baseDir) => {
+	try {
+		const pkgPath = node_path.default.join(baseDir, "package.json");
+		const raw = await node_fs_promises.default.readFile(pkgPath, "utf8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.version === "string" ? parsed.version : null;
+	} catch {
+		return null;
+	}
+};
+const parseSkillSummary = (content) => {
+	const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
+	if (!match) return null;
+	const lines = match[1].split("\n");
+	let name = "";
+	let description = "";
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		if (trimmed.startsWith("name:")) name = unquoteYamlValue(trimmed.slice(5).trim());
+		if (trimmed.startsWith("description:")) description = unquoteYamlValue(trimmed.slice(12).trim());
+	}
+	if (!name || !description) return null;
+	return {
+		name,
+		description
+	};
+};
+const fileExists = async (filePath) => {
+	try {
+		await node_fs_promises.default.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const loadCustomSkills = async (outputPath, baseDir, existingNames, log) => {
+	const entries = await node_fs_promises.default.readdir(outputPath, { withFileTypes: true });
+	const results = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const skillFile = node_path.default.join(outputPath, entry.name, "SKILL.md");
+		if (!await fileExists(skillFile)) continue;
+		const summary = parseSkillSummary(await readFileSafe(skillFile));
+		if (!summary) {
+			log.child("ai").log(`Skipping custom skill without valid frontmatter: ${skillFile}`);
+			continue;
+		}
+		if (!isValidSkillName(summary.name)) {
+			log.child("ai").log(`Invalid skill name "${summary.name}" in ${skillFile}`);
+			continue;
+		}
+		if (existingNames.has(summary.name)) continue;
+		results.push({
+			name: summary.name,
+			description: summary.description,
+			path: node_path.default.relative(baseDir, skillFile),
+			source: "custom"
+		});
+	}
+	results.sort((a, b) => a.name.localeCompare(b.name));
+	return results;
+};
+const buildSections = (api, session) => {
+	const config = getAiConfig(api);
+	const baseDir = getBaseDir(api, session);
+	const defaultLlmsPath = node_path.default.join(api.folder ?? api.configDir ?? ".bo$$", "LLMS.md");
+	const llmsPath = config.llms?.path ?? defaultLlmsPath;
+	const llmsFullPath = node_path.default.isAbsolute(llmsPath) ? llmsPath : node_path.default.join(baseDir, llmsPath);
+	const pluginNames = api.plugins.map((plugin) => plugin.name ?? "unknown");
+	const pluginLines = api.plugins.map((plugin) => {
+		const hooks = EVENT_NAMES.filter((eventName) => Boolean(plugin[eventName]));
+		return `${plugin.name ?? "unknown"} (${hooks.join(", ") || "no hooks"})`;
+	});
+	const summaryBody = formatLines([
+		`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+		`Base dir: ${baseDir}`,
+		`Config path: ${session?.configPath ?? "(unknown)"}`,
+		`LLMS path: ${llmsFullPath}`,
+		`Runtime strategy: ${api.strategy ?? "(default)"}`,
+		`Plugins: ${pluginNames.join(", ")}`
+	]);
+	const configBody = formatLines([
+		`content: ${Array.isArray(api.content) ? api.content.join(", ") : api.content ?? "(none)"}`,
+		`selectorPrefix: ${api.selectorPrefix ?? "(none)"}`,
+		`selectorScope: ${api.selectorScope ?? "(none)"}`,
+		`unit: ${api.unit ?? "px"}`,
+		`runtime.only: ${api.runtime?.only === true ? "true" : "false"}`,
+		`runtime.strategy: ${api.runtime?.strategy ?? "(default)"}`
+	]);
+	const outputsBody = formatLines([
+		`runtime: ${node_path.default.join(api.folder ?? api.configDir ?? ".bo$$", "index.js")}`,
+		`types: ${node_path.default.join(api.folder ?? api.configDir ?? ".bo$$", "index.d.ts")}`,
+		api.file.native?.hasContent ? `native runtime: ${node_path.default.join(api.folder ?? api.configDir ?? ".bo$$", "native.js")}` : "",
+		api.file.native?.hasContent ? `native types: ${node_path.default.join(api.folder ?? api.configDir ?? ".bo$$", "native.d.ts")}` : "",
+		`styles: ${api.stylesheetPath ?? node_path.default.join(api.configDir ?? ".bo$$", "styles.css")}`
+	]);
+	const customPropLines = [];
+	const seenDescriptors = /* @__PURE__ */ new Set();
+	for (const descriptor of api.dictionary.values()) {
+		if (!descriptor || descriptor.isCSSProp !== false) continue;
+		if (seenDescriptors.has(descriptor)) continue;
+		seenDescriptors.add(descriptor);
+		const alias = descriptor.aliases?.[0] ?? descriptor.property;
+		if (!alias) continue;
+		const description = descriptor.description ?? descriptor.usage ?? "";
+		customPropLines.push(description ? `${alias} — ${description}` : alias);
+	}
+	const customPropsBody = formatLines(customPropLines.sort((a, b) => a.localeCompare(b)));
+	const frameworkBody = formatLines([
+		`framework: ${typeof api.framework === "string" ? api.framework : typeof api.framework === "object" ? api.framework.name ?? "unknown" : "unknown"}`,
+		typeof api.framework === "object" && api.framework?.className ? `className: ${api.framework.className}` : "",
+		typeof api.framework === "object" && api.framework?.fileType ? `fileType: ${api.framework.fileType}` : ""
+	]);
+	const compileBody = formatLines([
+		`compile.enabled: ${api.compile ? "true" : "false"}`,
+		api.compile?.spread ? `compile.spread: true` : "",
+		api.compile?.stats ? `compile.stats: ${api.compile.stats}` : ""
+	]);
+	const sections = {
+		static: renderSection("Boss CSS usage", STATIC_DOC),
+		summary: renderSection("Summary", summaryBody),
+		config: renderSection("Config", configBody),
+		plugins: renderSection("Plugins", formatLines(pluginLines)),
+		outputs: renderSection("Outputs", outputsBody),
+		framework: renderSection("Framework", frameworkBody),
+		props: renderSection("Custom props", customPropsBody),
+		compile: renderSection("Compile", compileBody)
+	};
+	const defaultTitles = {
+		tokens: "Tokens",
+		props: "Props",
+		prepared: "Prepared components",
+		pseudos: "Pseudos",
+		at: "At (breakpoints and media)",
+		bosswind: "Bosswind",
+		boundaries: "CSS boundaries",
+		"dev-server": "Dev server"
+	};
+	const metaOrder = [
+		"tokens",
+		"props",
+		"prepared",
+		"pseudos",
+		"at",
+		"bosswind",
+		"boundaries",
+		"dev-server"
+	];
+	const orderedSections = [...metaOrder.filter((section) => metaStore.has(section)), ...Array.from(metaStore.keys()).filter((section) => !metaOrder.includes(section)).sort((a, b) => a.localeCompare(b))];
+	for (const section of orderedSections) {
+		const entries = metaStore.get(section);
+		if (!entries || entries.length === 0) continue;
+		const sorted = [...entries].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+		const title = sorted.find((entry) => entry.title)?.title ?? defaultTitles[section] ?? section;
+		const content = sorted.map((entry) => entry.content.trim()).filter(Boolean).join("\n\n");
+		if (!content) continue;
+		sections[section] = renderSection(title, content);
+	}
+	return {
+		sections,
+		llmsFullPath
+	};
+};
+const getLlmsFile = (api, filePath) => {
+	if (!llmsFile || llmsFilePath !== filePath) {
+		llmsFile = new require_text.default(api, { path: filePath });
+		llmsFilePath = filePath;
+	}
+	return llmsFile;
+};
+const writeLlms = async (api, session) => {
+	if (getAiConfig(api).llms?.enabled === false) return;
+	const { sections, llmsFullPath } = buildSections(api, session);
+	const updated = updateSectionBlocks(await readFileSafe(llmsFullPath), sections);
+	const baseDir = getBaseDir(api, session);
+	const folder = api.folder ?? ".bo$$";
+	const folderPath = node_path.default.isAbsolute(folder) ? folder : node_path.default.join(baseDir, folder);
+	const relativePath = node_path.default.relative(folderPath, llmsFullPath);
+	if (relativePath && !relativePath.startsWith("..") && !node_path.default.isAbsolute(relativePath)) {
+		const file = getLlmsFile(api, relativePath);
+		file.set("body", "llms", updated);
+		await file.write();
+		return;
+	}
+	await writeFileIfChanged(llmsFullPath, updated);
+};
+const writeSkills = async (api, session) => {
+	const config = getAiConfig(api);
+	if (config.skills?.enabled === false) return;
+	const baseDir = getBaseDir(api, session);
+	const outputDir = config.skills?.outputDir ?? node_path.default.join(api.folder ?? api.configDir ?? ".bo$$", "skills");
+	const outputPath = node_path.default.isAbsolute(outputDir) ? outputDir : node_path.default.join(baseDir, outputDir);
+	const includeBuiltins = config.skills?.includeBuiltins !== false;
+	await node_fs_promises.default.mkdir(outputPath, { recursive: true });
+	const skills = [];
+	const packageVersion = await resolvePackageVersion(baseDir);
+	if (includeBuiltins) skills.push(...require_ai_skills.builtInSkills.map((skill) => ({
+		name: skill.name,
+		description: skill.description,
+		body: skill.body,
+		compatibility: skill.compatibility,
+		license: skill.license,
+		metadata: packageVersion ? {
+			...skill.metadata ?? {},
+			version: packageVersion
+		} : skill.metadata,
+		allowedTools: skill.allowedTools,
+		source: "builtin"
+	})));
+	const indexEntries = [];
+	const builtinNames = new Set(skills.map((skill) => skill.name));
+	for (const skill of skills) {
+		if (!isValidSkillName(skill.name)) {
+			api.log.child("ai").log(`Invalid skill name "${skill.name}"`);
+			continue;
+		}
+		const skillDir = node_path.default.join(outputPath, skill.name);
+		const filePath = node_path.default.join(skillDir, "SKILL.md");
+		await node_fs_promises.default.mkdir(skillDir, { recursive: true });
+		await writeFileIfChanged(filePath, renderSkill(skill));
+		indexEntries.push({
+			name: skill.name,
+			description: skill.description,
+			path: node_path.default.relative(baseDir, filePath),
+			source: skill.source
+		});
+	}
+	const customEntries = await loadCustomSkills(outputPath, baseDir, builtinNames, api.log);
+	indexEntries.push(...customEntries);
+	await writeFileIfChanged(node_path.default.join(outputPath, "index.json"), JSON.stringify(indexEntries, null, 2) + "\n");
+};
+const onBoot = async (api) => {
+	if (metaStoreApi !== api) {
+		metaStore.clear();
+		metaStoreApi = api ?? null;
+	}
+	llmsFile = null;
+	llmsFilePath = null;
+};
+const onMetaData = async (_api, payload) => {
+	if (!payload || payload.kind !== "ai") return;
+	if (_api && metaStoreApi !== _api) {
+		metaStore.clear();
+		metaStoreApi = _api;
+	}
+	const type = typeof payload.type === "string" ? payload.type : "";
+	const data = payload.data;
+	const shouldReplace = payload.replace === true || data && typeof data === "object" && data.replace === true;
+	let entry = null;
+	if (type === "skill") {
+		const content = typeof data === "string" ? data : data && typeof data.content === "string" ? String(data.content) : data && typeof data.body === "string" ? String(data.body) : "";
+		if (content) entry = {
+			section: "skills",
+			title: data && typeof data.title === "string" ? String(data.title) : typeof payload.label === "string" ? payload.label : "Skills",
+			content,
+			order: typeof data?.order === "number" ? Number(data.order) : void 0
+		};
+	} else if (data && typeof data === "object") {
+		const section = data.section;
+		const content = data.content;
+		if (typeof section === "string" && typeof content === "string") entry = {
+			section,
+			content,
+			title: typeof data.title === "string" ? String(data.title) : void 0,
+			order: typeof data.order === "number" ? Number(data.order) : void 0
+		};
+	}
+	if (!entry) return;
+	if (!/^[a-zA-Z0-9._-]+$/.test(entry.section)) return;
+	if (shouldReplace) {
+		metaStore.set(entry.section, [entry]);
+		return;
+	}
+	const list = metaStore.get(entry.section) ?? [];
+	list.push(entry);
+	metaStore.set(entry.section, list);
+};
+const onSession = async (api, session) => {
+	if (!session) return;
+	if (session.phase !== "run" && session.phase !== "stop") return;
+	await writeLlms(api, session);
+	await writeSkills(api, session);
+};
+
+//#endregion
+exports.name = name;
+exports.onBoot = onBoot;
+exports.onMetaData = onMetaData;
+exports.onSession = onSession;
+Object.defineProperty(exports, 'server_exports', {
+  enumerable: true,
+  get: function () {
+    return server_exports;
+  }
+});