@pyreon/zero 0.12.2 → 0.12.3

package/lib/actions.js

@@ -0,0 +1,97 @@
+//#region src/actions.ts
+const actionRegistry = /* @__PURE__ */ new Map();
+/**
+* Define a server action. Returns a callable function that:
+* - On the **client**: sends a POST request to `/_zero/actions/<id>`
+* - On the **server** (SSR): executes the handler directly (no fetch)
+*
+* @example
+* // In a route file or module:
+* export const createPost = defineAction(async (ctx) => {
+*   const data = ctx.json as { title: string; body: string }
+*   // ... save to database
+*   return { success: true, id: 123 }
+* })
+*
+* // In a component:
+* const result = await createPost({ title: 'Hello', body: '...' })
+*/
+function defineAction(handler) {
+	const id = `action_${crypto.randomUUID().slice(0, 8)}`;
+	actionRegistry.set(id, {
+		id,
+		handler
+	});
+	const callable = async (data) => {
+		if (typeof globalThis.window === "undefined") return handler({
+			request: new Request(`http://localhost/_zero/actions/${id}`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(data ?? null)
+			}),
+			formData: null,
+			json: data ?? null,
+			headers: new Headers({ "Content-Type": "application/json" })
+		});
+		const response = await fetch(`/_zero/actions/${id}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(data ?? null)
+		});
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error ?? `Action failed: ${response.statusText}`);
+		}
+		return response.json();
+	};
+	callable.actionId = id;
+	return callable;
+}
+/** Get all registered actions. Useful for testing. */
+function getRegisteredActions() {
+	return actionRegistry;
+}
+/**
+* Reset the action registry. Useful for testing.
+* @internal
+*/
+function _resetActions() {
+	actionRegistry.clear();
+}
+/**
+* Create a middleware that handles action requests at `/_zero/actions/*`.
+* Mount this before the SSR handler in the server entry.
+*/
+function createActionMiddleware() {
+	return async (ctx) => {
+		if (!ctx.path.startsWith("/_zero/actions/")) return;
+		const actionId = ctx.path.slice(15);
+		const action = actionRegistry.get(actionId);
+		if (!action) return Response.json({ error: "Action not found" }, { status: 404 });
+		if (ctx.req.method !== "POST") return Response.json({ error: "Method not allowed" }, { status: 405 });
+		return executeAction(action, ctx.req);
+	};
+}
+async function executeAction(action, req) {
+	try {
+		const contentType = req.headers.get("content-type") ?? "";
+		let formData = null;
+		let json = null;
+		if (contentType.includes("application/json")) json = await req.json();
+		else if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) formData = await req.formData();
+		const result = await action.handler({
+			request: req,
+			formData,
+			json,
+			headers: req.headers
+		});
+		return Response.json(result ?? null);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Internal server error";
+		return Response.json({ error: message }, { status: 500 });
+	}
+}
+
+//#endregion
+export { _resetActions, createActionMiddleware, defineAction, getRegisteredActions };
+//# sourceMappingURL=actions.js.map

package/lib/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","names":[],"sources":["../src/actions.ts"],"sourcesContent":["import type { MiddlewareContext } from '@pyreon/server'\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\n/** Context passed to server action handlers. */\nexport interface ActionContext {\n  /** The original request. */\n  request: Request\n  /** Parsed form data (for form submissions). */\n  formData: FormData | null\n  /** Parsed JSON body (for JSON submissions). */\n  json: unknown\n  /** Request headers. */\n  headers: Headers\n}\n\n/** A server action handler function. */\nexport type ActionHandler<T = unknown> = (ctx: ActionContext) => T | Promise<T>\n\n/** A registered action with its ID and handler. */\ninterface RegisteredAction {\n  id: string\n  handler: ActionHandler\n}\n\n/** Client-side callable action returned by defineAction. */\nexport interface Action<T = unknown> {\n  /** Call the action with JSON data. */\n  (data?: unknown): Promise<T>\n  /** The action's unique ID. */\n  actionId: string\n}\n\n// ─── Registry ────────────────────────────────────────────────────────────────\n\nconst actionRegistry = new Map<string, RegisteredAction>()\n\n/**\n * Define a server action. Returns a callable function that:\n * - On the **client**: sends a POST request to `/_zero/actions/<id>`\n * - On the **server** (SSR): executes the handler directly (no fetch)\n *\n * @example\n * // In a route file or module:\n * export const createPost = defineAction(async (ctx) => {\n *   const data = ctx.json as { title: string; body: string }\n *   // ... save to database\n *   return { success: true, id: 123 }\n * })\n *\n * // In a component:\n * const result = await createPost({ title: 'Hello', body: '...' })\n */\nexport function defineAction<T = unknown>(handler: ActionHandler<T>): Action<T> {\n  const id = `action_${crypto.randomUUID().slice(0, 8)}`\n\n  actionRegistry.set(id, { id, handler: handler as ActionHandler })\n\n  const callable = async (data?: unknown): Promise<T> => {\n    // Server-side: execute handler directly (no network round-trip)\n    if (typeof globalThis.window === 'undefined') {\n      return handler({\n        request: new Request(`http://localhost/_zero/actions/${id}`, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify(data ?? null),\n        }),\n        formData: null,\n        json: data ?? null,\n        headers: new Headers({ 'Content-Type': 'application/json' }),\n      })\n    }\n\n    // Client-side: POST to the action endpoint\n    const response = await fetch(`/_zero/actions/${id}`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify(data ?? null),\n    })\n    if (!response.ok) {\n      const body = await response.json().catch(() => ({}))\n      throw new Error((body as { error?: string }).error ?? `Action failed: ${response.statusText}`)\n    }\n    return response.json()\n  }\n\n  callable.actionId = id\n  return callable as Action<T>\n}\n\n/** Get all registered actions. Useful for testing. */\nexport function getRegisteredActions(): Map<string, RegisteredAction> {\n  return actionRegistry\n}\n\n/**\n * Reset the action registry. Useful for testing.\n * @internal\n */\nexport function _resetActions(): void {\n  actionRegistry.clear()\n}\n\n// ─── Server handler ──────────────────────────────────────────────────────────\n\n/**\n * Create a middleware that handles action requests at `/_zero/actions/*`.\n * Mount this before the SSR handler in the server entry.\n */\nexport function createActionMiddleware(): (\n  ctx: MiddlewareContext,\n) => Response | undefined | Promise<Response | undefined> {\n  return async (ctx: MiddlewareContext) => {\n    if (!ctx.path.startsWith('/_zero/actions/')) return\n\n    const actionId = ctx.path.slice('/_zero/actions/'.length)\n    const action = actionRegistry.get(actionId)\n\n    if (!action) {\n      return Response.json({ error: 'Action not found' }, { status: 404 })\n    }\n\n    if (ctx.req.method !== 'POST') {\n      return Response.json({ error: 'Method not allowed' }, { status: 405 })\n    }\n\n    return executeAction(action, ctx.req)\n  }\n}\n\nasync function executeAction(action: RegisteredAction, req: Request): Promise<Response> {\n  try {\n    const contentType = req.headers.get('content-type') ?? ''\n    let formData: FormData | null = null\n    let json: unknown = null\n\n    if (contentType.includes('application/json')) {\n      json = await req.json()\n    } else if (\n      contentType.includes('multipart/form-data') ||\n      contentType.includes('application/x-www-form-urlencoded')\n    ) {\n      formData = await req.formData()\n    }\n\n    const result = await action.handler({\n      request: req,\n      formData,\n      json,\n      headers: req.headers,\n    })\n\n    return Response.json(result ?? null)\n  } catch (err) {\n    const message = err instanceof Error ? err.message : 'Internal server error'\n    return Response.json({ error: message }, { status: 500 })\n  }\n}\n"],"mappings":";AAmCA,MAAM,iCAAiB,IAAI,KAA+B;;;;;;;;;;;;;;;;;AAkB1D,SAAgB,aAA0B,SAAsC;CAC9E,MAAM,KAAK,UAAU,OAAO,YAAY,CAAC,MAAM,GAAG,EAAE;AAEpD,gBAAe,IAAI,IAAI;EAAE;EAAa;EAA0B,CAAC;CAEjE,MAAM,WAAW,OAAO,SAA+B;AAErD,MAAI,OAAO,WAAW,WAAW,YAC/B,QAAO,QAAQ;GACb,SAAS,IAAI,QAAQ,kCAAkC,MAAM;IAC3D,QAAQ;IACR,SAAS,EAAE,gBAAgB,oBAAoB;IAC/C,MAAM,KAAK,UAAU,QAAQ,KAAK;IACnC,CAAC;GACF,UAAU;GACV,MAAM,QAAQ;GACd,SAAS,IAAI,QAAQ,EAAE,gBAAgB,oBAAoB,CAAC;GAC7D,CAAC;EAIJ,MAAM,WAAW,MAAM,MAAM,kBAAkB,MAAM;GACnD,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAC/C,MAAM,KAAK,UAAU,QAAQ,KAAK;GACnC,CAAC;AACF,MAAI,CAAC,SAAS,IAAI;GAChB,MAAM,OAAO,MAAM,SAAS,MAAM,CAAC,aAAa,EAAE,EAAE;AACpD,SAAM,IAAI,MAAO,KAA4B,SAAS,kBAAkB,SAAS,aAAa;;AAEhG,SAAO,SAAS,MAAM;;AAGxB,UAAS,WAAW;AACpB,QAAO;;;AAIT,SAAgB,uBAAsD;AACpE,QAAO;;;;;;AAOT,SAAgB,gBAAsB;AACpC,gBAAe,OAAO;;;;;;AASxB,SAAgB,yBAE0C;AACxD,QAAO,OAAO,QAA2B;AACvC,MAAI,CAAC,IAAI,KAAK,WAAW,kBAAkB,CAAE;EAE7C,MAAM,WAAW,IAAI,KAAK,MAAM,GAAyB;EACzD,MAAM,SAAS,eAAe,IAAI,SAAS;AAE3C,MAAI,CAAC,OACH,QAAO,SAAS,KAAK,EAAE,OAAO,oBAAoB,EAAE,EAAE,QAAQ,KAAK,CAAC;AAGtE,MAAI,IAAI,IAAI,WAAW,OACrB,QAAO,SAAS,KAAK,EAAE,OAAO,sBAAsB,EAAE,EAAE,QAAQ,KAAK,CAAC;AAGxE,SAAO,cAAc,QAAQ,IAAI,IAAI;;;AAIzC,eAAe,cAAc,QAA0B,KAAiC;AACtF,KAAI;EACF,MAAM,cAAc,IAAI,QAAQ,IAAI,eAAe,IAAI;EACvD,IAAI,WAA4B;EAChC,IAAI,OAAgB;AAEpB,MAAI,YAAY,SAAS,mBAAmB,CAC1C,QAAO,MAAM,IAAI,MAAM;WAEvB,YAAY,SAAS,sBAAsB,IAC3C,YAAY,SAAS,oCAAoC,CAEzD,YAAW,MAAM,IAAI,UAAU;EAGjC,MAAM,SAAS,MAAM,OAAO,QAAQ;GAClC,SAAS;GACT;GACA;GACA,SAAS,IAAI;GACd,CAAC;AAEF,SAAO,SAAS,KAAK,UAAU,KAAK;UAC7B,KAAK;EACZ,MAAM,UAAU,eAAe,QAAQ,IAAI,UAAU;AACrD,SAAO,SAAS,KAAK,EAAE,OAAO,SAAS,EAAE,EAAE,QAAQ,KAAK,CAAC"}

package/lib/ai.js

@@ -0,0 +1,503 @@
+//#region src/fs-router.ts
+const ROUTE_EXTENSIONS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+/**
+* Parse a set of file paths (relative to routes dir) into FileRoute objects.
+*
+* @param files Array of file paths like ["index.tsx", "users/[id].tsx"]
+* @param defaultMode Default rendering mode from config
+*/
+function parseFileRoutes(files, defaultMode = "ssr") {
+	return files.filter((f) => ROUTE_EXTENSIONS.some((ext) => f.endsWith(ext))).map((filePath) => parseFilePath(filePath, defaultMode)).sort(sortRoutes);
+}
+function parseFilePath(filePath, defaultMode) {
+	let route = filePath;
+	for (const ext of ROUTE_EXTENSIONS) if (route.endsWith(ext)) {
+		route = route.slice(0, -ext.length);
+		break;
+	}
+	const fileName = getFileName(route);
+	const isLayout = fileName === "_layout";
+	const isError = fileName === "_error";
+	const isLoading = fileName === "_loading";
+	const isNotFound = fileName === "_404" || fileName === "_not-found";
+	const isCatchAll = route.includes("[...");
+	const parts = route.split("/");
+	parts.pop();
+	const dirPath = parts.filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/");
+	const urlPath = filePathToUrlPath(route);
+	return {
+		filePath,
+		urlPath,
+		dirPath,
+		depth: urlPath === "/" ? 0 : urlPath.split("/").filter(Boolean).length,
+		isLayout,
+		isError,
+		isLoading,
+		isNotFound,
+		isCatchAll,
+		renderMode: defaultMode
+	};
+}
+/**
+* Convert a file path (without extension) to a URL path pattern.
+*
+* Examples:
+*   "index"            → "/"
+*   "about"            → "/about"
+*   "users/index"      → "/users"
+*   "users/[id]"       → "/users/:id"
+*   "blog/[...slug]"   → "/blog/:slug*"
+*   "(auth)/login"     → "/login"         (group stripped)
+*   "_layout"          → "/"              (layout marker)
+*/
+function filePathToUrlPath(filePath) {
+	const segments = filePath.split("/");
+	const urlSegments = [];
+	for (const seg of segments) {
+		if (seg.startsWith("(") && seg.endsWith(")")) continue;
+		if (seg === "_layout" || seg === "_error" || seg === "_loading" || seg === "_404" || seg === "_not-found") continue;
+		if (seg === "index") continue;
+		const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/);
+		if (catchAll) {
+			urlSegments.push(`:${catchAll[1]}*`);
+			continue;
+		}
+		const dynamic = seg.match(/^\[(\w+)\]$/);
+		if (dynamic) {
+			urlSegments.push(`:${dynamic[1]}`);
+			continue;
+		}
+		urlSegments.push(seg);
+	}
+	return `/${urlSegments.join("/")}` || "/";
+}
+/** Sort routes: static before dynamic, catch-all last. */
+function sortRoutes(a, b) {
+	if (a.isCatchAll !== b.isCatchAll) return a.isCatchAll ? 1 : -1;
+	if (a.isLayout !== b.isLayout) return a.isLayout ? -1 : 1;
+	const aDynamic = a.urlPath.includes(":");
+	if (aDynamic !== b.urlPath.includes(":")) return aDynamic ? 1 : -1;
+	return a.urlPath.localeCompare(b.urlPath);
+}
+function getFileName(filePath) {
+	const parts = filePath.split("/");
+	return parts[parts.length - 1] ?? "";
+}
+
+//#endregion
+//#region src/ai.ts
+/**
+* Generate llms.txt content from route files and config.
+*
+* Format follows the llms.txt proposal:
+* ```
+* # {name}
+* > {description}
+*
+* ## Pages
+* - [/about](/about): About page
+*
+* ## API
+* - GET /api/posts: List posts
+* ```
+*
+* @internal Exported for testing.
+*/
+function generateLlmsTxt(routeFiles, apiFiles, config) {
+	const lines = [];
+	lines.push(`# ${config.name}`);
+	lines.push(`> ${config.description}`);
+	lines.push("");
+	const routes = parseFileRoutes(routeFiles);
+	const pages = routes.filter((r) => !r.isLayout && !r.isError && !r.isLoading && !r.isNotFound && !r.isCatchAll && !r.urlPath.includes(":"));
+	if (pages.length > 0) {
+		lines.push("## Pages");
+		lines.push("");
+		for (const page of pages) {
+			const desc = config.pageDescriptions?.[page.urlPath];
+			const url = `${config.origin}${page.urlPath === "/" ? "" : page.urlPath}`;
+			if (desc) lines.push(`- [${page.urlPath}](${url}): ${desc}`);
+			else lines.push(`- [${page.urlPath}](${url})`);
+		}
+		lines.push("");
+	}
+	const dynamicRoutes = routes.filter((r) => !r.isLayout && !r.isError && !r.isLoading && !r.isNotFound && (r.urlPath.includes(":") || r.isCatchAll));
+	if (dynamicRoutes.length > 0) {
+		lines.push("## Dynamic Pages");
+		lines.push("");
+		for (const route of dynamicRoutes) {
+			const desc = config.pageDescriptions?.[route.urlPath];
+			if (desc) lines.push(`- ${route.urlPath}: ${desc}`);
+			else lines.push(`- ${route.urlPath}`);
+		}
+		lines.push("");
+	}
+	const apiPatterns = parseApiFiles(apiFiles);
+	if (apiPatterns.length > 0 || config.apiDescriptions) {
+		lines.push("## API Endpoints");
+		lines.push("");
+		if (config.apiDescriptions) for (const [endpoint, desc] of Object.entries(config.apiDescriptions)) lines.push(`- ${endpoint}: ${desc}`);
+		const describedPatterns = new Set(Object.keys(config.apiDescriptions ?? {}).map((k) => k.replace(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+/, "")));
+		for (const pattern of apiPatterns) if (!describedPatterns.has(pattern)) lines.push(`- ${pattern}`);
+		lines.push("");
+	}
+	if (config.llmsExtra) {
+		lines.push(config.llmsExtra);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Generate llms-full.txt — expanded version with more detail.
+* Includes all route metadata and API descriptions.
+*
+* @internal Exported for testing.
+*/
+function generateLlmsFullTxt(routeFiles, apiFiles, config) {
+	const lines = [];
+	lines.push(`# ${config.name} — Full Reference`);
+	lines.push(`> ${config.description}`);
+	lines.push("");
+	lines.push(`Base URL: ${config.origin}`);
+	lines.push("");
+	const pages = parseFileRoutes(routeFiles).filter((r) => !r.isLayout && !r.isError && !r.isLoading && !r.isNotFound);
+	if (pages.length > 0) {
+		lines.push("## All Routes");
+		lines.push("");
+		for (const page of pages) {
+			const desc = config.pageDescriptions?.[page.urlPath] ?? "";
+			const dynamic = page.urlPath.includes(":") ? " (dynamic)" : "";
+			const catchAll = page.isCatchAll ? " (catch-all)" : "";
+			lines.push(`### ${page.urlPath}${dynamic}${catchAll}`);
+			if (desc) lines.push(desc);
+			lines.push(`- File: ${page.filePath}`);
+			lines.push(`- Render mode: ${page.renderMode}`);
+			lines.push("");
+		}
+	}
+	if (config.apiDescriptions) {
+		lines.push("## API Reference");
+		lines.push("");
+		for (const [endpoint, desc] of Object.entries(config.apiDescriptions)) {
+			lines.push(`### ${endpoint}`);
+			lines.push(desc);
+			lines.push("");
+		}
+	}
+	if (config.llmsExtra) {
+		lines.push("## Additional Information");
+		lines.push("");
+		lines.push(config.llmsExtra);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Auto-infer JSON-LD structured data from page metadata.
+*
+* Returns an array of JSON-LD objects (multiple schemas can apply to one page).
+* For example, an article page gets both `Article` and `BreadcrumbList`.
+*
+* @example
+* ```tsx
+* const schemas = inferJsonLd({
+*   url: "https://example.com/blog/my-post",
+*   title: "My Post",
+*   description: "A great article",
+*   type: "article",
+*   author: "Vit Bokisch",
+*   publishedTime: "2026-03-31",
+* })
+* // → [Article schema, BreadcrumbList schema]
+* ```
+*/
+function inferJsonLd(options) {
+	const schemas = [];
+	if (options.type === "article") {
+		const article = {
+			"@context": "https://schema.org",
+			"@type": "Article",
+			headline: options.title,
+			url: options.url
+		};
+		if (options.description) article.description = options.description;
+		if (options.image) article.image = options.image;
+		if (options.publishedTime) article.datePublished = options.publishedTime;
+		if (options.author) article.author = {
+			"@type": "Person",
+			name: options.author
+		};
+		if (options.tags && options.tags.length > 0) article.keywords = options.tags.join(", ");
+		if (options.siteName) article.publisher = {
+			"@type": "Organization",
+			name: options.siteName
+		};
+		schemas.push(article);
+	} else if (options.type === "product") {
+		const product = {
+			"@context": "https://schema.org",
+			"@type": "Product",
+			name: options.title,
+			url: options.url
+		};
+		if (options.description) product.description = options.description;
+		if (options.image) product.image = options.image;
+		schemas.push(product);
+	} else {
+		const webpage = {
+			"@context": "https://schema.org",
+			"@type": "WebPage",
+			name: options.title,
+			url: options.url
+		};
+		if (options.description) webpage.description = options.description;
+		if (options.image) webpage.thumbnailUrl = options.image;
+		schemas.push(webpage);
+	}
+	if (options.breadcrumbs && options.breadcrumbs.length > 0) schemas.push({
+		"@context": "https://schema.org",
+		"@type": "BreadcrumbList",
+		itemListElement: options.breadcrumbs.map((bc, i) => ({
+			"@type": "ListItem",
+			position: i + 1,
+			name: bc.name,
+			item: bc.url
+		}))
+	});
+	else {
+		const urlObj = safeParseUrl(options.url);
+		if (urlObj) {
+			const segments = urlObj.pathname.split("/").filter(Boolean);
+			if (segments.length > 0) {
+				const items = [{
+					"@type": "ListItem",
+					position: 1,
+					name: "Home",
+					item: urlObj.origin
+				}];
+				let path = "";
+				for (let i = 0; i < segments.length; i++) {
+					path += `/${segments[i]}`;
+					items.push({
+						"@type": "ListItem",
+						position: i + 2,
+						name: capitalize(segments[i].replace(/-/g, " ")),
+						item: `${urlObj.origin}${path}`
+					});
+				}
+				schemas.push({
+					"@context": "https://schema.org",
+					"@type": "BreadcrumbList",
+					itemListElement: items
+				});
+			}
+		}
+	}
+	return schemas;
+}
+/**
+* Generate an OpenAI-compatible AI plugin manifest.
+*
+* Follows the /.well-known/ai-plugin.json spec.
+*
+* @internal Exported for testing.
+*/
+function generateAiPluginManifest(config) {
+	return {
+		schema_version: "v1",
+		name_for_human: config.name,
+		name_for_model: config.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, ""),
+		description_for_human: config.description,
+		description_for_model: config.description,
+		auth: { type: "none" },
+		api: {
+			type: "openapi",
+			url: `${config.origin}/.well-known/openapi.yaml`
+		},
+		logo_url: config.logoUrl ?? `${config.origin}/favicon.svg`,
+		contact_email: config.contactEmail ?? "",
+		legal_info_url: config.legalUrl ?? `${config.origin}/legal`
+	};
+}
+/**
+* Generate a minimal OpenAPI 3.0 spec from API route descriptions.
+*
+* @internal Exported for testing.
+*/
+function generateOpenApiSpec(apiFiles, config) {
+	const paths = {};
+	if (config.apiDescriptions) for (const [endpoint, desc] of Object.entries(config.apiDescriptions)) {
+		const match = endpoint.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(.+)$/);
+		if (match) {
+			const method = match[1].toLowerCase();
+			const openApiPath = match[2].replace(/:(\w+)/g, "{$1}");
+			if (!paths[openApiPath]) paths[openApiPath] = {};
+			paths[openApiPath][method] = {
+				summary: desc,
+				responses: { "200": { description: "Success" } }
+			};
+		}
+	}
+	for (const pattern of parseApiFiles(apiFiles)) {
+		const openApiPath = pattern.replace(/:(\w+)/g, "{$1}");
+		if (!paths[openApiPath]) paths[openApiPath] = { get: {
+			summary: `${openApiPath} endpoint`,
+			responses: { "200": { description: "Success" } }
+		} };
+	}
+	return {
+		openapi: "3.0.0",
+		info: {
+			title: config.name,
+			description: config.description,
+			version: "1.0.0"
+		},
+		servers: [{ url: config.origin }],
+		paths
+	};
+}
+/**
+* AI integration Vite plugin.
+*
+* Generates at build time:
+* - `/llms.txt` — concise site summary for AI agents
+* - `/llms-full.txt` — detailed reference for AI agents
+* - `/.well-known/ai-plugin.json` — OpenAI plugin manifest
+* - `/.well-known/openapi.yaml` — minimal OpenAPI spec from API routes
+*
+* In dev, serves these files via middleware.
+*
+* @example
+* ```ts
+* import { aiPlugin } from "@pyreon/zero/ai"
+*
+* export default {
+*   plugins: [
+*     aiPlugin({
+*       name: "My App",
+*       origin: "https://example.com",
+*       description: "A modern web application",
+*       apiDescriptions: {
+*         "GET /api/posts": "List blog posts",
+*         "GET /api/posts/:id": "Get post by ID",
+*       },
+*     }),
+*   ],
+* }
+* ```
+*/
+function aiPlugin(config) {
+	let root = "";
+	let isBuild = false;
+	let routeFiles = [];
+	let apiFiles = [];
+	return {
+		name: "pyreon-zero-ai",
+		enforce: "post",
+		configResolved(resolvedConfig) {
+			root = resolvedConfig.root;
+			isBuild = resolvedConfig.command === "build";
+		},
+		async buildStart() {
+			try {
+				const { join } = await import("node:path");
+				const routesDir = join(root, config.routesDir ?? "src/routes");
+				const apiDir = join(root, config.apiDir ?? "src/api");
+				routeFiles = await scanDir(routesDir, routesDir);
+				apiFiles = await scanDir(apiDir, apiDir);
+			} catch {}
+		},
+		configureServer(server) {
+			server.middlewares.use(async (req, res, next) => {
+				const url = req.url ?? "";
+				if (url === "/llms.txt") {
+					res.setHeader("Content-Type", "text/plain; charset=utf-8");
+					res.end(generateLlmsTxt(routeFiles, apiFiles, config));
+					return;
+				}
+				if (url === "/llms-full.txt") {
+					res.setHeader("Content-Type", "text/plain; charset=utf-8");
+					res.end(generateLlmsFullTxt(routeFiles, apiFiles, config));
+					return;
+				}
+				if (url === "/.well-known/ai-plugin.json") {
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify(generateAiPluginManifest(config), null, 2));
+					return;
+				}
+				if (url === "/.well-known/openapi.yaml" || url === "/.well-known/openapi.json") {
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify(generateOpenApiSpec(apiFiles, config), null, 2));
+					return;
+				}
+				next();
+			});
+		},
+		async generateBundle() {
+			if (!isBuild) return;
+			this.emitFile({
+				type: "asset",
+				fileName: "llms.txt",
+				source: generateLlmsTxt(routeFiles, apiFiles, config)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: "llms-full.txt",
+				source: generateLlmsFullTxt(routeFiles, apiFiles, config)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: ".well-known/ai-plugin.json",
+				source: JSON.stringify(generateAiPluginManifest(config), null, 2)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: ".well-known/openapi.json",
+				source: JSON.stringify(generateOpenApiSpec(apiFiles, config), null, 2)
+			});
+		}
+	};
+}
+function parseApiFiles(files) {
+	return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js")).map((f) => {
+		let path = f.replace(/\.\w+$/, "").replace(/\/index$/, "");
+		if (!path.startsWith("/")) path = `/${path}`;
+		path = path.replace(/\[\.\.\.(\w+)\]/g, ":$1*").replace(/\[(\w+)\]/g, ":$1");
+		return `/api${path === "/" ? "" : path}`;
+	});
+}
+async function scanDir(dir, base) {
+	const { readdir, stat } = await import("node:fs/promises");
+	const { join, relative } = await import("node:path");
+	try {
+		const entries = await readdir(dir);
+		const files = [];
+		for (const entry of entries) {
+			const full = join(dir, entry);
+			if ((await stat(full)).isDirectory()) files.push(...await scanDir(full, base));
+			else files.push(relative(base, full));
+		}
+		return files;
+	} catch {
+		return [];
+	}
+}
+function safeParseUrl(url) {
+	try {
+		return new URL(url);
+	} catch {
+		return null;
+	}
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+//#endregion
+export { aiPlugin, generateAiPluginManifest, generateLlmsFullTxt, generateLlmsTxt, generateOpenApiSpec, inferJsonLd };
+//# sourceMappingURL=ai.js.map