@agentrules/core 0.0.10 → 0.1.0

package/dist/index.js

@@ -1,41 +1,9 @@
 import { ZodError, z } from "zod";
 import { createTwoFilesPatch } from "diff";
 
-//#region src/constants.ts
-/**
-* Shared constants for agentrules presets and registry.
-*/
-/** Filename for preset configuration */
-const PRESET_CONFIG_FILENAME = "agentrules.json";
-/** Directory name for preset metadata (README, LICENSE, etc.) */
-const AGENT_RULES_DIR = ".agentrules";
-/** JSON Schema URL for preset configuration */
-const PRESET_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
-/** API root path segment */
-const API_PATH = "api";
-/** Default version identifier for latest preset version */
-const LATEST_VERSION = "latest";
-/**
-* API endpoint paths (relative to registry base URL).
-*/
-const API_ENDPOINTS = {
-	presets: {
-		base: `${API_PATH}/presets`,
-		get: (slug, platform, version = LATEST_VERSION) => `${API_PATH}/presets/${encodeURIComponent(slug)}/${encodeURIComponent(platform)}/${encodeURIComponent(version)}`,
-		unpublish: (slug, platform, version) => `${API_PATH}/presets/${encodeURIComponent(slug)}/${encodeURIComponent(platform)}/${encodeURIComponent(version)}`
-	},
-	auth: {
-		session: `${API_PATH}/auth/get-session`,
-		deviceCode: `${API_PATH}/auth/device/code`,
-		deviceToken: `${API_PATH}/auth/device/token`
-	}
-};
-
-//#endregion
 //#region src/platform/types.ts
 /**
-* Single source of truth for platform IDs.
-* Add new platforms here - types and config will follow.
+* Platform and rule type definitions.
 */
 const PLATFORM_ID_TUPLE = [
 	"opencode",
@@ -46,30 +14,169 @@ const PLATFORM_ID_TUPLE = [
 
 //#endregion
 //#region src/platform/config.ts
-/** List of supported platform IDs as a readonly tuple */
 const PLATFORM_IDS = PLATFORM_ID_TUPLE;
 /**
-* Platform-specific configuration.
-* Single source of truth for all platform paths.
+* Platform configuration including supported rule types and install paths.
 */
 const PLATFORMS = {
 	opencode: {
+		label: "OpenCode",
 		projectDir: ".opencode",
-		globalDir: "~/.config/opencode"
-	},
-	codex: {
-		projectDir: ".codex",
-		globalDir: "~/.codex"
+		globalDir: "~/.config/opencode",
+		types: {
+			instruction: {
+				description: "Project instructions",
+				format: "markdown",
+				extension: "md",
+				projectPath: "AGENTS.md",
+				globalPath: "~/.config/opencode/AGENTS.md"
+			},
+			agent: {
+				description: "Specialized AI agent",
+				format: "markdown",
+				extension: "md",
+				projectPath: ".opencode/agent/{name}.md",
+				globalPath: "~/.config/opencode/agent/{name}.md"
+			},
+			command: {
+				description: "Custom slash command",
+				format: "markdown",
+				extension: "md",
+				projectPath: ".opencode/command/{name}.md",
+				globalPath: "~/.config/opencode/command/{name}.md"
+			},
+			tool: {
+				description: "Custom tool",
+				format: "typescript",
+				extension: "ts",
+				projectPath: ".opencode/tool/{name}.ts",
+				globalPath: "~/.config/opencode/tool/{name}.ts"
+			}
+		}
 	},
 	claude: {
+		label: "Claude Code",
 		projectDir: ".claude",
-		globalDir: "~/.claude"
+		globalDir: "~/.claude",
+		types: {
+			instruction: {
+				description: "Project instructions",
+				format: "markdown",
+				extension: "md",
+				projectPath: "CLAUDE.md",
+				globalPath: "~/.claude/CLAUDE.md"
+			},
+			command: {
+				description: "Custom slash command",
+				format: "markdown",
+				extension: "md",
+				projectPath: ".claude/commands/{name}.md",
+				globalPath: "~/.claude/commands/{name}.md"
+			},
+			skill: {
+				description: "Custom skill",
+				format: "markdown",
+				extension: "md",
+				projectPath: ".claude/skills/{name}/SKILL.md",
+				globalPath: "~/.claude/skills/{name}/SKILL.md"
+			}
+		}
 	},
 	cursor: {
+		label: "Cursor",
 		projectDir: ".cursor",
-		globalDir: "~/.cursor"
+		globalDir: "~/.cursor",
+		types: {
+			instruction: {
+				description: "Project instructions",
+				format: "markdown",
+				extension: "md",
+				projectPath: "AGENTS.md",
+				globalPath: null
+			},
+			rule: {
+				description: "Custom rule",
+				format: "mdc",
+				extension: "mdc",
+				projectPath: ".cursor/rules/{name}.mdc",
+				globalPath: null
+			},
+			command: {
+				description: "Custom slash command",
+				format: "markdown",
+				extension: "md",
+				projectPath: ".cursor/commands/{name}.md",
+				globalPath: "~/.cursor/commands/{name}.md"
+			}
+		}
+	},
+	codex: {
+		label: "Codex",
+		projectDir: ".codex",
+		globalDir: "~/.codex",
+		types: {
+			instruction: {
+				description: "Project instructions",
+				format: "markdown",
+				extension: "md",
+				projectPath: "AGENTS.md",
+				globalPath: "~/.codex/AGENTS.md"
+			},
+			command: {
+				description: "Custom prompt",
+				format: "markdown",
+				extension: "md",
+				projectPath: null,
+				globalPath: "~/.codex/prompts/{name}.md"
+			}
+		}
 	}
 };
+/** Valid rule types for each platform. Must be kept in sync with PLATFORMS. */
+const PLATFORM_RULE_TYPES = {
+	opencode: [
+		"instruction",
+		"command",
+		"agent",
+		"tool"
+	],
+	claude: [
+		"instruction",
+		"command",
+		"skill"
+	],
+	codex: ["instruction", "command"],
+	cursor: [
+		"instruction",
+		"command",
+		"rule"
+	]
+};
+/** Get valid rule types for a specific platform */
+function getValidRuleTypes(platform) {
+	return PLATFORM_RULE_TYPES[platform];
+}
+/** Check if a type is valid for a given platform */
+function isValidRuleType(platform, type) {
+	return PLATFORM_RULE_TYPES[platform].includes(type);
+}
+/** Get the configuration for a specific platform + type combination */
+function getRuleTypeConfig(platform, type) {
+	const platformConfig = PLATFORMS[platform];
+	return platformConfig.types[type];
+}
+/** Get the install path for a rule, replacing {name} placeholder */
+function getInstallPath(platform, type, name, location = "project") {
+	const config = getRuleTypeConfig(platform, type);
+	if (!config) return null;
+	const pathTemplate = location === "project" ? config.projectPath : config.globalPath;
+	if (!pathTemplate) return null;
+	return pathTemplate.replace("{name}", name);
+}
+/** Get platform configuration */
+function getPlatformConfig(platform) {
+	return PLATFORMS[platform];
+}
 
 //#endregion
 //#region src/platform/utils.ts
@@ -117,25 +224,56 @@ function toUint8Array(payload) {
 }
 
 //#endregion
-//#region src/preset/schema.ts
+//#region src/schemas/common.ts
 const PLATFORM_ID_SET = new Set(PLATFORM_IDS);
-const VERSION_REGEX = /^[1-9]\d*\.\d+$/;
-const platformIdSchema = z.enum(PLATFORM_IDS);
-const titleSchema = z.string().trim().min(1, "Title is required").max(80, "Title must be 80 characters or less");
-const descriptionSchema = z.string().trim().min(1, "Description is required").max(500, "Description must be 500 characters or less");
-const versionSchema = z.string().trim().regex(VERSION_REGEX, "Version must be in MAJOR.MINOR format (e.g., 1.3)");
-const majorVersionSchema = z.number().int().positive("Major version must be a positive integer");
 const TAG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const TAG_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-tag)";
+/**
+* Schema for a single tag.
+* - Max 35 characters
+* - Lowercase alphanumeric with hyphens
+* - Platform names blocked (redundant with platform field)
+*/
 const tagSchema = z.string().trim().min(1, "Tag cannot be empty").max(35, "Tag must be 35 characters or less").regex(TAG_REGEX, TAG_ERROR).refine((tag) => !PLATFORM_ID_SET.has(tag), { message: "Platform names cannot be used as tags (redundant with platform field)" });
+/**
+* Schema for tags array.
+* - 1-10 tags required
+*/
 const tagsSchema = z.array(tagSchema).min(1, "At least one tag is required").max(10, "Maximum 10 tags allowed");
+const NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const NAME_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-preset)";
+/**
+* Schema for preset/rule name.
+* - Max 64 characters
+* - Lowercase alphanumeric with hyphens
+*/
+const nameSchema = z.string().trim().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(NAME_REGEX, NAME_ERROR);
+/**
+* Schema for display title.
+* - Max 80 characters
+*/
+const titleSchema = z.string().trim().min(1, "Title is required").max(80, "Title must be 80 characters or less");
+/**
+* Schema for description.
+* - Max 500 characters
+*/
+const descriptionSchema = z.string().trim().max(500, "Description must be 500 characters or less");
+
+//#endregion
+//#region src/preset/schema.ts
+const VERSION_REGEX$1 = /^[1-9]\d*\.\d+$/;
+const platformIdSchema = z.enum(PLATFORM_IDS);
+/**
+* Schema for required description (presets require a description).
+* Extends base descriptionSchema with min(1) constraint.
+*/
+const requiredDescriptionSchema = descriptionSchema.min(1, "Description is required");
+const versionSchema = z.string().trim().regex(VERSION_REGEX$1, "Version must be in MAJOR.MINOR format (e.g., 1.3)");
+const majorVersionSchema = z.number().int().positive("Major version must be a positive integer");
 const featureSchema = z.string().trim().min(1, "Feature cannot be empty").max(100, "Feature must be 100 characters or less");
 const featuresSchema = z.array(featureSchema).max(5, "Maximum 5 features allowed");
 const installMessageSchema = z.string().trim().max(2e3, "Install message must be 2000 characters or less");
 const contentSchema = z.string();
