@agentrules/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -11,172 +11,174 @@ const PLATFORM_ID_TUPLE = [
 	"claude",
 	"cursor"
 ];
+/** Tuple of all rule types for schema validation */
+const RULE_TYPE_TUPLE = [
+	"instruction",
+	"rule",
+	"command",
+	"skill",
+	"agent",
+	"tool"
+];
 
 //#endregion
 //#region src/platform/config.ts
 const PLATFORM_IDS = PLATFORM_ID_TUPLE;
 /**
-* Platform configuration including supported rule types and install paths.
+* Platform configuration including supported types and install paths.
 */
 const PLATFORMS = {
 	opencode: {
 		label: "OpenCode",
-		projectDir: ".opencode",
+		platformDir: ".opencode",
 		globalDir: "~/.config/opencode",
 		types: {
 			instruction: {
 				description: "Project instructions",
-				format: "markdown",
-				extension: "md",
-				projectPath: "AGENTS.md",
-				globalPath: "~/.config/opencode/AGENTS.md"
+				project: "AGENTS.md",
+				global: "{platformDir}/AGENTS.md"
 			},
 			agent: {
 				description: "Specialized AI agent",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".opencode/agent/{name}.md",
-				globalPath: "~/.config/opencode/agent/{name}.md"
+				project: "{platformDir}/agent/{name}.md",
+				global: "{platformDir}/agent/{name}.md"
 			},
 			command: {
 				description: "Custom slash command",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".opencode/command/{name}.md",
-				globalPath: "~/.config/opencode/command/{name}.md"
+				project: "{platformDir}/command/{name}.md",
+				global: "{platformDir}/command/{name}.md"
 			},
 			tool: {
 				description: "Custom tool",
-				format: "typescript",
-				extension: "ts",
-				projectPath: ".opencode/tool/{name}.ts",
-				globalPath: "~/.config/opencode/tool/{name}.ts"
+				project: "{platformDir}/tool/{name}.ts",
+				global: "{platformDir}/tool/{name}.ts"
 			}
 		}
 	},
 	claude: {
 		label: "Claude Code",
-		projectDir: ".claude",
+		platformDir: ".claude",
 		globalDir: "~/.claude",
 		types: {
 			instruction: {
 				description: "Project instructions",
-				format: "markdown",
-				extension: "md",
-				projectPath: "CLAUDE.md",
-				globalPath: "~/.claude/CLAUDE.md"
+				project: "CLAUDE.md",
+				global: "{platformDir}/CLAUDE.md"
+			},
+			rule: {
+				description: "Project rule",
+				project: "{platformDir}/rules/{name}.md",
+				global: "{platformDir}/rules/{name}.md"
 			},
 			command: {
 				description: "Custom slash command",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".claude/commands/{name}.md",
-				globalPath: "~/.claude/commands/{name}.md"
+				project: "{platformDir}/commands/{name}.md",
+				global: "{platformDir}/commands/{name}.md"
 			},
 			skill: {
 				description: "Custom skill",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".claude/skills/{name}/SKILL.md",
-				globalPath: "~/.claude/skills/{name}/SKILL.md"
+				project: "{platformDir}/skills/{name}/SKILL.md",
+				global: "{platformDir}/skills/{name}/SKILL.md"
 			}
 		}
 	},
 	cursor: {
 		label: "Cursor",
-		projectDir: ".cursor",
+		platformDir: ".cursor",
 		globalDir: "~/.cursor",
 		types: {
 			instruction: {
 				description: "Project instructions",
-				format: "markdown",
-				extension: "md",
-				projectPath: "AGENTS.md",
-				globalPath: null
+				project: "AGENTS.md",
+				global: null
 			},
 			rule: {
 				description: "Custom rule",
-				format: "mdc",
-				extension: "mdc",
-				projectPath: ".cursor/rules/{name}.mdc",
-				globalPath: null
+				project: "{platformDir}/rules/{name}.mdc",
+				global: null
 			},
 			command: {
 				description: "Custom slash command",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".cursor/commands/{name}.md",
-				globalPath: "~/.cursor/commands/{name}.md"
+				project: "{platformDir}/commands/{name}.md",
+				global: "{platformDir}/commands/{name}.md"
 			}
 		}
 	},
 	codex: {
 		label: "Codex",
-		projectDir: ".codex",
+		platformDir: ".codex",
 		globalDir: "~/.codex",
 		types: {
 			instruction: {
 				description: "Project instructions",
-				format: "markdown",
-				extension: "md",
-				projectPath: "AGENTS.md",
-				globalPath: "~/.codex/AGENTS.md"
+				project: "AGENTS.md",
+				global: "{platformDir}/AGENTS.md"
 			},
 			command: {
 				description: "Custom prompt",
-				format: "markdown",
-				extension: "md",
-				projectPath: null,
-				globalPath: "~/.codex/prompts/{name}.md"
+				project: null,
+				global: "{platformDir}/prompts/{name}.md"
 			}
 		}
 	}
 };
