@agentrules/cli 0.2.0 → 0.3.0

package/README.md

@@ -105,7 +105,7 @@ A typical single-platform rule structure is:
 .
 ├── agentrules.json       # Rule config (created by init)
 ├── README.md             # Shown on registry page (optional, not bundled)
-├── LICENSE.md            # Full license text (optional, not bundled)
+├── LICENSE.md            # Full license text (optional, not bundled; LICENSE.txt also supported)
 ├── INSTALL.txt           # Shown after install (optional, not bundled)
 ├── AGENTS.md             # Instruction file (optional)
 └── command/

package/dist/index.js

@@ -63,6 +63,11 @@ const PLATFORMS = {
 				description: "Custom tool",
 				project: "{platformDir}/tool/{name}.ts",
 				global: "{platformDir}/tool/{name}.ts"
+			},
+			skill: {
+				description: "Agent skill",
+				project: "{platformDir}/skill/{name}/SKILL.md",
+				global: "{platformDir}/skill/{name}/SKILL.md"
 			}
 		}
 	},
@@ -112,6 +117,11 @@ const PLATFORMS = {
 				description: "Custom slash command",
 				project: "{platformDir}/commands/{name}.md",
 				global: "{platformDir}/commands/{name}.md"
+			},
+			skill: {
+				description: "Agent skill",
+				project: "{platformDir}/skills/{name}/SKILL.md",
+				global: "{platformDir}/skills/{name}/SKILL.md"
 			}
 		}
 	},
@@ -129,6 +139,11 @@ const PLATFORMS = {
 				description: "Custom prompt",
 				project: null,
 				global: "{platformDir}/prompts/{name}.md"
+			},
+			skill: {
+				description: "Agent skill",
+				project: "{platformDir}/skills/{name}/SKILL.md",
+				global: "{platformDir}/skills/{name}/SKILL.md"
 			}
 		}
 	}