-const SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const SLUG_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-preset)";
-const slugSchema = z.string().trim().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(SLUG_REGEX, SLUG_ERROR);
 const COMMON_LICENSES = [
 	"MIT",
 	"Apache-2.0",
@@ -148,60 +286,101 @@ const licenseSchema = z.string().trim().min(1, "License is required").max(128, "
 const pathSchema = z.string().trim().min(1);
 const ignorePatternSchema = z.string().trim().min(1, "Ignore pattern cannot be empty");
 const ignoreSchema = z.array(ignorePatternSchema).max(50, "Maximum 50 ignore patterns allowed");
+/**
+* Schema for agentrulesDir - directory containing metadata files (README, LICENSE, INSTALL).
+* Defaults to ".agentrules" if not specified.
+* Use "." to read metadata from the project root.
+*/
+const agentrulesPathSchema = z.string().trim().min(1, "agentrulesDir cannot be empty");
+/**
+* Platform entry - either a platform ID string or an object with optional path.
+*
+* Examples:
+* - "opencode" (shorthand, uses default directory)
+* - { platform: "opencode", path: "rules" } (custom path)
+*/
+const platformEntryObjectSchema = z.object({
+	platform: platformIdSchema,
+	path: pathSchema.optional()
+}).strict();
+const platformEntrySchema = z.union([platformIdSchema, platformEntryObjectSchema]);
+/**
+* Preset config schema.
+*
+* Uses a unified `platforms` array that accepts either:
+* - Platform ID strings: `["opencode", "claude"]`
+* - Objects with optional path: `[{ platform: "opencode", path: "rules" }]`
+* - Mixed: `["opencode", { platform: "claude", path: "my-claude" }]`
+*/
 const presetConfigSchema = z.object({
 	$schema: z.string().optional(),
-	name: slugSchema,
+	name: nameSchema,
 	title: titleSchema,
 	version: majorVersionSchema.optional(),
-	description: descriptionSchema,
+	description: requiredDescriptionSchema,
 	tags: tagsSchema,
 	features: featuresSchema.optional(),
 	license: licenseSchema,
-	platform: platformIdSchema,
-	path: pathSchema.optional(),
-	ignore: ignoreSchema.optional()
+	ignore: ignoreSchema.optional(),
+	agentrulesDir: agentrulesPathSchema.optional(),
+	platforms: z.array(platformEntrySchema).min(1, "At least one platform is required")
 }).strict();
 const bundledFileSchema = z.object({
 	path: z.string().min(1),
 	size: z.number().int().nonnegative(),
 	checksum: z.string().length(64),
-	contents: z.string()
+	content: z.string()
 });
 /**
-* Schema for what clients send to publish a preset.
+* Schema for per-platform variant in publish input.
+*/
+const publishVariantInputSchema = z.object({
+	platform: platformIdSchema,
+	files: z.array(bundledFileSchema).min(1),
+	readmeContent: contentSchema.optional(),
+	licenseContent: contentSchema.optional(),
+	installMessage: installMessageSchema.optional()
+});
+/**
+* Schema for what clients send to publish a preset (multi-platform).
+*
+* One publish call creates ONE version with ALL platform variants.
 * Version is optional major version. Registry assigns full MAJOR.MINOR.
+*
+* Note: Clients send `name` (e.g., "my-preset"), and the registry defines the format of the slug.
+* For example, a namespaced slug could be returned as "username/my-preset"
 */
 const presetPublishInputSchema = z.object({
-	slug: z.string().trim().min(1),
-	platform: platformIdSchema,
+	name: nameSchema,
 	title: titleSchema,
-	description: descriptionSchema,
+	description: requiredDescriptionSchema,
 	tags: tagsSchema,
 	license: licenseSchema,
-	licenseContent: contentSchema.optional(),
-	readmeContent: contentSchema.optional(),
 	features: featuresSchema.optional(),
-	installMessage: installMessageSchema.optional(),
-	files: z.array(bundledFileSchema).min(1),
+	variants: z.array(publishVariantInputSchema).min(1, "At least one platform variant is required"),
 	version: majorVersionSchema.optional()
 });
 /**
 * Schema for what registries store and return.
-* Includes version (required) - full MAJOR.MINOR format assigned by registry.
-*/
-const presetBundleSchema = presetPublishInputSchema.omit({ version: true }).extend({ version: versionSchema });
-const presetSchema = presetBundleSchema.omit({
-	files: true,
-	readmeContent: true,
-	licenseContent: true,
-	installMessage: true
+* Includes full namespaced slug and version assigned by registry.
+*/
+const presetBundleSchema = presetPublishInputSchema.omit({
+	name: true,
+	version: true
 }).extend({
-	name: z.string().trim().min(1),
-	bundleUrl: z.string().trim().min(1),
-	fileCount: z.number().int().nonnegative(),
-	totalSize: z.number().int().nonnegative()
+	slug: z.string().trim().min(1),
+	version: versionSchema
 });
-const presetIndexSchema = z.record(z.string(), presetSchema);
+
+//#endregion
+//#region src/preset/types.ts
+/**
+* Normalize a raw platform entry to the object form.
+*/
+function normalizePlatformEntry(entry) {
+	if (typeof entry === "string") return { platform: entry };
+	return entry;
+}
 
 //#endregion
 //#region src/builder/utils.ts
@@ -210,9 +389,10 @@ function cleanInstallMessage(value) {
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : void 0;
 }
-function encodeItemName(slug, platform) {
-	return `${slug}.${platform}`;
-}
+/**
+* Validate raw preset config from JSON.
+* Returns the raw config shape (before normalization).
+*/
 function validatePresetConfig(config, slug) {
 	try {
 		return presetConfigSchema.parse(config);
@@ -235,7 +415,7 @@ const NAME_PATTERN = /^[a-z0-9-]+$/;
 * Directory name for bundle files in static registry output.
 * Used by `agentrules registry build` to structure output.
 */
-const STATIC_BUNDLE_DIR = "r";
+const STATIC_BUNDLE_DIR = "registry";
 /**
 * Compute SHA-256 hash using Web Crypto API (works in browser and Node.js 15+)
 */
@@ -246,121 +426,128 @@ async function sha256(data) {
 }
 /**
 * Builds a PresetPublishInput from preset input.
-* Used by CLI to prepare data for publishing to a registry.
+*
+* PresetInput always has platformFiles array (unified format).
 */
 async function buildPresetPublishInput(options) {
-	const { preset: presetInput, version } = options;
-	if (!NAME_PATTERN.test(presetInput.slug)) throw new Error(`Invalid slug "${presetInput.slug}". Slugs must be lowercase kebab-case.`);
-	const presetConfig = validatePresetConfig(presetInput.config, presetInput.slug);
-	const platform = presetConfig.platform;
-	ensureKnownPlatform(platform, presetInput.slug);
-	if (presetInput.files.length === 0) throw new Error(`Preset ${presetInput.slug} does not include any files.`);
-	const files = await createBundledFilesFromInputs(presetInput.files);
-	const installMessage = cleanInstallMessage(presetInput.installMessage);
-	const features = presetConfig.features ?? [];
-	const readmeContent = presetInput.readmeContent?.trim() || void 0;
-	const licenseContent = presetInput.licenseContent?.trim() || void 0;
-	const majorVersion = version ?? presetConfig.version;
+	const { preset, version } = options;
+	if (!NAME_PATTERN.test(preset.name)) throw new Error(`Invalid name "${preset.name}". Names must be lowercase kebab-case.`);
+	const config = validatePresetConfig(preset.config, preset.name);
+	const majorVersion = version ?? config.version;
+	const platforms = preset.config.platforms;
+	if (platforms.length === 0) throw new Error(`Preset ${preset.name} must specify at least one platform.`);
+	for (const entry of platforms) ensureKnownPlatform(entry.platform, preset.name);
+	const variants = [];
+	for (const entry of platforms) {
+		const platformData = preset.platformFiles.find((pf) => pf.platform === entry.platform);
+		if (!platformData) throw new Error(`Preset ${preset.name} is missing files for platform "${entry.platform}".`);
+		if (platformData.files.length === 0) throw new Error(`Preset ${preset.name} has no files for platform "${entry.platform}".`);
+		const files = await createBundledFilesFromInputs(platformData.files);
+		variants.push({
+			platform: entry.platform,
+			files,
+			readmeContent: platformData.readmeContent?.trim() || preset.readmeContent?.trim() || void 0,
+			licenseContent: platformData.licenseContent?.trim() || preset.licenseContent?.trim() || void 0,
+			installMessage: cleanInstallMessage(platformData.installMessage) || cleanInstallMessage(preset.installMessage)
+		});
+	}
 	return {
-		slug: presetInput.slug,
-		platform,
-		title: presetConfig.title,
-		description: presetConfig.description,
-		tags: presetConfig.tags ?? [],
-		license: presetConfig.license,
-		licenseContent,
-		readmeContent,
-		features,
-		installMessage,
-		files,
+		name: preset.name,
+		title: config.title,
+		description: config.description,
+		tags: config.tags ?? [],
+		license: config.license,
+		features: config.features ?? [],
+		variants,
 		...majorVersion !== void 0 && { version: majorVersion }
 	};
 }
 /**
-* Builds a static registry with entries, index, and bundles.
-* Used for building static registry files (e.g., community-presets).
-* Each preset uses its version from config (default: major 1, minor 0).
+* Builds a static registry with items and bundles.
+*
+* Uses the same model as dynamic publishing:
+* - Each PresetInput (single or multi-platform) becomes one item
+* - Each platform variant becomes one bundle
 */
 async function buildPresetRegistry(options) {
 	const bundleBase = normalizeBundleBase(options.bundleBase);
-	const entries = [];
+	const items = [];
 	const bundles = [];
 	for (const presetInput of options.presets) {
-		if (!NAME_PATTERN.test(presetInput.slug)) throw new Error(`Invalid slug "${presetInput.slug}". Slugs must be lowercase kebab-case.`);
-		const presetConfig = validatePresetConfig(presetInput.config, presetInput.slug);
-		const platform = presetConfig.platform;
-		ensureKnownPlatform(platform, presetInput.slug);
-		if (presetInput.files.length === 0) throw new Error(`Preset ${presetInput.slug} does not include any files.`);
-		const files = await createBundledFilesFromInputs(presetInput.files);
-		const totalSize = files.reduce((sum, file) => sum + file.size, 0);
-		const installMessage = cleanInstallMessage(presetInput.installMessage);
-		const features = presetConfig.features ?? [];
-		const readmeContent = presetInput.readmeContent?.trim() || void 0;
-		const licenseContent = presetInput.licenseContent?.trim() || void 0;
-		const majorVersion = presetConfig.version ?? 1;
-		const version = `${majorVersion}.0`;
-		const entry = {
-			name: encodeItemName(presetInput.slug, platform),
-			slug: presetInput.slug,
-			platform,
-			title: presetConfig.title,
-			version,
-			description: presetConfig.description,
-			tags: presetConfig.tags ?? [],
-			license: presetConfig.license,
-			features,
-			bundleUrl: getBundlePath(bundleBase, presetInput.slug, platform, version),
-			fileCount: files.length,
-			totalSize
-		};
-		entries.push(entry);
-		const bundle = {
-			slug: presetInput.slug,
-			platform,
-			title: presetConfig.title,
-			version,
-			description: presetConfig.description,
-			tags: presetConfig.tags ?? [],
-			license: presetConfig.license,
-			licenseContent,
-			readmeContent,
-			features,
-			installMessage,
-			files
+		const publishInput = await buildPresetPublishInput({ preset: presetInput });
+		const slug = publishInput.name;
+		const version = `${publishInput.version ?? 1}.0`;
+		const presetVariants = publishInput.variants.map((v) => ({
+			platform: v.platform,
+			bundleUrl: getBundlePath(bundleBase, slug, v.platform, version),
+			fileCount: v.files.length,
+			totalSize: v.files.reduce((sum, f) => sum + f.content.length, 0)
+		}));
+		presetVariants.sort((a, b) => a.platform.localeCompare(b.platform));
+		const item = {
+			kind: "preset",
+			slug,
+			name: publishInput.title,
+			title: publishInput.title,
+			description: publishInput.description,
+			tags: publishInput.tags,
+			license: publishInput.license,
+			features: publishInput.features ?? [],
+			versions: [{
+				version,
+				isLatest: true,
+				variants: presetVariants
+			}]
 		};
-		bundles.push(bundle);
+		items.push(item);
+		for (const variant of publishInput.variants) {
+			const bundle = {
+				name: publishInput.name,
+				slug,
+				platform: variant.platform,
+				title: publishInput.title,
+				version,
+				description: publishInput.description,
+				tags: publishInput.tags,
+				license: publishInput.license,
+				features: publishInput.features,
+				files: variant.files,
+				readmeContent: variant.readmeContent,
+				licenseContent: variant.licenseContent,
+				installMessage: variant.installMessage
+			};
+			bundles.push(bundle);
+		}
 	}
-	sortBySlugAndPlatform(entries);
-	sortBySlugAndPlatform(bundles);
-	const index = entries.reduce((acc, entry) => {
-		acc[entry.name] = entry;
-		return acc;
-	}, {});
+	items.sort((a, b) => a.slug.localeCompare(b.slug));
+	bundles.sort((a, b) => {
+		if (a.slug === b.slug) return a.platform.localeCompare(b.platform);
+		return a.slug.localeCompare(b.slug);
+	});
 	return {
-		entries,
-		index,
+		items,
 		bundles
 	};
 }
 async function createBundledFilesFromInputs(files) {
 	const results = await Promise.all(files.map(async (file) => {
-		const payload = normalizeFilePayload(file.contents);
-		const contents = encodeFilePayload(payload, file.path);
+		const payload = normalizeFilePayload(file.content);
+		const content = encodeFilePayload(payload, file.path);
 		const checksum = await sha256(payload);
 		return {
 			path: toPosixPath(file.path),
 			size: payload.length,
 			checksum,
-			contents
+			content
 		};
 	}));
 	return results.sort((a, b) => a.path.localeCompare(b.path));
 }
-function normalizeFilePayload(contents) {
-	if (typeof contents === "string") return new TextEncoder().encode(contents);
-	if (contents instanceof ArrayBuffer) return new Uint8Array(contents);
-	if (ArrayBuffer.isView(contents)) return new Uint8Array(contents.buffer, contents.byteOffset, contents.byteLength);
-	return new Uint8Array(contents);
+function normalizeFilePayload(content) {
+	if (typeof content === "string") return new TextEncoder().encode(content);
+	if (content instanceof ArrayBuffer) return new Uint8Array(content);
+	if (ArrayBuffer.isView(content)) return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+	return new Uint8Array(content);
 }
 function encodeFilePayload(data, filePath) {
 	const decoder = new TextDecoder("utf-8", { fatal: true });
@@ -370,36 +557,22 @@ function encodeFilePayload(data, filePath) {
 		throw new Error(`Binary files are not supported: "${filePath}". Only UTF-8 text files are allowed.`);
 	}
 }
-/**
-* Normalize bundle base by removing trailing slashes.
-* Returns empty string if base is undefined/empty (use default relative path).
-*/
 function normalizeBundleBase(base) {
 	if (!base) return "";
 	return base.replace(/\/+$/, "");
 }
-/**
-* Returns the bundle URL/path for a preset.
-* Format: {base}/{STATIC_BUNDLE_DIR}/{slug}/{platform}/{version}
-*/
-function getBundlePath(base, slug, platform, version = LATEST_VERSION) {
+function getBundlePath(base, slug, platform, version) {
 	const prefix = base ? `${base}/` : "";
 	return `${prefix}${STATIC_BUNDLE_DIR}/${slug}/${platform}/${version}`;
 }
 function ensureKnownPlatform(platform, slug) {
 	if (!isSupportedPlatform(platform)) throw new Error(`Unknown platform "${platform}" in ${slug}. Supported: ${PLATFORM_IDS.join(", ")}`);
 }
-function sortBySlugAndPlatform(items) {
-	items.sort((a, b) => {
-		if (a.slug === b.slug) return a.platform.localeCompare(b.platform);
-		return a.slug.localeCompare(b.slug);
-	});
-}
 
 //#endregion
 //#region src/client/bundle.ts
 function decodeBundledFile(file) {
-	return encodeUtf8(file.contents);
+	return encodeUtf8(file.content);
 }
 async function verifyBundledFileChecksum(file, payload) {
 	const bytes = toUint8Array(payload);
@@ -427,39 +600,48 @@ async function sha256Hex(payload) {
 }
 
 //#endregion
-//#region src/client/registry.ts
+//#region src/constants.ts
+/**
+* Shared constants for agentrules presets and registry.
+*/
+/** Filename for preset configuration */
+const PRESET_CONFIG_FILENAME = "agentrules.json";
+/** Directory name for preset metadata (README, LICENSE, etc.) */
+const AGENT_RULES_DIR = ".agentrules";
+/** JSON Schema URL for preset configuration */
+const PRESET_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
+/** API root path segment */
+const API_PATH = "api";
+/** Default version identifier for latest preset version */
+const LATEST_VERSION = "latest";
 /**
-* Resolves a preset from the registry via API endpoint.
-* Returns the entry metadata and the absolute bundle URL.
+* API endpoint paths (relative to registry base URL).
 *
-* @param baseUrl - Registry base URL
-* @param slug - Preset slug
-* @param platform - Target platform
-* @param version - Version to resolve (defaults to "latest")
+* Note on slug handling:
+* - Slugs may contain slashes (e.g., "username/my-preset") which flow through as path segments
+* - The client is responsible for validating values before making requests
 */
-async function resolvePreset(baseUrl, slug, platform, version = LATEST_VERSION) {
-	const apiUrl = new URL(API_ENDPOINTS.presets.get(slug, platform, version), baseUrl);
-	const response = await fetch(apiUrl);
-	if (!response.ok) {
-		if (response.status === 404) {
-			const versionInfo = version === LATEST_VERSION ? "" : ` version "${version}"`;
-			throw new Error(`Preset "${slug}"${versionInfo} for platform "${platform}" was not found in the registry.`);
-		}
-		throw new Error(`Failed to resolve preset (${response.status} ${response.statusText}).`);
-	}
-	try {
-		const preset = await response.json();
-		const resolvedBundleUrl = new URL(preset.bundleUrl, baseUrl).toString();
-		return {
-			preset,
-			bundleUrl: resolvedBundleUrl
-		};
-	} catch (error) {
-		throw new Error(`Unable to parse preset response: ${error.message}`);
-	}
-}
+const API_ENDPOINTS = {
+	presets: {
+		base: `${API_PATH}/presets`,
+		unpublish: (slug, version) => `${API_PATH}/presets/${slug}/${version}`
+	},
+	auth: {
+		session: `${API_PATH}/auth/get-session`,
+		deviceCode: `${API_PATH}/auth/device/code`,
+		deviceToken: `${API_PATH}/auth/device/token`
+	},
+	rules: {
+		base: `${API_PATH}/rules`,
+		bySlug: (slug) => `${API_PATH}/rules/${slug}`
+	},
+	items: { get: (slug) => `${API_PATH}/items/${slug}` }
+};
+
+//#endregion
+//#region src/client/registry.ts
 /**
-* Fetches a bundle from an absolute URL or resolves it relative to the registry.
+* Fetches a bundle from an absolute URL.
 */
 async function fetchBundle(bundleUrl) {
 	const response = await fetch(bundleUrl);
@@ -470,6 +652,232 @@ async function fetchBundle(bundleUrl) {
 		throw new Error(`Unable to parse bundle JSON: ${error.message}`);
 	}
 }
+/**
+* Resolves a slug to get all versions and platform variants.
+*
+* @param baseUrl - Registry base URL
+* @param slug - Content slug (may contain slashes, e.g., "username/my-preset")
+* @param version - Optional version filter (server may ignore for static registries)
+* @returns Resolved data, or null if not found
+* @throws Error on network/server errors
+*/
+async function resolveSlug(baseUrl, slug, version) {
+	const url = new URL(API_ENDPOINTS.items.get(slug), baseUrl);
+	if (version) url.searchParams.set("version", version);
+	let response;
+	try {
+		response = await fetch(url);
+	} catch (error) {
+		throw new Error(`Failed to connect to registry: ${error.message}`);
+	}
+	if (response.status === 404) return null;
+	if (!response.ok) {
+		let errorMessage = `Registry returned ${response.status} ${response.statusText}`;
+		try {
+			const body = await response.json();
+			if (body && typeof body === "object" && "error" in body && typeof body.error === "string") errorMessage = body.error;
+		} catch {}
+		throw new Error(errorMessage);
+	}
+	const data = await response.json();
+	if (data.kind === "preset") {
+		for (const ver of data.versions) for (const variant of ver.variants) if ("bundleUrl" in variant) variant.bundleUrl = new URL(variant.bundleUrl, baseUrl).toString();
+	}
+	return data;
+}
+
+//#endregion
+//#region src/resolve/schema.ts
+const VERSION_REGEX = /^[1-9]\d*\.\d+$/;
+const presetVariantBundleSchema = z.object({
+	platform: platformIdSchema,
+	bundleUrl: z.string().min(1),
+	fileCount: z.number().int().nonnegative(),
+	totalSize: z.number().int().nonnegative()
+});
+const presetVariantInlineSchema = z.object({
+	platform: platformIdSchema,
+	content: z.string().min(1),
+	fileCount: z.number().int().nonnegative(),
+	totalSize: z.number().int().nonnegative()
+});
+const presetVariantSchema = z.union([presetVariantBundleSchema, presetVariantInlineSchema]);
+const ruleVariantSchema = z.object({
+	platform: platformIdSchema,
+	type: z.string().min(1),
+	content: z.string().min(1)
+});
+const presetVersionSchema = z.object({
+	version: z.string().regex(VERSION_REGEX, "Version must be MAJOR.MINOR format"),
+	isLatest: z.boolean(),
+	publishedAt: z.string().datetime().optional(),
+	variants: z.array(presetVariantSchema).min(1)
+});
+const ruleVersionSchema = z.object({
+	version: z.string().regex(VERSION_REGEX, "Version must be MAJOR.MINOR format"),
+	isLatest: z.boolean(),
+	publishedAt: z.string().datetime().optional(),
+	variants: z.array(ruleVariantSchema).min(1)
+});
+const resolvedPresetSchema = z.object({
+	kind: z.literal("preset"),
+	slug: z.string().min(1),
+	name: z.string().min(1),
+	title: z.string().min(1),
+	description: z.string(),
+	tags: z.array(z.string()),
+	license: z.string(),
+	features: z.array(z.string()),
+	versions: z.array(presetVersionSchema).min(1)
+});
+const resolvedRuleSchema = z.object({
+	kind: z.literal("rule"),
+	slug: z.string().min(1),
+	name: z.string().min(1),
+	title: z.string().min(1),
+	description: z.string(),
+	tags: z.array(z.string()),
+	versions: z.array(ruleVersionSchema).min(1)
+});
+const resolveResponseSchema = z.discriminatedUnion("kind", [resolvedPresetSchema, resolvedRuleSchema]);
+
+//#endregion
+//#region src/resolve/utils.ts
+/**
+* Type guard for preset
+*/
+function isPreset(item) {
+	return item.kind === "preset";
+}
+/**
+* Type guard for rule
+*/
+function isRule(item) {
+	return item.kind === "rule";
+}
+/**
+* Type guard for preset variant with bundleUrl
+*/
+function hasBundle(variant) {
+	return "bundleUrl" in variant;
+}
+/**
+* Type guard for preset variant with inline content
+*/
+function hasInlineContent(variant) {
+	return "content" in variant;
+}
+/**
+* Get the latest version from a resolved preset
+*/
+function getLatestPresetVersion(item) {
+	return item.versions.find((v) => v.isLatest);
+}
+/**
+* Get the latest version from a resolved rule
+*/
+function getLatestRuleVersion(item) {
+	return item.versions.find((v) => v.isLatest);
+}
+/**
+* Get a specific version from a resolved preset
+*/
+function getPresetVersion(item, version) {
+	return item.versions.find((v) => v.version === version);
+}
+/**
+* Get a specific version from a resolved rule
+*/
+function getRuleVersion(item, version) {
+	return item.versions.find((v) => v.version === version);
+}
+/**
+* Get a specific platform variant from a preset version
+*/
+function getPresetVariant(version, platform) {
+	return version.variants.find((v) => v.platform === platform);
+}
+/**
+* Get a specific platform variant from a rule version
+*/
+function getRuleVariant(version, platform) {
+	return version.variants.find((v) => v.platform === platform);
+}
+/**
+* Get all available platforms for a preset version
+*/
+function getPresetPlatforms(version) {
+	return version.variants.map((v) => v.platform);
+}
+/**
+* Get all available platforms for a rule version
+*/
+function getRulePlatforms(version) {
+	return version.variants.map((v) => v.platform);
+}
+/**
+* Check if a platform is available in any version of a preset
+*/
+function presetHasPlatform(item, platform) {
+	return item.versions.some((v) => v.variants.some((variant) => variant.platform === platform));
+}
+/**
+* Check if a platform is available in any version of a rule
+*/
+function ruleHasPlatform(item, platform) {
+	return item.versions.some((v) => v.variants.some((variant) => variant.platform === platform));
+}
+
+//#endregion
+//#region src/rule/schema.ts
+/**
+* Rule-specific schema aliases.
+* All use shared schemas for consistency with presets:
+* - name: max 64 chars, lowercase kebab-case
+* - title: max 80 chars
+* - description: max 500 chars (optional for rules)
+* - tags: max 35 chars each, 1-10 required, platform names blocked
+*/
+const ruleNameSchema = nameSchema;
+const ruleTitleSchema = titleSchema;
+const ruleDescriptionSchema = descriptionSchema;
+const ruleTagSchema = tagSchema;
+const ruleTagsSchema = tagsSchema;
+const rulePlatformSchema = z.enum(PLATFORM_IDS);
+const ruleTypeSchema = z.string().trim().min(1).max(32);
+const ruleContentSchema = z.string().min(1, "Content is required").max(1e5, "Content must be 100KB or less");
+/** Common fields shared across all platform-type combinations */
+const ruleCommonFields = {
+	name: ruleNameSchema,
+	title: ruleTitleSchema,
+	description: ruleDescriptionSchema.optional(),
+	content: ruleContentSchema,
+	tags: ruleTagsSchema
+};
+/**
+* Discriminated union schema for platform + type combinations.
+* Each platform has its own set of valid types.
+*/
+const rulePlatformTypeSchema = z.discriminatedUnion("platform", [
+	z.object({
+		platform: z.literal("opencode"),
+		type: z.enum(PLATFORM_RULE_TYPES.opencode)
+	}),
+	z.object({
+		platform: z.literal("claude"),
+		type: z.enum(PLATFORM_RULE_TYPES.claude)
+	}),
+	z.object({
+		platform: z.literal("cursor"),
+		type: z.enum(PLATFORM_RULE_TYPES.cursor)
+	}),
+	z.object({
+		platform: z.literal("codex"),
+		type: z.enum(PLATFORM_RULE_TYPES.codex)
+	})
+]);
+/** Schema for rule creation with discriminated union for platform+type */
+const ruleCreateInputSchema = z.object(ruleCommonFields).and(rulePlatformTypeSchema);
 
 //#endregion
 //#region src/utils/diff.ts
@@ -495,4 +903,4 @@ function normalizeBundlePath(value) {
 }
 
 //#endregion
-export { AGENT_RULES_DIR, API_ENDPOINTS, COMMON_LICENSES, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PRESET_CONFIG_FILENAME, PRESET_SCHEMA_URL, STATIC_BUNDLE_DIR, buildPresetPublishInput, buildPresetRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeItemName, encodeUtf8, fetchBundle, getPlatformFromDir, isLikelyText, isPlatformDir, isSupportedPlatform, licenseSchema, normalizeBundlePath, normalizePlatformInput, platformIdSchema, presetBundleSchema, presetConfigSchema, presetIndexSchema, presetPublishInputSchema, presetSchema, resolvePreset, slugSchema, tagSchema, tagsSchema, titleSchema, toPosixPath, toUint8Array, toUtf8String, validatePresetConfig, verifyBundledFileChecksum };
+export { AGENT_RULES_DIR, API_ENDPOINTS, COMMON_LICENSES, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PLATFORM_RULE_TYPES, PRESET_CONFIG_FILENAME, PRESET_SCHEMA_URL, STATIC_BUNDLE_DIR, buildPresetPublishInput, buildPresetRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeUtf8, fetchBundle, getInstallPath, getLatestPresetVersion, getLatestRuleVersion, getPlatformConfig, getPlatformFromDir, getPresetPlatforms, getPresetVariant, getPresetVersion, getRulePlatforms, getRuleTypeConfig, getRuleVariant, getRuleVersion, getValidRuleTypes, hasBundle, hasInlineContent, isLikelyText, isPlatformDir, isPreset, isRule, isSupportedPlatform, isValidRuleType, licenseSchema, nameSchema, normalizeBundlePath, normalizePlatformEntry, normalizePlatformInput, platformIdSchema, presetBundleSchema, presetConfigSchema, presetHasPlatform, presetPublishInputSchema, presetVariantSchema, presetVersionSchema, publishVariantInputSchema, requiredDescriptionSchema, resolveResponseSchema, resolveSlug, resolvedPresetSchema, resolvedRuleSchema, ruleContentSchema, ruleCreateInputSchema, ruleDescriptionSchema, ruleHasPlatform, ruleNameSchema, rulePlatformSchema, rulePlatformTypeSchema, ruleTagSchema, ruleTagsSchema, ruleTitleSchema, ruleTypeSchema, ruleVariantSchema, ruleVersionSchema, tagSchema, tagsSchema, titleSchema, toPosixPath, toUint8Array, toUtf8String, validatePresetConfig, verifyBundledFileChecksum };