-/** Valid rule types for each platform. Must be kept in sync with PLATFORMS. */
+/** Get valid types for a specific platform */
+function getValidTypes(platform) {
+	return Object.keys(PLATFORMS[platform].types);
+}
+/** Check if a type is valid for a given platform */
+function isValidType(platform, type) {
+	return type in PLATFORMS[platform].types;
+}
+/** Get the configuration for a specific platform + type combination */
+function getTypeConfig(platform, type) {
+	const platformConfig = PLATFORMS[platform];
+	return platformConfig.types[type];
+}
+function supportsInstallPath({ platform, type, scope = "project" }) {
+	const typeConfig = getTypeConfig(platform, type);
+	if (!typeConfig) return false;
+	const template = scope === "project" ? typeConfig.project : typeConfig.global;
+	return template !== null;
+}
+function getInstallPath({ platform, type, name, scope = "project" }) {
+	const platformConfig = PLATFORMS[platform];
+	const typeConfig = getTypeConfig(platform, type);
+	if (!typeConfig) return null;
+	const template = scope === "project" ? typeConfig.project : typeConfig.global;
+	if (!template) return null;
+	const rootDir = scope === "project" ? platformConfig.platformDir : platformConfig.globalDir;
+	if (template.includes("{name}") && !name) throw new Error(`Missing name for install path: platform="${platform}" type="${type}" scope="${scope}"`);
+	return template.replace("{platformDir}", rootDir).replace("{name}", name ?? "");
+}
+/** Get platform configuration */
+function getPlatformConfig(platform) {
+	return PLATFORMS[platform];
+}
+/**
+* Platform-specific type tuples for zod schema validation.
+* Must be kept in sync with PLATFORMS types above.
+*/
 const PLATFORM_RULE_TYPES = {
 	opencode: [
 		"instruction",
-		"command",
 		"agent",
+		"command",
 		"tool"
 	],
 	claude: [
 		"instruction",
+		"rule",
 		"command",
 		"skill"
 	],
-	codex: ["instruction", "command"],
 	cursor: [
 		"instruction",
-		"command",
-		"rule"
-	]
+		"rule",
+		"command"
+	],
+	codex: ["instruction", "command"]
 };
-/** 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
@@ -189,19 +191,89 @@ function normalizePlatformInput(value) {
 	throw new Error(`Unknown platform "${value}". Supported platforms: ${PLATFORM_IDS.join(", ")}.`);
 }
 /**
-* Check if a directory name matches a platform's projectDir.
-* Used to detect if a preset config is inside a platform directory (in-project mode).
+* Check if a directory name matches a platform's platformDir.
+* Used to detect if a rule config is inside a platform directory (in-project mode).
 */
 function isPlatformDir(dirName) {
-	return PLATFORM_IDS.some((id) => PLATFORMS[id].projectDir === dirName);
+	return PLATFORM_IDS.some((id) => PLATFORMS[id].platformDir === dirName);
 }
 /**
-* Get the platform ID from a directory name, if it matches a platform's projectDir.
+* Get the platform ID from a directory name, if it matches a platform's platformDir.
 */
 function getPlatformFromDir(dirName) {
-	for (const id of PLATFORM_IDS) if (PLATFORMS[id].projectDir === dirName) return id;
+	for (const id of PLATFORM_IDS) if (PLATFORMS[id].platformDir === dirName) return id;
+	return;
+}
+function normalizePathForInference(value) {
+	return value.replace(/\\/g, "/");
+}
+function getBasename(value) {
+	const normalized = normalizePathForInference(value);
+	const segments = normalized.split("/").filter(Boolean);
+	return segments.at(-1) ?? "";
+}
+/**
+* Infer the platform from a file path by searching for platformDir segments.
+*
+* Example: "/repo/.claude/commands/foo.md" -> "claude"
+*/
+function inferPlatformFromPath(value) {
+	const normalized = normalizePathForInference(value);
+	const segments = normalized.split("/").filter(Boolean);
+	const matches = PLATFORM_IDS.filter((id) => segments.includes(PLATFORMS[id].platformDir));
+	if (matches.length === 1) return matches[0];
 	return;
 }