@@ -162,6 +177,21 @@ function getInstallPath({ platform, type, name, scope = "project" }) {
 	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 the relative install path for a type (without the root directory prefix).
+* Returns the path relative to the platform's root directory.
+*
+* Example: For codex instruction with scope="global", returns "AGENTS.md"
+* (not "~/.codex/AGENTS.md")
+*/
+function getRelativeInstallPath({ platform, type, name, scope = "project" }) {
+	const typeConfig = getTypeConfig(platform, type);
+	if (!typeConfig) return null;
+	const template = scope === "project" ? typeConfig.project : typeConfig.global;
+	if (!template) return null;
+	if (template.includes("{name}") && !name) throw new Error(`Missing name for install path: platform="${platform}" type="${type}" scope="${scope}"`);
+	return template.replace("{platformDir}/", "").replace("{platformDir}", "").replace("{name}", name ?? "");
+}
 
 //#endregion
 //#region ../core/src/platform/utils.ts
@@ -250,6 +280,41 @@ function inferTypeFromPath(platform, filePath) {
 	if (!nextDir) return;
 	return getProjectTypeDirMap(platform).get(nextDir);
 }
+/**
+* Get the install directory for a type (parent directory of the install path).
+* For skills, this is the directory containing SKILL.md.
+*/
+function getInstallDir({ platform, type, name }) {
+	const installPath = getInstallPath({
+		platform,
+		type,
+		name,
+		scope: "project"
+	});
+	if (!installPath) return null;
+	const lastSlash = installPath.lastIndexOf("/");
+	if (lastSlash === -1) return null;
+	return installPath.slice(0, lastSlash);
+}
+/**
+* Normalize skill files by finding SKILL.md anchor and adjusting all paths.
+* Strips any existing path prefix to prevent duplication.
+*/
+function normalizeSkillFiles({ files, installDir }) {
+	const marker = files.find((f) => f.path === "SKILL.md" || f.path.endsWith("/SKILL.md"));
+	if (!marker) throw new Error("SKILL.md not found in files");
+	const skillRoot = marker.path === "SKILL.md" ? "." : marker.path.slice(0, marker.path.lastIndexOf("/"));
+	return files.map((f) => {
+		let relative$1;
+		if (skillRoot === ".") relative$1 = f.path;
+		else if (f.path.startsWith(`${skillRoot}/`)) relative$1 = f.path.slice(skillRoot.length + 1);
+		else relative$1 = f.path;
+		return {
+			...f,
+			path: `${installDir}/${relative$1}`
+		};
+	});
+}
 
 //#endregion
 //#region ../core/src/utils/encoding.ts
@@ -3757,7 +3822,7 @@ function normalizeBundleBase(base) {
 }
 function getBundlePath(base, slug, platform, version$2) {
 	const prefix = base ? `${base}/` : "";
-	return `${prefix}${STATIC_BUNDLE_DIR}/${slug}/${platform}/${version$2}`;
+	return `${prefix}${STATIC_BUNDLE_DIR}/${slug}/${version$2}/${platform}.json`;
 }
 function ensureKnownPlatform(platform, slug) {
 	if (!isSupportedPlatform(platform)) throw new Error(`Unknown platform "${platform}" in ${slug}. Supported: ${PLATFORM_IDS.join(", ")}`);
@@ -5534,7 +5599,7 @@ function resolveInstallTarget(platform, type, name, options) {
 			mode: "global",
 			platform,
 			platformDir,
-			globalDir,
+			globalDir: globalRoot,
 			type,
 			name,
 			label: `global path ${globalRoot}`
@@ -5558,17 +5623,20 @@ function resolveInstallTarget(platform, type, name, options) {
 *
 * - Project scope: use file.path directly
 * - Global scope:
-*   - If path starts with platformDir: transform to globalDir
-*   - If type is "multi" and path doesn't start with platformDir: skip (return null)
-*   - Otherwise: use getInstallPath for root-level files (e.g., instruction)
+*   - If path starts with platformDir: strip prefix (target.root is already globalDir)
+*   - If typed bundle and root file: use type template to get relative path
+*   - If freeform bundle and root file: use path as-is (relative to globalDir)
+*
+* IMPORTANT: For global scope, this returns RELATIVE paths only.
+* The caller combines with target.root (which is the expanded globalDir).
 */
 function resolvePath(filePath, target) {
-	const { platform, platformDir, globalDir, type, name, mode } = target;
+	const { platform, platformDir, type, name, mode } = target;
 	if (mode === "project") return filePath;
 	const platformDirPrefix = `${platformDir}/`;
-	if (filePath.startsWith(platformDirPrefix)) return `${globalDir}/${filePath.slice(platformDirPrefix.length)}`;
-	if (!type) return null;
-	return getInstallPath({
+	if (filePath.startsWith(platformDirPrefix)) return filePath.slice(platformDirPrefix.length);
+	if (!type) return filePath;
+	return getRelativeInstallPath({
 		platform,
 		type,
 		name,
@@ -5578,12 +5646,22 @@ function resolvePath(filePath, target) {
 function computeDestinationPath(pathInput, target) {
 	const normalized = normalizeBundlePath(pathInput);
 	if (!normalized) throw new Error(`Unable to derive destination for ${pathInput}. The computed relative path is empty.`);
+	validateBundlePath(normalized, pathInput);
 	const resolvedPath = resolvePath(normalized, target);
 	if (resolvedPath === null) return null;
 	const destination = resolve(target.root, resolvedPath);
 	ensureWithinRoot(destination, target.root);
 	return destination;
 }
+/**
+* Validate bundle path for dangerous patterns.
+* Throws if path contains traversal or home directory references.
+*/
+function validateBundlePath(normalized, original) {
+	if (normalized.includes("..")) throw new Error(`Refusing to install file with path traversal: ${original}`);
+	if (normalized.startsWith("~")) throw new Error(`Refusing to install file with home directory reference: ${original}`);
+	if (normalized.includes("/~/") || normalized.includes("\\~\\")) throw new Error(`Refusing to install file with embedded home directory reference: ${original}`);
+}
 function parseInput(input, explicitPlatform, explicitVersion) {
 	let normalized = input.toLowerCase().trim();
 	let parsedVersion;
@@ -5806,9 +5884,27 @@ async function directoryExists(path$1) {
 
 //#endregion
 //#region src/lib/rule-utils.ts
-const INSTALL_FILENAME = "INSTALL.txt";
-const README_FILENAME = "README.md";
-const LICENSE_FILENAME = "LICENSE.md";
+const SKILL_FILENAME = "SKILL.md";
+/**
+* Parse SKILL.md frontmatter for name and license.
+* Only extracts simple key: value pairs we need for quick publish defaults.
+*/
+function parseSkillFrontmatter(content) {
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match?.[1]) return {};
+	const frontmatter = match[1];
+	const result = {};
+	const nameMatch = frontmatter.match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m);
+	if (nameMatch?.[1]) result.name = nameMatch[1].trim();
+	const licenseMatch = frontmatter.match(/^license:\s*["']?([^"'\n]+)["']?\s*$/m);
+	if (licenseMatch?.[1]) result.license = licenseMatch[1].trim();
+	return result;
+}
+const METADATA_FILES = {
+	install: ["INSTALL.txt"],
+	readme: ["README.md"],
+	license: ["LICENSE.md", "LICENSE.txt"]
+};
 /**
 * Files/directories that are always excluded from rules.
 * These are never useful in a rule bundle.
@@ -5942,9 +6038,9 @@ async function loadRule(ruleDir, overrides) {
 }
 async function collectMetadata(loaded) {
 	const { configDir } = loaded;
-	const installMessage = await readFileIfExists(join(configDir, INSTALL_FILENAME));
-	const readmeContent = await readFileIfExists(join(configDir, README_FILENAME));
-	const licenseContent = await readFileIfExists(join(configDir, LICENSE_FILENAME));
+	const installMessage = await readFirstMatch(configDir, METADATA_FILES.install);
+	const readmeContent = await readFirstMatch(configDir, METADATA_FILES.readme);
+	const licenseContent = await readFirstMatch(configDir, METADATA_FILES.license);
 	return {
 		installMessage,
 		readmeContent,
@@ -5962,6 +6058,34 @@ async function collectPlatformFiles(loaded) {
 		const resolvedSourcePath = sourcePath ?? ".";
 		const filesDir = join(configDir, resolvedSourcePath);
 		log.debug(`Files for ${platform}: source=${resolvedSourcePath}, dir=${filesDir}`);
+		const filesDirExists = await directoryExists(filesDir);
+		const rootExclude = [RULE_CONFIG_FILENAME];
+		if (filesDir === configDir) rootExclude.push(...METADATA_FILES.readme, ...METADATA_FILES.license, ...METADATA_FILES.install);
+		const collectedFiles = filesDirExists ? await collectFiles(filesDir, rootExclude, ignorePatterns) : [];
+		if (collectedFiles.length === 0) {
+			if (!filesDirExists) throw new Error(`Files directory not found: ${filesDir}. Create the directory or set "path" in the platform entry.`);
+			throw new Error(`No files found in ${filesDir}. Rules must include at least one file.`);
+		}
+		if (config$1.type === "skill") {
+			const installDir = getInstallDir({
+				platform,
+				type: "skill",
+				name: config$1.name
+			});
+			if (!installDir) throw new Error(`Platform "${platform}" does not support skill type.`);
+			const normalizedFiles = normalizeSkillFiles({
+				files: collectedFiles,
+				installDir
+			});
+			platformFiles.push({
+				platform,
+				files: normalizedFiles.map((f) => ({
+					path: f.path,
+					content: typeof f.content === "string" ? f.content : new TextDecoder().decode(f.content)
+				}))
+			});
+			continue;
+		}
 		const treatInstructionAsRoot = config$1.type === void 0 || config$1.type === "instruction";
 		const instructionProjectPath = treatInstructionAsRoot ? getInstallPath({
 			platform,
@@ -5969,10 +6093,6 @@ async function collectPlatformFiles(loaded) {
 			scope: "project"
 		}) : null;
 		const instructionContent = instructionProjectPath ? await readFileIfExists(join(configDir, instructionProjectPath)) : void 0;
-		const filesDirExists = await directoryExists(filesDir);
-		const rootExclude = [RULE_CONFIG_FILENAME];
-		if (filesDir === configDir) rootExclude.push(README_FILENAME, LICENSE_FILENAME, INSTALL_FILENAME);
-		const collectedFiles = filesDirExists ? await collectFiles(filesDir, rootExclude, ignorePatterns) : [];
 		const publishFiles = [];
 		const seenPublishPaths = new Set();
 		for (const file of collectedFiles) {
@@ -5992,10 +6112,7 @@ async function collectPlatformFiles(loaded) {
 				content: instructionContent
 			});
 		}
-		if (publishFiles.length === 0) {
-			if (!filesDirExists) throw new Error(`Files directory not found: ${filesDir}. Create the directory or set "path" in the platform entry.`);
-			throw new Error(`No files found in ${filesDir}. Rules must include at least one file.`);
-		}
+		if (publishFiles.length === 0) throw new Error(`No files found in ${filesDir}. Rules must include at least one file.`);
 		platformFiles.push({
 			platform,
 			files: publishFiles
@@ -6064,6 +6181,16 @@ async function readFileIfExists(path$1) {
 	if (await fileExists(path$1)) return await readFile(path$1, "utf8");
 	return;
 }
+/**
+* Try reading files from a list of candidates, return first match.
+*/
+async function readFirstMatch(dir, filenames) {
+	for (const filename of filenames) {
+		const content = await readFileIfExists(join(dir, filename));
+		if (content !== void 0) return content;
+	}
+	return;
+}
 
 //#endregion
 //#region src/lib/zod-validator.ts
@@ -6111,11 +6238,12 @@ async function publish(options = {}) {
 	}
 	if (!dryRun) log.debug(`Authenticated as user, publishing to ${ctx.registry.url}`);
 	const filePath = await getSingleFilePath(path$1);
+	const quickDir = await getQuickPublishDirectory(path$1);
 	let publishInput;
 	if (filePath) {
 		let resolved;
 		try {
-			resolved = await resolveSingleFileInputs({
+			resolved = await resolveQuickPublishInputs({
 				name,
 				platform,
 				type,
@@ -6123,7 +6251,10 @@ async function publish(options = {}) {
 				description,
 				tags,
 				license
-			}, filePath, {
+			}, {
+				type: "file",
+				path: filePath
+			}, {
 				dryRun,
 				yes
 			});
@@ -6138,7 +6269,7 @@ async function publish(options = {}) {
 		const fileSpinner = await log.spinner("Building bundle...");
 		try {
 			publishInput = await buildPublishInput({
-				rule: await buildRuleInputFromSingleFile(resolved),
+				rule: await buildRuleInputFromQuickPublish(resolved),
 				version: version$2
 			});
 			log.debug(`Built publish input for platforms: ${publishInput.variants.map((v) => v.platform).join(", ")}`);
@@ -6159,6 +6290,57 @@ async function publish(options = {}) {
 			ctx
 		});
 	}
+	if (quickDir) {
+		let resolved;
+		try {
+			resolved = await resolveQuickPublishInputs({
+				name,
+				platform,
+				type,
+				title,
+				description,
+				tags,
+				license
+			}, {
+				type: "directory",
+				path: quickDir.path,
+				entryFile: quickDir.entryFile
+			}, {
+				dryRun,
+				yes
+			});
+		} catch (error$2) {
+			const message = getErrorMessage(error$2);
+			log.error(message);
+			return {
+				success: false,
+				error: message
+			};
+		}
+		const dirSpinner = await log.spinner("Building bundle...");
+		try {
+			publishInput = await buildPublishInput({
+				rule: await buildRuleInputFromQuickPublish(resolved),
+				version: version$2
+			});
+			log.debug(`Built publish input for platforms: ${publishInput.variants.map((v) => v.platform).join(", ")}`);
+		} catch (error$2) {
+			const message = getErrorMessage(error$2);
+			dirSpinner.fail("Failed to build bundle");
+			log.error(message);
+			return {
+				success: false,
+				error: message
+			};
+		}
+		return await finalizePublish({
+			publishInput,
+			dryRun,
+			version: version$2,
+			spinner: dirSpinner,
+			ctx
+		});
+	}
 	const spinner$1 = await log.spinner("Validating rule...");
 	const configPath = await resolveConfigPath(path$1);
 	log.debug(`Resolved config path: ${configPath}`);
@@ -6247,19 +6429,34 @@ async function getSingleFilePath(inputPath) {
 	if (basename(inputPath) === RULE_CONFIG_FILENAME) return;
 	return inputPath;
 }
+async function getQuickPublishDirectory(inputPath) {
+	if (!inputPath) return;
+	const pathStat = await stat(inputPath).catch(() => null);
+	if (!pathStat?.isDirectory()) return;
+	const configStat = await stat(`${inputPath}/${RULE_CONFIG_FILENAME}`).catch(() => null);
+	if (configStat?.isFile()) return;
+	const skillPath = `${inputPath}/${SKILL_FILENAME}`;
+	const skillStat = await stat(skillPath).catch(() => null);
+	if (skillStat?.isFile()) return {
+		path: inputPath,
+		type: "skill",
+		entryFile: skillPath
+	};
+	return;
+}
 function normalizePathForInference(value) {
 	return value.replace(/\\/g, "/");
 }
 function stripExtension(value) {
 	return value.replace(/\.[^/.]+$/, "");
 }
-function inferSingleFileDefaults(filePath) {
+function inferFileDefaults(filePath) {
 	const normalized = normalizePathForInference(filePath);
 	const segments = normalized.split("/").filter(Boolean);
 	const fileName = segments.at(-1) ?? "";
 	const instructionPlatforms = inferInstructionPlatformsFromFileName(fileName);
 	if (instructionPlatforms.length > 0) return {
-		type: "instruction",
+		ruleType: "instruction",
 		...instructionPlatforms.length === 1 ? { platform: instructionPlatforms[0] } : {}
 	};
 	const platform = inferPlatformFromPath(filePath);
@@ -6267,11 +6464,22 @@ function inferSingleFileDefaults(filePath) {
 	const inferredType = inferTypeFromPath(platform, filePath);
 	const result = { platform };
 	if (inferredType) {
-		result.type = inferredType;
+		result.ruleType = inferredType;
 		if (inferredType !== "instruction") result.name = normalizeName(stripExtension(fileName));
 	}
 	return result;
 }
+async function inferDirectoryDefaults(_dirPath, entryFile, dirType) {
+	const result = {};
+	if (dirType === "skill") {
+		result.ruleType = "skill";
+		const content = await readFile(entryFile, "utf8");
+		const frontmatter = parseSkillFrontmatter(content);
+		if (frontmatter.name) result.name = normalizeName(frontmatter.name);
+		if (frontmatter.license) result.license = frontmatter.license;
+	}
+	return result;
+}
 function buildConfigPublishOverrides(options) {
 	const overrides = {};
 	if (options.name !== void 0) overrides.name = options.name;
@@ -6283,13 +6491,17 @@ function buildConfigPublishOverrides(options) {
 	if (options.tags !== void 0) overrides.tags = options.tags;
 	return Object.keys(overrides).length > 0 ? overrides : void 0;
 }
-async function resolveSingleFileInputs(options, filePath, ctx) {
-	const inferred = inferSingleFileDefaults(filePath);
+async function resolveQuickPublishInputs(options, source, ctx) {
+	const inferred = source.type === "file" ? inferFileDefaults(source.path) : await inferDirectoryDefaults(source.path, source.entryFile, "skill");
 	const isInteractive = !ctx.yes && process.stdin.isTTY;
-	const hasRequiredArgs = options.name !== void 0 && options.platform !== void 0 && options.type !== void 0;
-	if (!(isInteractive || hasRequiredArgs)) throw new Error("Publishing a single file in non-interactive mode requires --name, --platform, and --type.");
+	const isDirectory = source.type === "directory";
+	const hasRequiredArgs = isDirectory ? options.platform !== void 0 && (options.name !== void 0 || inferred.name !== void 0) : options.name !== void 0 && options.platform !== void 0 && options.type !== void 0;
+	if (!(isInteractive || hasRequiredArgs)) {
+		if (isDirectory) throw new Error("Publishing a directory in non-interactive mode requires --platform (and --name if not in frontmatter).");
+		throw new Error("Publishing a single file in non-interactive mode requires --name, --platform, and --type.");
+	}
 	const selectedPlatforms = options.platform ? parsePlatformSelection(options.platform) : void 0;
-	if (selectedPlatforms && selectedPlatforms.length > 1) throw new Error("Publishing a single file requires exactly one --platform value.");
+	if (selectedPlatforms && selectedPlatforms.length > 1) throw new Error("Quick publish requires exactly one --platform value.");
 	let selectedPlatform = selectedPlatforms?.[0] ? normalizePlatformInput(selectedPlatforms[0]) : inferred.platform;
 	if (!selectedPlatform) {
 		if (!isInteractive) throw new Error("Missing --platform");
@@ -6303,7 +6515,7 @@ async function resolveSingleFileInputs(options, filePath, ctx) {
 		if (p$1.isCancel(selection)) throw new Error("Cancelled");
 		selectedPlatform = selection;
 	}
-	let selectedType = options.type ?? inferred.type;
+	let selectedType = options.type ?? inferred.ruleType;
 	if (!selectedType) {
 		if (!isInteractive) throw new Error("Missing --type");
 		const candidates = getValidTypes(selectedPlatform).filter((t) => supportsInstallPath({
@@ -6322,8 +6534,8 @@ async function resolveSingleFileInputs(options, filePath, ctx) {
 		selectedType = selection;
 	}
 	const platform = selectedPlatform;
-	const type = selectedType;
-	const nameValue = options.name ?? await (async () => {
+	const ruleType = selectedType;
+	const nameValue = options.name ?? inferred.name ?? await (async () => {
 		if (!isInteractive) throw new Error("Missing --name");
 		const input = await p$1.text({
 			message: "Rule name",
@@ -6336,13 +6548,6 @@ async function resolveSingleFileInputs(options, filePath, ctx) {
 	const normalizedName = normalizeName(nameValue);
 	const nameCheck = nameSchema.safeParse(normalizedName);
 	if (!nameCheck.success) throw new Error(nameCheck.error.issues[0]?.message ?? "Invalid name");
-	const bundlePath = getInstallPath({
-		platform,
-		type,
-		name: normalizedName,
-		scope: "project"
-	});
-	if (!bundlePath) throw new Error(`Type "${type}" is not supported for project installs on platform "${platform}".`);
 	const defaultTitle = toTitleCase(normalizedName);
 	const finalTitle = options.title ?? await (async () => {
 		if (!isInteractive) return defaultTitle;
@@ -6375,59 +6580,80 @@ async function resolveSingleFileInputs(options, filePath, ctx) {
 		if (p$1.isCancel(input)) throw new Error("Cancelled");
 		return tagsInputSchema.parse(input);
 	})();
-	const finalLicense = options.license ?? "MIT";
+	const finalLicense = options.license ?? inferred.license ?? "MIT";
 	if (isInteractive && !ctx.dryRun) {
 		log.print("");
 		log.print(ui.header("Quick publish"));
-		log.print(ui.keyValue("File", ui.path(filePath)));
+		log.print(ui.keyValue(isDirectory ? "Directory" : "File", ui.path(source.path)));
 		log.print(ui.keyValue("Name", ui.code(normalizedName)));
 		log.print(ui.keyValue("Title", finalTitle));
 		log.print(ui.keyValue("Description", finalDescription));
 		log.print(ui.keyValue("Platform", platform));
-		log.print(ui.keyValue("Type", type));
-		log.print(ui.keyValue("Installs to", ui.path(bundlePath)));
+		log.print(ui.keyValue("Type", ruleType));
 		if (finalTags.length > 0) log.print(ui.keyValue("Tags", finalTags.join(", ")));
 		log.print("");
 		const confirm = await p$1.confirm({
-			message: "Publish this file?",
+			message: isDirectory ? "Publish this directory?" : "Publish this file?",
 			initialValue: true
 		});
 		if (p$1.isCancel(confirm) || !confirm) throw new Error("Cancelled");
 	}
 	return {
-		filePath,
+		source,
 		name: normalizedName,
 		platform,
-		type,
+		ruleType,
 		title: finalTitle,
 		description: finalDescription,
 		tags: finalTags,
-		license: finalLicense,
-		bundlePath
+		license: finalLicense
 	};
 }
-async function buildRuleInputFromSingleFile(inputs) {
-	const content = await readFile(inputs.filePath);
+async function buildRuleInputFromQuickPublish(inputs) {
 	const config$1 = {
 		$schema: RULE_SCHEMA_URL,
 		name: inputs.name,
-		type: inputs.type,
+		type: inputs.ruleType,
 		title: inputs.title,
 		description: inputs.description,
 		license: inputs.license,
 		tags: inputs.tags,
 		platforms: [{ platform: inputs.platform }]
 	};
+	if (inputs.source.type === "file") {
+		const content = await readFile(inputs.source.path);
+		const bundlePath = getInstallPath({
+			platform: inputs.platform,
+			type: inputs.ruleType,
+			name: inputs.name,
+			scope: "project"
+		});
+		if (!bundlePath) throw new Error(`Type "${inputs.ruleType}" is not supported for project installs on platform "${inputs.platform}".`);
+		return {
+			name: inputs.name,
+			config: config$1,
+			platformFiles: [{
+				platform: inputs.platform,
+				files: [{
+					path: bundlePath,
+					content
+				}]
+			}]
+		};
+	}
+	const loadedConfig = {
+		configPath: `${inputs.source.path}/agentrules.json`,
+		config: {
+			...config$1,
+			platforms: [{ platform: inputs.platform }]
+		},
+		configDir: inputs.source.path
+	};
+	const platformFiles = await collectPlatformFiles(loadedConfig);
 	return {
 		name: inputs.name,
 		config: config$1,
-		platformFiles: [{
-			platform: inputs.platform,
-			files: [{
-				path: inputs.bundlePath,
-				content
-			}]
-		}]
+		platformFiles
 	};
 }
 async function finalizePublish(options) {
@@ -6563,11 +6789,13 @@ async function buildRegistry(options) {
 	await mkdir(outputDir, { recursive: true });
 	const indent$1 = compact ? void 0 : 2;
 	for (const bundle of result.bundles) {
-		const bundleDir = join(outputDir, STATIC_BUNDLE_DIR, bundle.slug, bundle.platform);
-		await mkdir(bundleDir, { recursive: true });
 		const bundleJson = JSON.stringify(bundle, null, indent$1);
-		await writeFile(join(bundleDir, bundle.version), bundleJson);
-		await writeFile(join(bundleDir, LATEST_VERSION), bundleJson);
+		const versionedDir = join(outputDir, STATIC_BUNDLE_DIR, bundle.slug, bundle.version);
+		await mkdir(versionedDir, { recursive: true });
+		await writeFile(join(versionedDir, `${bundle.platform}.json`), bundleJson);
+		const latestDir = join(outputDir, STATIC_BUNDLE_DIR, bundle.slug, LATEST_VERSION);
+		await mkdir(latestDir, { recursive: true });
+		await writeFile(join(latestDir, `${bundle.platform}.json`), bundleJson);
 	}
 	for (const rule of result.rules) {
 		const ruleJson = JSON.stringify(rule, null, indent$1);
@@ -6610,6 +6838,19 @@ async function discoverRuleDirs(inputDir) {
 /** Default rule name when none specified */
 const DEFAULT_RULE_NAME$1 = "my-rule";
 /**
+* Detect if directory contains SKILL.md and extract frontmatter defaults.
+*/
+async function detectSkillDirectory(directory) {
+	const skillPath = join(directory, SKILL_FILENAME);
+	if (!await fileExists(skillPath)) return;
+	const content = await readFile(skillPath, "utf8");
+	const frontmatter = parseSkillFrontmatter(content);
+	return {
+		name: frontmatter.name,
+		license: frontmatter.license
+	};
+}
+/**
 * Initialize a rule in a directory (rule root).
 *
 * Structure:
@@ -6620,14 +6861,17 @@ const DEFAULT_RULE_NAME$1 = "my-rule";
 async function initRule(options) {
 	const ruleDir = options.directory ?? process.cwd();
 	log.debug(`Initializing rule in: ${ruleDir}`);
+	const skillInfo = await detectSkillDirectory(ruleDir);
+	const isSkillDirectory = skillInfo !== void 0;
 	const inferredPlatform = getPlatformFromDir(basename(ruleDir));
 	const platformInputs = options.platforms ?? (inferredPlatform ? [inferredPlatform] : []);
 	if (platformInputs.length === 0) throw new Error(`Cannot determine platform. Specify --platform (${PLATFORM_IDS.join(", ")}).`);
 	const platforms = platformInputs.map(normalizePlatformEntryInput);
-	const name = normalizeName(options.name ?? DEFAULT_RULE_NAME$1);
+	const name = normalizeName(options.name ?? skillInfo?.name ?? DEFAULT_RULE_NAME$1);
 	const title = options.title ?? toTitleCase(name);
 	const description = options.description ?? "";
-	const license = options.license ?? "MIT";
+	const license = options.license ?? skillInfo?.license ?? "MIT";
+	const ruleType = isSkillDirectory ? "skill" : options.type;
 	const platformLabels = platforms.map((p$2) => typeof p$2 === "string" ? p$2 : p$2.platform).join(", ");
 	log.debug(`Rule name: ${name}, platforms: ${platformLabels}`);
 	const configPath = join(ruleDir, RULE_CONFIG_FILENAME);
@@ -6635,7 +6879,7 @@ async function initRule(options) {
 	const config$1 = {
 		$schema: RULE_SCHEMA_URL,
 		name,
-		...options.type && { type: options.type },
+		...ruleType && { type: ruleType },
 		title,
 		version: 1,
 		description,
@@ -6701,8 +6945,22 @@ function checkTags(value) {
 async function initInteractive(options) {
 	const { directory, name: nameOption, title: titleOption, description: descriptionOption, platforms: platformsOption, platformPaths, license: licenseOption } = options;
 	let { force } = options;
-	const defaultName = nameOption ?? DEFAULT_RULE_NAME;
 	p.intro("Create a new rule");
+	const skillInfo = await detectSkillDirectory(directory);
+	let useSkillDefaults = false;
+	if (skillInfo) {
+		const confirm = await p.confirm({
+			message: `Detected SKILL.md${skillInfo.name ? ` (${skillInfo.name})` : ""}. Initialize as skill?`,
+			initialValue: true
+		});
+		if (p.isCancel(confirm)) {
+			p.cancel("Cancelled");
+			process.exit(0);
+		}
+		useSkillDefaults = confirm;
+	}
+	const defaultName = useSkillDefaults && skillInfo?.name ? skillInfo.name : nameOption ?? DEFAULT_RULE_NAME;
+	const defaultLicense = useSkillDefaults && skillInfo?.license ? skillInfo.license : licenseOption ?? "MIT";
 	const validatedPlatforms = [];
 	if (platformsOption) for (const platform of platformsOption) {
 		if (!isSupportedPlatform(platform)) {
@@ -6728,6 +6986,7 @@ async function initInteractive(options) {
 	})();
 	const platformEntries = await (async () => {
 		if (selectedPlatforms.length === 0) return [];
+		if (useSkillDefaults) return selectedPlatforms;
 		const hasCompletePathMapping = selectedPlatforms.every((platform) => {
 			const value = platformPaths?.[platform];
 			return typeof value === "string" && value.trim().length > 0;
@@ -6777,12 +7036,18 @@ async function initInteractive(options) {
 		force = true;
 	}
 	const result = await p.group({
-		name: () => p.text({
-			message: "Rule name",
-			placeholder: normalizeName(defaultName),
-			defaultValue: normalizeName(defaultName),
-			validate: check(nameSchema)
-		}),
+		name: () => {
+			const normalizedDefault = normalizeName(defaultName);
+			return p.text({
+				message: "Rule name",
+				placeholder: normalizedDefault,
+				defaultValue: normalizedDefault,
+				validate: (value) => {
+					if (!value || value.trim() === "") return;
+					return check(nameSchema)(value);
+				}
+			});
+		},
 		title: ({ results }) => {
 			const defaultTitle = titleOption ?? toTitleCase(results.name ?? defaultName);
 			return p.text({
@@ -6803,7 +7068,6 @@ async function initInteractive(options) {
 			validate: checkTags
 		}),
 		license: async () => {
-			const defaultLicense = licenseOption ?? "MIT";
 			const choice = await p.select({
 				message: "License",
 				options: [...COMMON_LICENSES.map((id) => ({
@@ -6840,6 +7104,7 @@ async function initInteractive(options) {
 	const initOptions = {
 		directory,
 		name: result.name,
+		type: useSkillDefaults ? "skill" : void 0,
 		title: result.title.trim() || void 0,
 		description: result.description,
 		tags: parseTags(result.tags),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrules/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": "Brian Cheung <bcheung.dev@gmail.com> (https://github.com/bcheung)",
   "license": "MIT",
   "homepage": "https://agentrules.directory",
@@ -53,7 +53,7 @@
     "clean": "rm -rf node_modules dist .turbo"
   },
   "dependencies": {
-    "@agentrules/core": "0.2.0",
+    "@agentrules/core": "0.3.0",
     "@clack/prompts": "^0.11.0",
     "chalk": "^5.4.1",
     "commander": "^12.1.0",