+/**
+* Return all platforms whose instruction file matches this basename.
+*
+* Example: "CLAUDE.md" -> ["claude"], "AGENTS.md" -> ["opencode", "cursor", "codex"]
+*/
+function inferInstructionPlatformsFromFileName(fileName) {
+	const matches = [];
+	for (const id of PLATFORM_IDS) {
+		const instructionPath = getInstallPath({
+			platform: id,
+			type: "instruction",
+			scope: "project"
+		});
+		if (instructionPath === fileName) matches.push(id);
+	}
+	return matches;
+}
+function getProjectTypeDirMap(platform) {
+	const map = new Map();
+	for (const [type, cfg] of Object.entries(PLATFORMS[platform].types)) {
+		const template = cfg.project;
+		if (!template) continue;
+		if (!template.startsWith("{platformDir}/")) continue;
+		const rest = template.slice(14);
+		const dir = rest.split("/")[0];
+		if (!dir || dir.includes("{")) continue;
+		map.set(dir, type);
+	}
+	return map;
+}
+/**
+* Infer a rule type from a file path for a known platform.
+* Uses PLATFORMS templates as source-of-truth.
+*/
+function inferTypeFromPath(platform, filePath) {
+	const base = getBasename(filePath);
+	const instructionPath = getInstallPath({
+		platform,
+		type: "instruction",
+		scope: "project"
+	});
+	if (instructionPath === base) return "instruction";
+	const normalized = normalizePathForInference(filePath);
+	const segments = normalized.split("/").filter(Boolean);
+	const platformDirIndex = segments.lastIndexOf(PLATFORMS[platform].platformDir);
+	if (platformDirIndex < 0) return;
+	const nextDir = segments[platformDirIndex + 1];
+	if (!nextDir) return;
+	return getProjectTypeDirMap(platform).get(nextDir);
+}
 
 //#endregion
 //#region src/utils/encoding.ts
@@ -215,7 +287,10 @@ function encodeUtf8(value) {
 function decodeUtf8(payload) {
 	const bytes = toUint8Array(payload);
 	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("utf8");
-	return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+	return new TextDecoder("utf-8", {
+		fatal: false,
+		ignoreBOM: false
+	}).decode(bytes);
 }
 function toUint8Array(payload) {
 	if (payload instanceof Uint8Array) return payload;
@@ -237,13 +312,13 @@ const TAG_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-tag)";
 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
+* - 0-10 tags allowed
 */
-const tagsSchema = z.array(tagSchema).min(1, "At least one tag is required").max(10, "Maximum 10 tags allowed");
+const tagsSchema = z.array(tagSchema).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)";
+const NAME_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-rule)";
 /**
-* Schema for preset/rule name.
+* Schema for rule name.
 * - Max 64 characters
 * - Lowercase alphanumeric with hyphens
 */
@@ -260,14 +335,11 @@ const titleSchema = z.string().trim().min(1, "Title is required").max(80, "Title
 const descriptionSchema = z.string().trim().max(500, "Description must be 500 characters or less");
 
 //#endregion
-//#region src/preset/schema.ts
+//#region src/rule/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 normalizedDescriptionSchema = descriptionSchema.optional().default("");
+const normalizedTagsSchema = tagsSchema.optional().default([]);
 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");
@@ -287,12 +359,6 @@ 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:
@@ -305,24 +371,32 @@ const platformEntryObjectSchema = z.object({
 }).strict();
 const platformEntrySchema = z.union([platformIdSchema, platformEntryObjectSchema]);
 /**
-* Preset config schema.
+* Schema for rule type.
+* Valid types: instruction, rule, command, skill, agent, tool, multi.
+* Optional - defaults to "multi" (freeform file structure).
+* Platform-specific validation happens at publish time.
+*/
+const ruleTypeSchema = z.enum(RULE_TYPE_TUPLE);
+const typeSchema = ruleTypeSchema.optional();
+/**
+* Rule 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({
+const ruleConfigSchema = z.object({
 	$schema: z.string().optional(),
 	name: nameSchema,
+	type: typeSchema,
 	title: titleSchema,
 	version: majorVersionSchema.optional(),
-	description: requiredDescriptionSchema,
-	tags: tagsSchema,
+	description: normalizedDescriptionSchema,
+	tags: normalizedTagsSchema,
 	features: featuresSchema.optional(),
 	license: licenseSchema,
 	ignore: ignoreSchema.optional(),
-	agentrulesDir: agentrulesPathSchema.optional(),
 	platforms: z.array(platformEntrySchema).min(1, "At least one platform is required")
 }).strict();
 const bundledFileSchema = z.object({
@@ -342,46 +416,74 @@ const publishVariantInputSchema = z.object({
 	installMessage: installMessageSchema.optional()
 });
 /**
-* Schema for what clients send to publish a preset (multi-platform).
+* Schema for what clients send to publish a rule.
 *
 * 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"
+* Note: Clients send `name` (e.g., "my-rule"), and the registry defines the format of the slug.
+* For example, a namespaced slug could be returned as "username/my-rule"
 */
-const presetPublishInputSchema = z.object({
+const rulePublishInputSchema = z.object({
 	name: nameSchema,
+	type: typeSchema,
 	title: titleSchema,
-	description: requiredDescriptionSchema,
-	tags: tagsSchema,
+	description: normalizedDescriptionSchema,
+	tags: normalizedTagsSchema,
 	license: licenseSchema,
 	features: featuresSchema.optional(),
 	variants: z.array(publishVariantInputSchema).min(1, "At least one platform variant is required"),
 	version: majorVersionSchema.optional()
 });
 /**
-* Schema for what registries store and return.
-* Includes full namespaced slug and version assigned by registry.
+* Schema for what registries store and return for a single platform bundle.
+* This is per-platform (flat structure), stored in R2 and fetched via bundleUrl.
 */
-const presetBundleSchema = presetPublishInputSchema.omit({
-	name: true,
-	version: true
-}).extend({
+const ruleBundleSchema = z.object({
+	name: nameSchema,
+	type: typeSchema,
+	platform: platformIdSchema,
+	title: titleSchema,
+	description: normalizedDescriptionSchema,
+	tags: normalizedTagsSchema,
+	license: licenseSchema,
+	features: featuresSchema.optional(),
+	files: z.array(bundledFileSchema).min(1, "At least one file is required"),
+	readmeContent: contentSchema.optional(),
+	licenseContent: contentSchema.optional(),
+	installMessage: installMessageSchema.optional(),
 	slug: z.string().trim().min(1),
 	version: versionSchema
 });
 
 //#endregion
-//#region src/preset/types.ts
-/**
-* Normalize a raw platform entry to the object form.
-*/
+//#region src/rule/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/rule/validate.ts
+function validateRule(config) {
+	const errors = [];
+	const warnings = [];
+	if (!config.platforms || config.platforms.length === 0) errors.push("At least one platform is required.");
+	for (const entry of config.platforms) if (!isSupportedPlatform(entry.platform)) errors.push(`Unknown platform "${entry.platform}". Supported: ${PLATFORM_IDS.join(", ")}`);
+	if (config.type) for (const entry of config.platforms) {
+		if (!isSupportedPlatform(entry.platform)) continue;
+		if (!isValidType(entry.platform, config.type)) errors.push(`Platform "${entry.platform}" does not support type "${config.type}". Rule "${config.name}" cannot target this platform with type "${config.type}".`);
+	}
+	const hasPlaceholderFeatures = config.features?.some((feature) => feature.trim().startsWith("//"));
+	if (hasPlaceholderFeatures) errors.push("Replace placeholder comments in features before publishing.");
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+
 //#endregion
 //#region src/builder/utils.ts
 function cleanInstallMessage(value) {
@@ -390,19 +492,19 @@ function cleanInstallMessage(value) {
 	return trimmed.length > 0 ? trimmed : void 0;
 }
 /**
-* Validate raw preset config from JSON.
+* Validate raw rule config from JSON.
 * Returns the raw config shape (before normalization).
 */
-function validatePresetConfig(config, slug) {
+function validateConfig(config, slug) {
 	try {
-		return presetConfigSchema.parse(config);
+		return ruleConfigSchema.parse(config);
 	} catch (e) {
 		if (e instanceof ZodError) {
 			const messages = e.issues.map((issue) => {
 				const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
 				return `${path}${issue.message}`;
 			});
-			throw new Error(`Invalid preset config for ${slug}:\n  - ${messages.join("\n  - ")}`);
+			throw new Error(`Invalid rule config for ${slug}:\n  - ${messages.join("\n  - ")}`);
 		}
 		throw e;
 	}
@@ -425,34 +527,39 @@ async function sha256(data) {
 	return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 /**
-* Builds a PresetPublishInput from preset input.
+* Builds a RulePublishInput from rule input.
 *
-* PresetInput always has platformFiles array (unified format).
+* RuleInput always has platformFiles array (unified format).
 */
-async function buildPresetPublishInput(options) {
-	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);
+async function buildPublishInput(options) {
+	const { rule, version } = options;
+	if (!NAME_PATTERN.test(rule.name)) throw new Error(`Invalid name "${rule.name}". Names must be lowercase kebab-case.`);
+	const config = validateConfig(rule.config, rule.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 platforms = rule.config.platforms;
+	if (platforms.length === 0) throw new Error(`Rule ${rule.name} must specify at least one platform.`);
+	for (const entry of platforms) ensureKnownPlatform(entry.platform, rule.name);
+	const ruleType = config.type;
+	if (ruleType) {
+		for (const entry of platforms) if (!isValidType(entry.platform, ruleType)) throw new Error(`Platform "${entry.platform}" does not support type "${ruleType}". Rule "${rule.name}" cannot target this platform with type "${ruleType}".`);
+	}
 	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 platformData = rule.platformFiles.find((pf) => pf.platform === entry.platform);
+		if (!platformData) throw new Error(`Rule ${rule.name} is missing files for platform "${entry.platform}".`);
+		if (platformData.files.length === 0) throw new Error(`Rule ${rule.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)
+			readmeContent: platformData.readmeContent?.trim() || rule.readmeContent?.trim() || void 0,
+			licenseContent: platformData.licenseContent?.trim() || rule.licenseContent?.trim() || void 0,
+			installMessage: cleanInstallMessage(platformData.installMessage) || cleanInstallMessage(rule.installMessage)
 		});
 	}
 	return {
-		name: preset.name,
+		name: rule.name,
+		...ruleType && { type: ruleType },
 		title: config.title,
 		description: config.description,
 		tags: config.tags ?? [],
@@ -466,28 +573,28 @@ async function buildPresetPublishInput(options) {
 * 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 RuleInput (single or multi-platform) becomes one item
 * - Each platform variant becomes one bundle
 */
-async function buildPresetRegistry(options) {
+async function buildRegistry(options) {
 	const bundleBase = normalizeBundleBase(options.bundleBase);
-	const items = [];
+	const rules = [];
 	const bundles = [];
-	for (const presetInput of options.presets) {
-		const publishInput = await buildPresetPublishInput({ preset: presetInput });
+	for (const ruleInput of options.rules) {
+		const publishInput = await buildPublishInput({ rule: ruleInput });
 		const slug = publishInput.name;
 		const version = `${publishInput.version ?? 1}.0`;
-		const presetVariants = publishInput.variants.map((v) => ({
+		const ruleVariants = 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)
+			totalSize: v.files.reduce((sum, f) => sum + f.size, 0)
 		}));
-		presetVariants.sort((a, b) => a.platform.localeCompare(b.platform));
-		const item = {
-			kind: "preset",
+		ruleVariants.sort((a, b) => a.platform.localeCompare(b.platform));
+		const rule = {
 			slug,
-			name: publishInput.title,
+			name: publishInput.name,
+			...publishInput.type && { type: publishInput.type },
 			title: publishInput.title,
 			description: publishInput.description,
 			tags: publishInput.tags,
@@ -496,13 +603,14 @@ async function buildPresetRegistry(options) {
 			versions: [{
 				version,
 				isLatest: true,
-				variants: presetVariants
+				variants: ruleVariants
 			}]
 		};
-		items.push(item);
+		rules.push(rule);
 		for (const variant of publishInput.variants) {
 			const bundle = {
 				name: publishInput.name,
+				...publishInput.type && { type: publishInput.type },
 				slug,
 				platform: variant.platform,
 				title: publishInput.title,
@@ -519,13 +627,13 @@ async function buildPresetRegistry(options) {
 			bundles.push(bundle);
 		}
 	}
-	items.sort((a, b) => a.slug.localeCompare(b.slug));
+	rules.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 {
-		items,
+		rules,
 		bundles
 	};
 }
@@ -550,7 +658,10 @@ function normalizeFilePayload(content) {
 	return new Uint8Array(content);
 }
 function encodeFilePayload(data, filePath) {
-	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const decoder = new TextDecoder("utf-8", {
+		fatal: true,
+		ignoreBOM: false
+	});
 	try {
 		return decoder.decode(data);
 	} catch {
@@ -602,40 +713,34 @@ async function sha256Hex(payload) {
 //#endregion
 //#region src/constants.ts
 /**
-* Shared constants for agentrules presets and registry.
+* Shared constants for agentrules.
 */
-/** 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";
+/** Filename for rule configuration */
+const RULE_CONFIG_FILENAME = "agentrules.json";
+/** JSON Schema URL for rule configuration */
+const RULE_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
 /** API root path segment */
 const API_PATH = "api";
-/** Default version identifier for latest preset version */
+/** Default version identifier for latest rule version */
 const LATEST_VERSION = "latest";
 /**
 * API endpoint paths (relative to registry base URL).
 *
 * Note on slug handling:
-* - Slugs may contain slashes (e.g., "username/my-preset") which flow through as path segments
+* - Slugs may contain slashes (e.g., "username/my-rule") which flow through as path segments
 * - The client is responsible for validating values before making requests
 */
 const API_ENDPOINTS = {
-	presets: {
-		base: `${API_PATH}/presets`,
-		unpublish: (slug, version) => `${API_PATH}/presets/${slug}/${version}`
+	rules: {
+		base: `${API_PATH}/rules`,
+		get: (slug) => `${API_PATH}/rules/${slug}`,
+		unpublish: (slug, version) => `${API_PATH}/rules/${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
@@ -656,13 +761,13 @@ async function fetchBundle(bundleUrl) {
 * 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 slug - Content slug (may contain slashes, e.g., "username/my-rule")
 * @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);
+	const url = new URL(API_ENDPOINTS.rules.get(slug), baseUrl);
 	if (version) url.searchParams.set("version", version);
 	let response;
 	try {
@@ -680,47 +785,33 @@ async function resolveSlug(baseUrl, slug, version) {
 		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();
-	}
+	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({
+const ruleVariantBundleSchema = z.object({
 	platform: platformIdSchema,
 	bundleUrl: z.string().min(1),
 	fileCount: z.number().int().nonnegative(),
 	totalSize: z.number().int().nonnegative()
 });
-const presetVariantInlineSchema = z.object({
+const ruleVariantInlineSchema = 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 ruleVariantSchema = z.union([ruleVariantBundleSchema, ruleVariantInlineSchema]);
 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"),
+const resolvedRuleSchema = z.object({
 	slug: z.string().min(1),
 	name: z.string().min(1),
 	title: z.string().min(1),
@@ -728,157 +819,55 @@ const resolvedPresetSchema = z.object({
 	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]);
+const resolveResponseSchema = 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
+* Type guard for rule variant with bundleUrl
 */
 function hasBundle(variant) {
 	return "bundleUrl" in variant;
 }
 /**
-* Type guard for preset variant with inline content
+* Type guard for rule 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) {
+function getLatestVersion(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) {
+function getVersion(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) {
+function getVariant(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) {
+function getPlatforms(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) {
+function hasPlatform(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
 const DEFAULT_CONTEXT = 2;
@@ -903,4 +892,4 @@ function normalizeBundlePath(value) {
 }
 
 //#endregion
-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 };
+export { API_ENDPOINTS, COMMON_LICENSES, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PLATFORM_RULE_TYPES, RULE_CONFIG_FILENAME, RULE_SCHEMA_URL, RULE_TYPE_TUPLE, STATIC_BUNDLE_DIR, buildPublishInput, buildRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeUtf8, fetchBundle, getInstallPath, getLatestVersion, getPlatformConfig, getPlatformFromDir, getPlatforms, getTypeConfig, getValidTypes, getVariant, getVersion, hasBundle, hasInlineContent, hasPlatform, inferInstructionPlatformsFromFileName, inferPlatformFromPath, inferTypeFromPath, isLikelyText, isPlatformDir, isSupportedPlatform, isValidType, licenseSchema, nameSchema, normalizeBundlePath, normalizePlatformEntry, normalizePlatformInput, platformIdSchema, publishVariantInputSchema, resolveResponseSchema, resolveSlug, resolvedRuleSchema, ruleBundleSchema, ruleConfigSchema, rulePublishInputSchema, ruleTypeSchema, ruleVariantSchema, ruleVersionSchema, supportsInstallPath, tagSchema, tagsSchema, titleSchema, toPosixPath, toUint8Array, toUtf8String, validateConfig, validateRule, verifyBundledFileChecksum };